Enum Asset 

pub enum Asset {
    Fungible(FungibleAsset),
    NonFungible(NonFungibleAsset),
}

A fungible or a non-fungible asset.

All assets are encoded as the vault key of the asset and its value, each represented as one word (4 elements). This makes it is easy to determine the type of an asset both inside and outside Miden VM. Specifically:

The vault key of an asset contains the AssetComposition which describes how assets compose, meaning whether they can be merged or split.

This property guarantees that there can never be a collision between a fungible and a non-fungible asset.

The methodology for constructing fungible and non-fungible assets is described below.

Fungible assets

• A fungible asset’s value layout is: [amount, 0, 0, 0].
• A fungible asset’s vault key layout is: [0, 0, faucet_id_suffix_and_metadata, faucet_id_prefix].

Where:

• amount is the AssetAmount that the asset holds and cannot be greater than AssetAmount::MAX and thus fits into a felt.
• the remaining elements in the value word must be zero.
• faucet_id_prefix is the prefix of the faucet ID which issues the asset.
• faucet_id_suffix_and_metadata is the suffix of the faucet ID which issues the asset and the asset metadata (AssetCallbackFlag and AssetComposition). See AssetVaultKey for more details on the key’s layout.
• the asset ID limbs must be zero, which means two instances of the same fungible asset have the same asset key and will be merged together when stored in the same account’s vault.

It is impossible to find a collision between two fungible assets issued by different faucets as the faucet ID is part of the asset’s vault key and this is guaranteed to be different for each faucet as per the faucet creation logic.

Non-fungible assets

• A non-fungible asset’s data layout is: [hash0, hash1, hash2, hash3].
• A non-fungible asset’s vault key layout is: [hash0, hash1, faucet_id_suffix_and_metadata, faucet_id_prefix].

Where:

• the 4 elements of non-fungible asset values are computed by hashing the asset data. This compresses an asset of an arbitrary length to 4 field elements.
• faucet_id_prefix is the prefix of the faucet ID which issues the asset.
• faucet_id_suffix_and_metadata is the suffix of the faucet ID which issues the asset and the asset metadata (AssetCallbackFlag and AssetComposition). See AssetVaultKey for more details on the key’s layout.
• The asset ID limbs are set to hashes from the asset’s value (hash0 and hash1).

It is impossible to find a collision between two non-fungible assets issued by different faucets as the faucet ID is part of the asset’s vault key and this is guaranteed to be different as per the faucet creation logic.

The collision resistance of non-fungible assets issued by the same faucet is ~2^64, due to the 128-bit asset ID that is unique per non-fungible asset. In other words, two non-fungible assets issued by the same faucet are very unlikely to have the same asset key and thus should not collide when stored in the same account’s vault.

Variants

Fungible(FungibleAsset)

NonFungible(NonFungibleAsset)

Implementations

impl Asset

pub fn from_key_value( key: AssetVaultKey, value: Word, ) -> Result<Self, AssetError>

Creates an asset from the provided key and value.

Errors

Returns an error if:

• FungibleAsset::from_key_value or NonFungibleAsset::from_key_value fails.

pub fn from_key_value_words(key: Word, value: Word) -> Result<Self, AssetError>

Creates an asset from the provided key and value.

Prefer Self::from_key_value for more type safety.

Errors

Returns an error if:

• The provided key does not contain a valid faucet ID.
• Self::from_key_value fails.

pub fn with_callbacks(self, callbacks: AssetCallbackFlag) -> Self

Returns a copy of this asset with the given AssetCallbackFlag.

pub fn is_same(&self, other: &Self) -> bool

Returns true if this asset is the same as the specified asset.

Two assets are defined to be the same if their vault keys match.

pub fn is_fungible(&self) -> bool

Returns true if this asset is a fungible asset.

pub fn is_non_fungible(&self) -> bool

Returns true if this asset is a non fungible asset.

pub fn faucet_id(&self) -> AccountId

Returns the ID of the faucet that issued this asset.

pub fn vault_key(&self) -> AssetVaultKey

Returns the key which is used to store this asset in the account vault.

pub fn to_key_word(&self) -> Word

Returns the asset’s key encoded to a Word.

pub fn to_value_word(&self) -> Word

Returns the asset’s value encoded to a Word.

pub fn as_elements(&self) -> [Felt; 8]

Returns the asset encoded as elements.

The first four elements contain the asset key and the last four elements contain the asset value.

pub fn unwrap_fungible(&self) -> FungibleAsset

Returns the inner FungibleAsset.

Panics

Panics if the asset is non-fungible.

pub fn unwrap_non_fungible(&self) -> NonFungibleAsset

Returns the inner NonFungibleAsset.

Panics

Panics if the asset is fungible.

Trait Implementations

impl Clone for Asset

fn clone(&self) -> Asset

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Asset

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Deserializable for Asset

fn read_from<R: ByteReader>( source: &mut R, ) -> Result<Self, DeserializationError>

Reads a sequence of bytes from the provided source, attempts to deserialize these bytes into Self, and returns the result.

fn min_serialized_size() -> usize

Returns the minimum serialized size for one instance of this type.

fn read_from_bytes(bytes: &[u8]) -> Result<Self, DeserializationError>

Attempts to deserialize the provided bytes into Self and returns the result.

fn read_from_bytes_with_budget( bytes: &[u8], budget: usize, ) -> Result<Self, DeserializationError>

Deserializes Self from bytes with a byte budget limit.

impl From<Asset> for AssetVaultKey

fn from(asset: Asset) -> Self

Converts to this type from the input type.

impl From<FungibleAsset> for Asset

fn from(asset: FungibleAsset) -> Self

Converts to this type from the input type.

impl From<NonFungibleAsset> for Asset

fn from(asset: NonFungibleAsset) -> Self

Converts to this type from the input type.

impl PartialEq for Asset

fn eq(&self, other: &Asset) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serializable for Asset

fn write_into<W: ByteWriter>(&self, target: &mut W)

Serializes self into bytes and writes these bytes into the target.

fn get_size_hint(&self) -> usize

Returns an estimate of how many bytes are needed to represent self.

fn to_bytes(&self) -> Vec<u8>

Serializes self into a vector of bytes.

impl Copy for Asset

impl Eq for Asset

impl StructuralPartialEq for Asset