Struct smarthub_sdk::mt::base::core_impl::MultiFungibleToken

pub struct MultiFungibleToken {
    pub tokens: TreeMap<AccountId, MtToken>,
    pub account_storage_usage: StorageUsage,
}

Implementation of a MultiFungibleToken standard. Allows to include NEP-141 compatible token to any contract. There are next traits that any contract may implement: - MultiFungibleTokenCore – interface with mt_transfer methods. MultiFungibleToken provides methods for it. - MultiFungibleTokenMetaData – return metadata for the token in NEP-148, up to contract to implement. - StorageManager – interface for NEP-145 for allocating storage per account. MultiFungibleToken provides methods for it. - AccountRegistrar – interface for an account to register and unregister

For example usage, see examples/fungible-token/src/lib.rs.

Fields

tokens: TreeMap<AccountId, MtToken>

account_storage_usage: StorageUsage

The storage size in bytes for one account.

Implementations

impl MultiFungibleToken

pub fn new<S>(prefix: S) -> Selfwhere
    S: IntoStorageKey,

pub fn internal_unwrap_balance_of(
    &self,
    mft: &MtToken,
    account_id: &AccountId
) -> Balance

pub fn internal_deposit(
    &mut self,
    token_id: &AccountId,
    account_id: &AccountId,
    amount: Balance
)

pub fn internal_withdraw(
    &mut self,
    token_id: &AccountId,
    account_id: &AccountId,
    amount: Balance
)

pub fn internal_transfer_batch(
    &mut self,
    token_ids: &Vec<AccountId>,
    sender_id: &AccountId,
    receiver_id: &AccountId,
    amounts: &Vec<U128>,
    memo: Option<String>
)

pub fn internal_transfer(
    &mut self,
    token_id: &AccountId,
    sender_id: &AccountId,
    receiver_id: &AccountId,
    amount: Balance,
    _memo: Option<String>
)

pub fn internal_register_account(
    &mut self,
    token_id: &AccountId,
    account_id: &AccountId
)

pub fn internal_on_ft_transfer(
    &mut self,
    ft_token_id: &AccountId,
    sender_id: &AccountId,
    amount: &U128
) -> PromiseOrValue<U128>

impl MultiFungibleToken

pub fn internal_mt_resolve_transfer(
    &mut self,
    token_ids: &Vec<AccountId>,
    sender_id: &AccountId,
    receiver_id: AccountId,
    amounts: &Vec<U128>
) -> Vec<U128>

Internal method that returns the amount of burned tokens in a corner case when the sender has deleted (unregistered) their account while the mt_transfer_call was still in flight. Returns (Used token amount, Burned token amount)

impl MultiFungibleToken

pub fn internal_storage_unregister(
    &mut self,
    token_id: AccountId,
    force: Option<bool>
) -> Option<(AccountId, Balance)>

Internal method that returns the Account ID and the balance in case the account was unregistered.

Trait Implementations

impl BorshDeserialize for MultiFungibleTokenwhere
    TreeMap<AccountId, MtToken>: BorshDeserialize,
    StorageUsage: BorshDeserialize,

fn deserialize(buf: &mut &[u8]) -> Result<Self, Error>

Deserializes this instance from a given slice of bytes. Updates the buffer to point at the remaining bytes.

fn try_from_slice(v: &[u8]) -> Result<Self, Error>

Deserialize this instance from a slice of bytes.

impl BorshSerialize for MultiFungibleTokenwhere
    TreeMap<AccountId, MtToken>: BorshSerialize,
    StorageUsage: BorshSerialize,

fn serialize<W: Write>(&self, writer: &mut W) -> Result<(), Error>

fn try_to_vec(&self) -> Result<Vec<u8, Global>, Error>

Serialize this instance into a vector of bytes.

impl MultiFungibleTokenCore for MultiFungibleToken

fn mt_batch_transfer(
    &mut self,
    receiver_id: AccountId,
    token_ids: Vec<AccountId>,
    amounts: Vec<U128>,
    memo: Option<String>
)

Transfers positive amount of tokens from the env::predecessor_account_id to receiver_id. Both accounts must be registered with the contract for transfer to succeed. (See NEP-145) This method must to be able to accept attached deposits, and must not panic on attached deposit. Exactly 1 yoctoNEAR must be attached. See the Security section of the standard.

fn mt_batch_transfer_call(
    &mut self,
    receiver_id: AccountId,
    token_ids: Vec<AccountId>,
    amounts: Vec<U128>,
    memo: Option<String>,
    msg: String
) -> PromiseOrValue<U128>

Transfers positive amount of tokens from the env::predecessor_account_id to receiver_id account. Then calls mt_on_transfer method on receiver_id contract and attaches a callback to resolve this transfer. mt_on_transfer method must return the amount of tokens unused by the receiver contract, the remaining tokens must be refunded to the predecessor_account_id at the resolve transfer callback.

fn mt_total_supply(&self, token_id: AccountId) -> U128

Returns the total supply of the token in a decimal string representation.

fn mt_balance_of(&self, account_id: AccountId, token_id: AccountId) -> U128

Returns the balance of the account. If the account doesn’t exist must returns "0".

fn mt_add_token(&mut self, token_id: AccountId)

impl MultiFungibleTokenResolver for MultiFungibleToken

fn mt_resolve_transfer(
    &mut self,
    sender_id: AccountId,
    receiver_id: AccountId,
    token_ids: Vec<AccountId>,
    amounts: Vec<U128>
) -> Vec<U128>

impl StorageManagement for MultiFungibleToken

fn storage_withdraw(
    &mut self,
    token_id: AccountId,
    amount: Option<U128>
) -> StorageBalance

While storage_withdraw normally allows the caller to retrieve available balance, the basic MultiFungible Token implementation sets storage_balance_bounds.min == storage_balance_bounds.max, which means available balance will always be 0. So this implementation:

• panics if amount > 0
• never transfers Ⓝ to caller
• returns a storage_balance struct if amount is 0

fn storage_deposit(
    &mut self,
    token_id: AccountId,
    account_id: Option<AccountId>,
    registration_only: Option<bool>
) -> StorageBalance

fn storage_unregister(&mut self, token_id: AccountId, force: Option<bool>) -> bool

Unregisters the predecessor account and returns the storage NEAR deposit back.

fn storage_balance_bounds(&self) -> StorageBalanceBounds

fn storage_balance_of(
    &self,
    token_id: AccountId,
    account_id: AccountId
) -> Option<StorageBalance>