CML Chain

https://docs.rs/cml-chain/latest/
Admin
CML Chain is a Rust library providing serialization, deserialization, and manipulation of Cardano...
Tokens:598,871
Snippets:2,785
Trust Score:9.7
Update:1 year ago
Show doc for...
Tokens:
Raw
### Build Transaction with Reference Input

Source: https://docs.rs/cml-chain/latest/src/cml_chain/builders/tx_builder

This snippet illustrates how to construct a Cardano transaction that includes a reference input. It utilizes `SingleInputBuilder` to define the input and adds it to the `tx_builder`. The example also shows the setup for creating an account and deriving a public key.

```rust
let mut tx_builder = create_default_tx_builder();
        let change_key = root_key_15()
            .derive(harden(1852))
            .derive(harden(1815))
            .derive(harden(0))
            .derive(1)
            .derive(0)
            .to_public();
        let (_, (_, stake_cred), addr_net_0) = create_account();
        let input = {
            SingleInputBuilder::new(
                TransactionInput::new(genesis_id(), 0),
                TransactionOutput::new(addr_net_0.clone(), Value::from(5_000_000), None, None),
            )
            .payment_key()
            .unwrap()
        };
        tx_builder.add_input(input).unwrap();
        //add collateral
        {
            let input_utxo = TransactionOutputBuilder::new()
```

--------------------------------

### Rust: Metadata Implementation - Set and Get

Source: https://docs.rs/cml-chain/latest/cml_chain/auxdata/type

Enables setting and retrieving metadata entries based on a TransactionMetadatumLabel. The `set` method replaces existing entries, while `get` retrieves a single entry (handling potential duplicates by returning the first).

```rust
pub fn set( &mut self, label: TransactionMetadatumLabel, datum: TransactionMetadatum, )
pub fn get( &self, label: TransactionMetadatumLabel, ) -> Option<&TransactionMetadatum>

```

--------------------------------

### Rust Vec::with_capacity() Example

Source: https://docs.rs/cml-chain/latest/cml_chain/type

Illustrates creating a Vec<T> with a specified initial capacity using `with_capacity()`. This pre-allocates memory, potentially improving performance by reducing reallocations when adding elements. The example shows pre-allocation and subsequent additions without reallocation, and a case that might trigger reallocation.

```rust
let mut vec = Vec::with_capacity(10);

// The vector contains no items, even though it has capacity for more
assert_eq!(vec.len(), 0);
assert!(vec.capacity() >= 10);

// These are all done without reallocating...
for i in 0..10 {
    vec.push(i);
}
assert_eq!(vec.len(), 10);
assert!(vec.capacity() >= 10);

// ...but this may make the vector reallocate
vec.push(11);
assert_eq!(vec.len(), 11);
assert!(vec.capacity() >= 11);

// A vector of a zero-sized type will always over-allocate, since no
// allocation is necessary
let vec_units = Vec::<()>::with_capacity(10);
assert_eq!(vec_units.capacity(), usize::MAX);
```

--------------------------------

### Rust: NetworkInfo Network Constructors

Source: https://docs.rs/cml-chain/latest/cml_chain/genesis/network_info/struct

Offers convenient static methods to create NetworkInfo instances for specific Cardano networks. It includes constructors for mainnet, testnet, preview, preprod, and sancho_testnet, with a note recommending preview/preprod over the old testnet.

```rust
pub fn testnet() -> Self

pub fn mainnet() -> Self

pub fn preview() -> Self

pub fn preprod() -> Self

pub fn sancho_testnet() -> Self
```

--------------------------------

### GET /website/rs_cml-chain/rchunks

Source: https://docs.rs/cml-chain/latest/cml_chain/utils/struct

Returns an iterator over chunks of `chunk_size` elements starting from the end of the slice. The last chunk may be smaller if `chunk_size` does not divide the slice length.

```APIDOC
## GET /website/rs_cml-chain/rchunks

### Description
Returns an iterator over `chunk_size` elements of the slice at a time, starting at the end of the slice.

### Method
GET

### Endpoint
`/website/rs_cml-chain/rchunks`

### Parameters
#### Path Parameters
None

#### Query Parameters
- **chunk_size** (usize) - Required - The size of each chunk.

#### Request Body
- **slice** (&[T]) - Required - The slice to get chunks from.

### Request Example
```json
{
  "slice": [1, 2, 3, 4, 5],
  "chunk_size": 2
}
```

### Response
#### Success Response (200)
- **chunks** (RChunks<'_, T>) - An iterator yielding slices of size `chunk_size` (or smaller for the last chunk).

#### Response Example
```json
{
  "chunks": [
    [4, 5],
    [2, 3],
    [1]
  ]
}
```

### Panics
Panics if `chunk_size` is zero.
```

--------------------------------

### Check if Slice Starts With Prefix (Rust)

Source: https://docs.rs/cml-chain/latest/cml_chain/utils/struct

Verifies if a given slice (`needle`) is a prefix of another slice or identical to it. An empty `needle` will always return `true`. The examples demonstrate checking for various prefix lengths and edge cases.

```Rust
let v = [10, 40, 30];
assert!(v.starts_with(&[10]));
assert!(v.starts_with(&[10, 40]));
assert!(v.starts_with(&v));
assert!(!v.starts_with(&[50]));
assert!(!v.starts_with(&[10, 50]));
```

```Rust
let v = &[10, 40, 30];
assert!(v.starts_with(&[]));
let v: &[u8] = &[];
assert!(v.starts_with(&[]));
```

--------------------------------

### Initialize TransactionOutputBuilder (Rust)

Source: https://docs.rs/cml-chain/latest/cml_chain/builders/output_builder/struct

Provides methods to create and configure a TransactionOutputBuilder. The `new` function initializes an empty builder, while `with_address`, `with_communication_data`, `with_data`, and `with_reference_script` allow setting specific fields.

```rust
pub fn new() -> Self
```

```rust
pub fn with_address(self, address: Address) -> Self
```

```rust
pub fn with_communication_data(self, datum: PlutusData) -> Self
```

```rust
pub fn with_data(self, datum: DatumOption) -> Self
```

```rust
pub fn with_reference_script(self, script_ref: ScriptRef) -> Self
```

--------------------------------

### Rust: Initialize ProposalBuilder

Source: https://docs.rs/cml-chain/latest/src/cml_chain/builders/proposal_builder

Demonstrates the initialization of the ProposalBuilder struct. It includes the implementation for `new` and `default` methods, setting up an empty ProposalBuilderResult.

```rust
impl Default for ProposalBuilder {
    fn default() -> Self {
        Self::new()
    }
}

impl ProposalBuilder {
    pub fn new() -> Self {
        Self {
            result: ProposalBuilderResult::default(),
        }
    }
// ... other methods
```

--------------------------------

### Get Element Index with element_offset (Rust)

Source: https://docs.rs/cml-chain/latest/cml_chain/utils/struct

Illustrates the use of the experimental `element_offset` method to find the index of an element within a slice based on its memory address, not its value. This is useful for iterators but does not perform element comparison. It returns `Some(index)` if the element reference points to the start of an element, and `None` otherwise.

```rust
#![feature(substr_range)]

let nums: &[u32] = &[1, 7, 1, 1];
let num = &nums[2];

assert_eq!(num, &1);
assert_eq!(nums.element_offset(num), Some(2));
```

```rust
#![feature(substr_range)]

let arr: &[[u32; 2]] = &[[0, 1], [2, 3]];
let flat_arr: &[u32] = arr.as_flattened();

let ok_elm: &[u32; 2] = flat_arr[0..2].try_into().unwrap();
let weird_elm: &[u32; 2] = flat_arr[1..3].try_into().unwrap();

assert_eq!(ok_elm, &[0, 1]);
assert_eq!(weird_elm, &[1, 2]);

assert_eq!(arr.element_offset(ok_elm), Some(0)); // Points to element 0
assert_eq!(arr.element_offset(weird_elm), None); // Points between element 0 and 1
```

--------------------------------

### Build Cardano Transaction with Collateral and Metadata (Rust)

Source: https://docs.rs/cml-chain/latest/src/cml_chain/builders/tx_builder

This snippet demonstrates building a Cardano transaction, including adding a UTXO as collateral, setting metadata, defining transaction fees, and specifying execution units for redeemers. It also includes assertions to verify the script data hash before and after building the final transaction.

```rust
                .with_address(Address::from_bech32("addr1q9tzwgthsm4hs8alk5v3rgjn7nf9pldlmnc3nrns6dvct2dqzvgjxvajrmzsvwh9fucmp65gxc6mv3fskurctfyuj5zqc7q30l").unwrap())
                .next()
                .unwrap()
                .with_value(5000000)
                .build()
                .unwrap();
            tx_builder
                .add_collateral(
                    SingleInputBuilder::new(
                        TransactionInput::new(
                            TransactionHash::from_hex(
                                "a90a895d07049afc725a0d6a38c6b82218b8d1de60e7bd70ecdd58f1d9e1218b",
                            )
                            .unwrap(),
                            0,
                        ),
                        input_utxo.output,
                    )
                    .payment_key()
                    .unwrap(),
                )
                .unwrap();
        }

        // metadata
        {
            let mut map = MetadatumMap::new();
            map.set(
                TransactionMetadatum::new_int(0u64.into()),
                TransactionMetadatum::new_bytes(hex::decode("d866820080").unwrap()).unwrap(),
            );

            let mut aux_data = AuxiliaryData::new();
            aux_data
                .metadata_mut()
                .set(405, TransactionMetadatum::new_map(map));
            tx_builder.add_auxiliary_data(aux_data);
        }

        tx_builder.set_fee(897753);

        let mut tx_redeemer_builder = tx_builder
            .build_for_evaluation(
                ChangeSelectionAlgo::Default,
                &Address::from_bech32("addr1wx468s53gytznzs5dt6hmq2kk9vr7xplcpwq4fywa9d7cug7fd0ed")
                    .unwrap(),
            )
            .unwrap();

        let fake_script_hash = tx_redeemer_builder.draft_body().script_data_hash.unwrap();
        assert_eq!(
            fake_script_hash.to_hex(),
            "0000000000000000000000000000000000000000000000000000000000000000"
        );
        {
            tx_redeemer_builder.set_exunits(
                RedeemerWitnessKey::new(RedeemerTag::Spend, 0),
                ExUnits::new(5000000, 2000000000),
            );
            tx_builder.set_exunits(
                RedeemerWitnessKey::new(RedeemerTag::Spend, 0),
                ExUnits::new(5000000, 2000000000),
            );
        }
        let signed_tx_builder = tx_builder
            .build(
                ChangeSelectionAlgo::Default,
                &Address::from_bech32("addr1wx468s53gytznzs5dt6hmq2kk9vr7xplcpwq4fywa9d7cug7fd0ed")
                    .unwrap(),
            )
            .unwrap();
        let real_script_hash = signed_tx_builder.body.script_data_hash.as_ref().unwrap();
        assert_eq!(
            real_script_hash.to_hex(),
            "5d5863643ea0687f9ca3ea903e9d86d81787373da1ebf196206c31f29608ce9b"
        );

        let tx = &signed_tx_builder.body;
        assert_eq!(hex::encode(tx.to_cbor_bytes()), "a700d9010281825820473899cb48414442ea107735f7fc3e020f0293122e9d05e4be6f03ffafde5a0c00018283581d71aba3c2914116298a146af57d8156b1583f183fc05c0aa48ee95bec71821a001c41caa1581c6bec713b08a2d7c64baa3596d200b41b560850919d72e634944f2d52a14f537061636542756442696433303533015820f7f2f57c58b5e4872201ab678928b0d63935e82d022d385e1bad5bfe347e89d8825839015627217786eb781fbfb51911a253f4d250fdbfdcf1198e70d35985a9a013112333b21ec5063ae54f31b0ea883635b64530b70785a49c95041a040228dd021a000db2d907582029ed935cc80249c4de9f3e96fdcea6b7da123a543bbe75fffe9e2c66119e426d0b58205d5863643ea0687f9ca3ea903e9d86d81787373da1ebf196206c31f29608ce9b0dd9010281825820a90a895d07049afc725a0d6a38c6b82218b8d1de60e7bd70ecdd58f1d9e1218b000ed9010281581c1c616f1acb460668a9b2f123c80372c2adad3583b9c6cd2b1deeed1c")
    }

    #[test]
    fn test_collateral() {
        let mut tx_builder = create_realistic_tx_builder();

        // variant of the tx 18565ab3c960c000531e5b359432397907d663c0ac5f5dbae80e1bf88d25c8a0 on mainnet

        let mut spacebudz_asset = MultiAsset::new();
        spacebudz_asset.set(
            PolicyId::from_hex("6bec713b08a2d7c64baa3596d200b41b560850919d72e634944f2d52").unwrap(),
            AssetName::new(hex::decode("537061636542756442696433303533").unwrap()).unwrap(),
            1,
        );

        // not the real private key used for the tx on Cardano mainnet
        let private_key = PrivateKey::from_normal_bytes(
            &hex::decode("c660e50315d76a53d80732efda7630cae8885dfb85c46378684b3c6103e1284a")
                .unwrap(),
        )
        .unwrap();

        // add input
        {

```

--------------------------------

### Create Full TransactionBuilder Configuration

Source: https://docs.rs/cml-chain/latest/src/cml_chain/builders/tx_builder

This function builds a comprehensive TransactionBuilder configuration, including fee algorithm, deposits, size limits, execution unit prices, and collateral settings. It returns a configured TransactionBuilder instance.

```rust
fn create_tx_builder_full(
    linear_fee: LinearFee,
    pool_deposit: u64,
    key_deposit: u64,
    max_val_size: u32,
    coins_per_utxo_byte: u64,
) -> TransactionBuilder {
    let cfg = TransactionBuilderConfigBuilder::default()
        .fee_algo(linear_fee)
        .pool_deposit(pool_deposit)
        .key_deposit(key_deposit)
        .max_value_size(max_val_size)
        .max_tx_size(MAX_TX_SIZE)
        .coins_per_utxo_byte(coins_per_utxo_byte)
        .ex_unit_prices(ExUnitPrices::new(
            SubCoin::new(577, 10000),
            SubCoin::new(721, 10000000),
        ))
        .collateral_percentage(150)
        .max_collateral_inputs(3)
        .cost_models(plutus_alonzo_cost_models())
        .build()
        .unwrap();
    TransactionBuilder::new(cfg)
}
```

--------------------------------

### Serialize Validity Interval Start in Rust CBOR

Source: https://docs.rs/cml-chain/latest/src/cml_chain/transaction/serialization

Serializes the validity interval start time using CBOR. It writes an unsigned integer tag followed by the unsigned integer representation of the start time. Dependencies include cbor_event library and fit_sz.

```rust
serializer.write_unsigned_integer_sz(
                            8u64,
                            fit_sz(
                                8u64,
                                self.encodings
                                    .as_ref()
                                    .map(|encs| encs.validity_interval_start_key_encoding)
                                    .unwrap_or_default(),
                                force_canonical,
                            ),
                        )?;
                        serializer.write_unsigned_integer_sz(
                            *field,
                            fit_sz(
                                *field,
                                self.encodings
```

--------------------------------

### TreasuryWithdrawalsAction Constructor

Source: https://docs.rs/cml-chain/latest/cml_chain/governance/struct

Provides a constructor for creating new instances of TreasuryWithdrawalsAction.

```APIDOC
## Constructor for TreasuryWithdrawalsAction

### Description
Creates a new `TreasuryWithdrawalsAction` instance.

### Method
`new`

### Parameters
- **withdrawal** (OrderedHashMap<RewardAccount, Coin>) - Required - The map of reward accounts to coins for withdrawal.
- **policy_hash** (Option<ScriptHash>) - Optional - The policy hash associated with the withdrawal.
```

--------------------------------

### Rust AssetBundle Get Value

Source: https://docs.rs/cml-chain/latest/src/cml_chain/assets/utils

Implements a `get` method for `AssetBundle<T>` to retrieve the value of a specific asset given a policy ID and asset name. It returns an `Option<T>` containing the value if found, or `None` otherwise. This method chains `get` and `and_then` for safe access.

```Rust
impl<T> AssetBundle<T>
where
    T: num::CheckedAdd + num::CheckedSub + num::Zero + num::Bounded + Copy + Clone,
{
    /// Get the value of policy_id:asset_name if it exists.
    pub fn get(&self, policy_id: &PolicyId, asset_name: &AssetName) -> Option<T> {
        self.0
            .get(policy_id)
            .and_then(|assets| assets.get(asset_name))
            .copied()
    }
}
```

--------------------------------

### LinkedHashMap: Get Capacity (Rust)

Source: https://docs.rs/cml-chain/latest/cml_chain/assets/utils/struct

Shows how to get the current capacity of a LinkedHashMap. Capacity represents the number of elements the map can hold before it needs to reallocate memory.

```Rust
use linked_hash_map::LinkedHashMap;
let mut map: LinkedHashMap<i32, &str> = LinkedHashMap::new();
let capacity = map.capacity();
```

--------------------------------

### Rust: Build Transaction with Change and Verify Balances

Source: https://docs.rs/cml-chain/latest/src/cml_chain/builders/tx_builder

This snippet demonstrates building a transaction with the possibility of adding change, setting a Time To Live (TTL), and verifying that the sum of explicit and implicit inputs equals the sum of explicit outputs plus the fee. It uses the `tx_builder` to manage transaction components.

```Rust
    let added_change = tx_builder.add_change_if_needed_for_tests(&change_addr);
    assert!(!added_change.unwrap());
    assert_eq!(tx_builder.outputs.len(), 1);
    assert_eq!(
        tx_builder
            .get_explicit_input()
            .unwrap()
            .checked_add(&tx_builder.get_implicit_input().unwrap())
            .unwrap(),
        tx_builder
            .get_explicit_output()
            .unwrap()
            .checked_add(&Value::from(tx_builder.get_fee_if_set().unwrap()))
            .unwrap()
    );
    let _final_tx = tx_builder.build_body(); // just test that it doesn't throw
```

--------------------------------

### Get Metadata Datum by String Key (Rust)

Source: https://docs.rs/cml-chain/latest/cml_chain/auxdata/metadata/struct

A convenience function to retrieve a metadata datum using a string representation of the key. It internally calls the `get` method.

```rust
pub fn get_str(&self, key: &str) -> Option<&TransactionMetadatum>
```

--------------------------------

### SingleCertificateBuilder Methods

Source: https://docs.rs/cml-chain/latest/cml_chain/builders/certificate_builder/struct

This section details the methods available for the SingleCertificateBuilder, including initialization, skipping witnesses, and adding payment or script details.

```APIDOC
## SingleCertificateBuilder

### Description
Represents a builder for constructing a single certificate.

### Methods

#### `new(cert: Certificate) -> Self`

*   **Description**: Creates a new instance of `SingleCertificateBuilder` with the provided `Certificate`.
*   **Method**: `POST` (conceptual, as this is a builder pattern)
*   **Endpoint**: `/` (N/A for builder methods)

#### `skip_witness(self) -> CertificateBuilderResult`

*   **Description**: Skips the witness step for the certificate. Particularly useful for `StakeRegistration` which doesn’t require witnessing.
*   **Method**: `POST` (conceptual)
*   **Endpoint**: `/skip-witness` (N/A)

#### `payment_key(self) -> Result<CertificateBuilderResult, CertBuilderError>`

*   **Description**: Sets the payment key for the certificate.
*   **Method**: `POST` (conceptual)
*   **Endpoint**: `/payment-key` (N/A)

#### `native_script(self, native_script: NativeScript, witness_info: NativeScriptWitnessInfo) -> Result<CertificateBuilderResult, CertBuilderError>`

*   **Description**: Adds a native script and witness information to the certificate. Signer keys don’t have to be set initially.
*   **Method**: `POST` (conceptual)
*   **Endpoint**: `/native-script` (N/A)
*   **Request Body**: 
    *   `native_script` (NativeScript) - Required - The native script to add.
    *   `witness_info` (NativeScriptWitnessInfo) - Required - Information about the witnesses for the native script.

#### `plutus_script(self, partial_witness: PartialPlutusWitness, required_signers: RequiredSigners) -> Result<CertificateBuilderResult, CertBuilderError>`

*   **Description**: Adds a Plutus script and required signers to the certificate.
*   **Method**: `POST` (conceptual)
*   **Endpoint**: `/plutus-script` (N/A)
*   **Request Body**: 
    *   `partial_witness` (PartialPlutusWitness) - Required - Partial witness information for the Plutus script.
    *   `required_signers` (RequiredSigners) - Required - The list of required signers.
```

--------------------------------

### Deserialize Validity Interval Start in Rust

Source: https://docs.rs/cml-chain/latest/src/cml_chain/transaction/serialization

Deserializes the validity interval start time from an unsigned integer in the CBOR stream. It ensures that this field is not duplicated and handles potential deserialization errors, annotating them with the field name.

```rust
2492                        (8, key_enc) =>  {
                            if validity_interval_start.is_some() {
                                return Err(DeserializeFailure::DuplicateKey(Key::Uint(8)).into());
                            }
                            let (tmp_validity_interval_start, tmp_validity_interval_start_encoding) = (|| -> Result<_, DeserializeError> {
                                read_len.read_elems(1)?;
                                raw.unsigned_integer_sz().map_err(Into::<DeserializeError>::into).map(|(x, enc)| (x, Some(enc)))
                            })().map_err(|e| e.annotate("validity_interval_start"))?;
                            validity_interval_start = Some(tmp_validity_interval_start);
                            validity_interval_start_encoding = tmp_validity_interval_start_encoding;
                            validity_interval_start_key_encoding = Some(key_enc);
                            orig_deser_order.push(7);
                        },
```

--------------------------------

### Build Tx Exact Change Example in Rust

Source: https://docs.rs/cml-chain/latest/src/cml_chain/builders/tx_builder

Demonstrates building a transaction where the exact ADA amount is provided, including change. It utilizes `create_tx_builder_with_fee` and `add_change_if_needed_for_tests` to verify correct change calculation. Asserts ensure the transaction has the expected number of outputs and the correct change amount.

```rust
fn build_tx_exact_change() {
        // transactions where we have exactly enough ADA to add change should pass
        let mut tx_builder = create_tx_builder_with_fee(create_linear_fee(0, 0));
        let change_key = root_key_15()
            .derive(harden(1852))
            .derive(harden(1815))
            .derive(harden(0))
            .derive(1)
            .derive(0)
            .to_public();
        let (_, (_, stake_cred), addr_net_0) = create_account();

        let input = {
            SingleInputBuilder::new(
                TransactionInput::new(genesis_id(), 0),
                TransactionOutput::new(addr_net_0.clone(), Value::from(542), None, None),
            )
            .payment_key()
            .unwrap()
        };
        tx_builder.add_input(input).unwrap();

        tx_builder
            .add_output(
                TransactionOutputBuilder::new()
                    .with_address(addr_net_0)
                    .next()
                    .unwrap()
                    .with_value(222)
                    .build()
                    .unwrap(),
            )
            .unwrap();
        tx_builder.set_ttl(0);

        let change_cred = StakeCredential::new_pub_key(change_key.to_raw_key().hash());
        let change_addr =
            BaseAddress::new(NetworkInfo::testnet().network_id(), change_cred, stake_cred)
                .to_address();
        let added_change = tx_builder
            .add_change_if_needed_for_tests(&change_addr)
            .unwrap();
        assert!(added_change);
        let final_tx = tx_builder.build_body().unwrap();
        assert_eq!(final_tx.outputs.len(), 2);
        assert_eq!(final_tx.outputs[1].amount().coin, 320);
    }
```

--------------------------------

### Rust Script Constructors for Cardano

Source: https://docs.rs/cml-chain/latest/src/cml_chain/lib

Provides `new` functions for creating instances of each `Script` variant. These constructors initialize the script with default `len_encoding` and `None` for `tag_encoding`. This simplifies the creation of script objects.

```rust
impl Script {
    pub fn new_native(script: NativeScript) -> Self {
        Self::Native {
            script,
            len_encoding: LenEncoding::default(),
            tag_encoding: None,
        }
    }

    pub fn new_plutus_v1(script: PlutusV1Script) -> Self {
        Self::PlutusV1 {
            script,
            len_encoding: LenEncoding::default(),
            tag_encoding: None,
        }
    }

    pub fn new_plutus_v2(script: PlutusV2Script) -> Self {
        Self::PlutusV2 {
            script,
            len_encoding: LenEncoding::default(),
            tag_encoding: None,
        }
    }

    pub fn new_plutus_v3(script: PlutusV3Script) -> Self {
        Self::PlutusV3 {
            script,
            len_encoding: LenEncoding::default(),
            tag_encoding: None,
        }
    }
}
```

--------------------------------

### Rust MetadatumMap Get Str Method

Source: https://docs.rs/cml-chain/latest/src/cml_chain/auxdata/metadata

A convenience method to retrieve a metadatum by its string representation. It first converts the input string to a `TransactionMetadatum::new_text` and then uses the `get` method to find the corresponding metadatum.

```rust
pub fn get_str(&self, key: &str) -> Option<&TransactionMetadatum> {
    self.get(&TransactionMetadatum::new_text(key.to_owned()).ok()?)
}
```

--------------------------------

### Derive Keys and Build Transaction with Auxiliary Data in Rust

Source: https://docs.rs/cml-chain/latest/src/cml_chain/builders/tx_builder

This snippet demonstrates deriving public keys for spending and staking, creating a base address, and building a transaction with inputs, outputs, and auxiliary data. It includes setting transaction fee, TTL, and adding native scripts. It also verifies transaction integrity and serialization.

```rust
            .derive(harden(0))
            .derive(0)
            .derive(0)
            .to_public();
            let stake = root_key_15()
            .derive(harden(1854)) //multisig
            .derive(harden(1815))
            .derive(harden(0))
            .derive(2)
            .derive(0)
            .to_public();

            let spend_cred = StakeCredential::new_pub_key(spend.to_raw_key().hash());
            let stake_cred = StakeCredential::new_pub_key(stake.to_raw_key().hash());
            let addr_net_0 = 
                BaseAddress::new(NetworkInfo::testnet().network_id(), spend_cred, stake_cred)
                .to_address();
            let input = {
                SingleInputBuilder::new(
                    TransactionInput::new(genesis_id(), 0),
                    TransactionOutput::new(addr_net_0.clone(), Value::from(1_000_000), None, None),
                )
                .payment_key()
                .unwrap()
            };
            tx_builder.add_input(input).unwrap();
            tx_builder
                .add_output(
                    TransactionOutputBuilder::new()
                        .with_address(addr_net_0)
                        .next()
                        .unwrap()
                        .with_value(999_000)
                        .build()
                        .unwrap(),
                )
                .unwrap();
            tx_builder.set_ttl(1000);
            tx_builder.set_fee(1_000);

            let mut auxiliary_data = AuxiliaryData::new();
            let mut pubkey_native_scripts = Vec::new();
            let mut oneof_native_scripts = Vec::new();

            let spending_hash = spend.to_raw_key().hash();
            pubkey_native_scripts.push(NativeScript::new_script_pubkey(spending_hash));
            oneof_native_scripts.push(NativeScript::new_script_n_of_k(1, pubkey_native_scripts));
            auxiliary_data.add_native_scripts(oneof_native_scripts);
            tx_builder.add_auxiliary_data(auxiliary_data.clone());

            let body = tx_builder.build_body().unwrap();

            assert_eq!(tx_builder.outputs.len(), 1);
            assert_eq!(
                tx_builder
                    .get_explicit_input()
                    .unwrap()
                    .checked_add(&tx_builder.get_implicit_input().unwrap())
                    .unwrap(),
                tx_builder
                    .get_explicit_output()
                    .unwrap()
                    .checked_add(&Value::from(tx_builder.get_fee_if_set().unwrap()))
                    .unwrap()
            );

            let mut witness_set = TransactionWitnessSet::new();

            witness_set.vkeywitnesses = Some(
                vec![make_vkey_witness(
                    &hash_transaction(&body),
                    &PrivateKey::from_normal_bytes(
                        &hex::decode(
                            "c660e50315d76a53d80732efda7630cae8885dfb85c46378684b3c6103e1284a",
                        )
                        .unwrap(),
                    )
                    .unwrap(),
                )]
                .into(),
            );

            let final_tx = Transaction::new(body, witness_set, true, None);
            let deser_t = Transaction::from_cbor_bytes(&final_tx.to_cbor_bytes()).unwrap();
            assert_eq!(deser_t.to_cbor_bytes(), final_tx.to_cbor_bytes());
            assert_eq!(
                deser_t.body.auxiliary_data_hash.unwrap(),
                hash_auxiliary_data(&auxiliary_data)
            );

```

--------------------------------

### Get Mutable Element or Sub-slice by Index (Rust)

Source: https://docs.rs/cml-chain/latest/cml_chain/utils/struct

Safely retrieves a mutable reference to an element or sub-slice. Similar to `get` but allows modification. Returns None if the index is out of bounds. Requires a mutable reference to the slice and supports various index types.

```rust
pub fn get_mut<I>( &mut self, index: I, ) -> Option<&mut <I as SliceIndex<[T]>>::Output>
where I: SliceIndex<[T]>

// Example:
let x = &mut [0, 1, 2];

if let Some(elem) = x.get_mut(1) {
    *elem = 42;
}
assert_eq!(x, &[0, 42, 2]);
```

--------------------------------

### Handle Minting and Burning Assets in Rust TxBuilder

Source: https://docs.rs/cml-chain/latest/src/cml_chain/builders/tx_builder

Demonstrates how to manage both minting and burning of assets within a single transaction using Rust's `TxBuilder`. This snippet initializes a transaction builder, adds inputs with multi-assets, sets an initial output, and then proceeds to add minting and burning operations. It includes assertions to verify the total input and output values before and after these operations.

```rust
let mut tx_builder = create_tx_builder_with_fee(create_linear_fee(0, 1));
let (_, (_stake, _), addr_test_0) = create_account();

let (mint_script1, policy_id1) = mint_script_and_policy(0);
let (mint_script2, policy_id2) = mint_script_and_policy(1);

let name = AssetName::new(vec![0u8, 1, 2, 3]).unwrap();

let ma_input1 = 100;
let ma_input2 = 200;
let ma_output1 = 60;

let multiassets = [
            ma_input1, ma_input2, ma_output1
        ]
            .iter()
            .map(|input| {
                let mut multiasset = MultiAsset::new();
                multiasset.set(policy_id1, name.clone(), *input);
                multiasset.set(policy_id2, name.clone(), *input);
                multiasset
            })
            .collect::<Vec<MultiAsset>>();

for (multiasset, ada) in multiassets.iter().zip([100u64, 100, 100].iter().cloned()) {
            let mut input_amount = Value::from(ada);
            input_amount.multiasset = multiasset.clone();

            let input = {
                SingleInputBuilder::new(
                    TransactionInput::new(genesis_id(), 0),
                    TransactionOutput::new(addr_test_0.clone(), input_amount, None, None),
                )
                .payment_key()
                .unwrap()
            };
            tx_builder.add_input(input).unwrap();
        }

tx_builder
            .add_output(
                TransactionOutputBuilder::new()
                    .with_address(byron_address())
                    .next()
                    .unwrap()
                    .with_value(208)
                    .build()
                    .unwrap(),
            )
            .unwrap();

let total_input_before_mint = tx_builder.get_total_input().unwrap();
let total_output_before_mint = tx_builder.get_total_output().unwrap();

assert_eq!(total_input_before_mint.coin, 300);
assert_eq!(total_output_before_mint.coin, 208);
let ma1_input = &total_input_before_mint.multiasset;
let ma1_output = &total_output_before_mint;
assert_eq!(ma1_input.get(&policy_id1, &name).unwrap(), 360);
assert_eq!(ma1_input.get(&policy_id2, &name).unwrap(), 360);
assert!(!ma1_output.has_multiassets());

// Adding mint
let result = SingleMintBuilder::new_single_asset(name.clone(), 40).native_script(
            mint_script1,
            NativeScriptWitnessInfo::assume_signature_count(),
        );
tx_builder.add_mint(result).unwrap();

// Adding burn
let result = SingleMintBuilder::new_single_asset(name.clone(), -40).native_script(
            mint_script2,
            NativeScriptWitnessInfo::assume_signature_count(),
        );
tx_builder.add_mint(result).unwrap();

let total_input_after_mint = tx_builder.get_total_input().unwrap();
```

--------------------------------

### Get Raw Pointer to Vec Buffer (Rust)

Source: https://docs.rs/cml-chain/latest/cml_chain/type

Explains how to get a raw const pointer (`*const T`) to the vector's underlying buffer using `as_ptr`. It emphasizes the need to ensure the vector outlives the pointer and warns against modifying the buffer through this pointer to avoid undefined behavior.

```rust
pub const fn as_ptr(&self) -> *const T
```

--------------------------------

### Build Cardano Transaction with Output and Reference Script (Rust)

Source: https://docs.rs/cml-chain/latest/src/cml_chain/builders/tx_builder

This snippet demonstrates how to construct a transaction output with an address and a reference script (Plutus V1). It also shows how to add collateral to the transaction.

```Rust
tx_builder
    .add_collateral(
        SingleInputBuilder::new(
            TransactionInput::new(
                TransactionHash::from_hex(
                    "a90a895d07049afc725a0d6a38c6b82218b8d1de60e7bd70ecdd58f1d9e1218b",
                )
                .unwrap(),
                0,
            ),
            input_utxo.output,
        )
        .payment_key()
        .unwrap(),
    )
    .unwrap();

let change_cred = StakeCredential::new_pub_key(change_key.to_raw_key().hash());
{
    let output = TransactionOutputBuilder::new()
        .with_address(BaseAddress::new(NetworkInfo::testnet().network_id(), change_cred.clone(), stake_cred.clone()).to_address())
        .with_reference_script(
            Script::new_plutus_v1(
                PlutusV1Script::new(
                    hex::decode("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")
                )
            )
        )
        .unwrap();
}
```

--------------------------------

### Create Basic TransactionBuilder

Source: https://docs.rs/cml-chain/latest/src/cml_chain/builders/tx_builder

This function creates a TransactionBuilder with specified fee, coins per UTXO byte, pool deposit, and key deposit. It relies on `create_tx_builder_full` for detailed configuration.

```rust
fn create_tx_builder(
    linear_fee: LinearFee,
    coins_per_utxo_byte: u64,
    pool_deposit: u64,
    key_deposit: u64,
) -> TransactionBuilder {
    create_tx_builder_full(
        linear_fee,
        pool_deposit,
        key_deposit,
        MAX_VALUE_SIZE,
        coins_per_utxo_byte,
    )
}
```

--------------------------------

### Vec Memory Leak Example with set_len in Rust

Source: https://docs.rs/cml-chain/latest/cml_chain/utils/struct

Illustrates a potential memory leak when using `set_len` without proper deallocation. This example shows how calling `set_len(0)` on a vector of vectors without freeing the inner vectors first leads to a leak. It contrasts this with the recommended `clear` method for safe deallocation.

```Rust
let mut vec = vec![vec![1, 0, 0],
                   vec![0, 1, 0],
                   vec![0, 0, 1]];
// SAFETY:
// 1. `old_len..0` is empty so no elements need to be initialized.
// 2. `0 <= capacity` always holds whatever `capacity` is.
unsafe {
    vec.set_len(0);
}
```
Tokens:
Raw