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 AccountId of the faucet that issues the asset. It can be used to distinguish assets based on the encoded AccountId::account_type. In the vault keys of assets, the account type bits at index 4 and 5 determine whether the asset is fungible or non-fungible.

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, faucet_id_prefix].

The most significant elements of a fungible asset’s key are set to the prefix (faucet_id_prefix) and suffix (faucet_id_suffix) of the ID of the faucet which issues the asset. The asset ID limbs are set to 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.

The least significant element of the value is set to the amount of the asset and the remaining felts are zero. This amount cannot be greater than FungibleAsset::MAX_AMOUNT and thus fits into a felt.

It is impossible to find a collision between two fungible assets issued by different faucets as the faucet ID is included in the description of the asset 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, faucet_id_prefix].

The 4 elements of non-fungible assets are computed by hashing the asset data. This compresses an asset of an arbitrary length to 4 field elements: [hash0, hash1, hash2, hash3].

It is impossible to find a collision between two non-fungible assets issued by different faucets as the faucet ID is included in the description of the non-fungible asset and this is guaranteed to be different as per the faucet creation logic.

The most significant elements of a non-fungible asset’s key are set to the prefix (faucet_id_prefix) and suffix (faucet_id_suffix) of the ID of the faucet which issues the asset. The asset ID limbs are set to hashes from the asset’s value. This means 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 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:

• For fungible assets, if they were issued by the same faucet.
• For non-fungible assets, if the assets are identical.

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