Struct FungibleToken

pub struct FungibleToken {
    pub accounts: LookupMap<AccountId, Balance>,
    pub total_supply: Balance,
    pub account_storage_usage: StorageUsage,
}

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

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

Fields

accounts: LookupMap<AccountId, Balance>

AccountID -> Account balance.

total_supply: Balance

Total supply of the all token.

account_storage_usage: StorageUsage

The storage size in bytes for one account.

Implementations

impl FungibleToken

pub fn new<S>(prefix: S) -> Self

where S: IntoStorageKey,

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

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

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

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

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

impl FungibleToken

pub fn internal_ft_resolve_transfer( &mut self, sender_id: &AccountId, receiver_id: AccountId, amount: U128, ) -> (u128, u128)

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

impl FungibleToken

pub fn internal_storage_unregister( &mut self, 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 FungibleToken

fn deserialize_reader<__R: Read>(reader: &mut __R) -> Result<Self, Error>

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.

fn try_from_reader<R>(reader: &mut R) -> Result<Self, Error>

where R: Read,

impl BorshSchema for FungibleToken

fn declaration() -> Declaration

Get the name of the type without brackets.

fn add_definitions_recursively( definitions: &mut BTreeMap<Declaration, Definition>, )

Recursively, using DFS, add type definitions required for this type. Type definition partially explains how to serialize/deserialize a type.

impl BorshSerialize for FungibleToken

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

impl FungibleTokenCore for FungibleToken

fn ft_transfer( &mut self, receiver_id: AccountId, amount: 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 ft_transfer_call( &mut self, receiver_id: AccountId, amount: 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 ft_on_transfer method on receiver_id contract and attaches a callback to resolve this transfer. ft_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 ft_total_supply(&self) -> U128

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

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

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

impl FungibleTokenResolver for FungibleToken

fn ft_resolve_transfer( &mut self, sender_id: AccountId, receiver_id: AccountId, amount: U128, ) -> U128

impl StorageManagement for FungibleToken

fn storage_withdraw(&mut self, amount: Option<NearToken>) -> StorageBalance

While storage_withdraw normally allows the caller to retrieve available balance, the basic Fungible 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, account_id: Option<AccountId>, registration_only: Option<bool>, ) -> StorageBalance

fn storage_unregister(&mut self, 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, account_id: AccountId) -> Option<StorageBalance>