Enum miden_objects::assets::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 will be:

• ZERO for a fungible asset
• non-ZERO for a non-fungible asset The 3rd most significant 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

The most significant element of a fungible asset is set to the ID of the faucet which issued the asset. This guarantees the properties described above (the 3rd most significant bit is ONE).

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

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: [d0, d1, d2, d3].
• d1 is then replaced with the faucet_id which issues the asset: [d0, faucet_id, d2, d3].
• Lastly, the 3rd most significant bit of d3 is set to ZERO.

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 fn faucet_id(&self) -> AccountId

Returns ID of the faucet which issued this asset.

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 fungible asset, or panics if the asset is not fungible.

pub fn unwrap_non_fungible(&mut self) -> NonFungibleAsset

Returns the inner non-fungible asset, or 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 [u8; 32]

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<Asset> for [u8; 32]

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

This method tests for self and other values to be equal, and is used by ==.

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

This method 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 to_bytes(&self) -> Vec<u8>

Serializes self into a vector of bytes.

fn get_size_hint(&self) -> usize

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

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<&[u8; 32]> for Asset

type Error = AssetError

The type returned in the event of a conversion error.

fn try_from(value: &[u8; 32]) -> 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 TryFrom<[u8; 32]> for Asset

type Error = AssetError

The type returned in the event of a conversion error.

fn try_from(value: [u8; 32]) -> Result<Self, Self::Error>

Performs the conversion.

impl Copy for Asset

impl Eq for Asset

impl StructuralPartialEq for Asset