Struct near_contract_standards_sbt::fungible_token::core_impl::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) -> Selfwhere
    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 FungibleTokenwhere
    LookupMap<AccountId, Balance>: BorshDeserialize,
    Balance: 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 FungibleTokenwhere
    LookupMap<AccountId, Balance>: BorshSerialize,
    Balance: 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 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<U128>) -> 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>