Enum Asset

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

A fungible or a non-fungible asset.

All assets are encoded using a single word (4 elements) such that it is easy to determine the type of an asset both inside and outside Miden VM. Specifically:

Element 1 of the asset will be:

• ZERO for a fungible asset.
• non-ZERO for a non-fungible asset.

Element 3 of both asset types is an AccountIdPrefix or equivalently, the prefix of an AccountId, which can be used to distinguish assets based on AccountIdPrefix::account_type.

For element 3 of the vault keys of assets, the bit at index 5 (referred to as the “fungible bit” will be):

• 1 for a fungible asset.
• 0 for a non-fungible asset.

The above properties guarantee 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 data layout is: [amount, 0, faucet_id_suffix, faucet_id_prefix].
• A fungible asset’s vault key layout is: [0, 0, faucet_id_suffix, faucet_id_prefix].

The most significant elements of a fungible asset are set to the prefix (faucet_id_prefix) and suffix (faucet_id_suffix) of the ID of the faucet which issues the asset. This guarantees the properties described above (the fungible bit is 1).

The least significant element is set to the amount of the asset. This amount cannot be greater than 2^63 - 1 and thus requires 63-bits to store.

Elements 1 and 2 are set to ZERO.

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, faucet_id_prefix].
• A non-fungible asset’s vault key layout is: [faucet_id_prefix, hash1, hash2, hash0'], where hash0' is equivalent to hash0 with the fungible bit set to 0. See NonFungibleAsset::vault_key for more details.

The 4 elements of non-fungible assets are computed as follows:

• First the asset data is hashed. This compresses an asset of an arbitrary length to 4 field elements: [hash0, hash1, hash2, hash3].
• hash3 is then replaced with the prefix of the faucet ID (faucet_id_prefix) which issues the asset: [hash0, hash1, hash2, faucet_id_prefix].

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. Collision resistance for non-fungible assets issued by the same faucet is ~2^95.

Variants

Fungible(FungibleAsset)

NonFungible(NonFungibleAsset)

Implementations

impl Asset

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 const fn is_fungible(&self) -> bool

Returns true if this asset is a fungible asset.

pub const fn is_non_fungible(&self) -> bool

Returns true if this asset is a non fungible asset.

pub fn faucet_id_prefix(&self) -> AccountIdPrefix

Returns the prefix of the faucet ID which issued this asset.

To get the full AccountId of a fungible asset the asset must be matched on.

pub fn vault_key(&self) -> Word

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

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 copy 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 read_from_bytes(bytes: &[u8]) -> Result<Self, DeserializationError>

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

impl From<&Asset> for Word

fn from(value: &Asset) -> Self

Converts to this type from the input type.

impl From<Asset> for Word

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 TryFrom<&[BaseElement; 4]> for Asset

type Error = AssetError

The type returned in the event of a conversion error.

fn try_from(value: &Word) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<[BaseElement; 4]> for Asset

type Error = AssetError

The type returned in the event of a conversion error.

fn try_from(value: Word) -> Result<Self, Self::Error>

Performs the conversion.

impl Copy for Asset

impl Eq for Asset

impl StructuralPartialEq for Asset