Struct near_contract_standards_sbt::non_fungible_token::core::NonFungibleToken

pub struct NonFungibleToken {
    pub owner_id: AccountId,
    pub extra_storage_in_bytes_per_token: StorageUsage,
    pub owner_by_id: TreeMap<TokenId, AccountId>,
    pub token_metadata_by_id: Option<LookupMap<TokenId, TokenMetadata>>,
    pub tokens_per_owner: Option<LookupMap<AccountId, UnorderedSet<TokenId>>>,
    pub approvals_by_id: Option<LookupMap<TokenId, HashMap<AccountId, u64>>>,
    pub next_approval_id_by_id: Option<LookupMap<TokenId, u64>>,
}

Implementation of the non-fungible token standard. Allows to include NEP-171 compatible token to any contract. There are next traits that any contract may implement: - NonFungibleTokenCore – interface with nft_transfer methods. NonFungibleToken provides methods for it. - NonFungibleTokenApproval – interface with nft_approve methods. NonFungibleToken provides methods for it. - NonFungibleTokenEnumeration – interface for getting lists of tokens. NonFungibleToken provides methods for it. - NonFungibleTokenMetadata – return metadata for the token in NEP-177, up to contract to implement.

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

Fields

owner_id: AccountId

extra_storage_in_bytes_per_token: StorageUsage

owner_by_id: TreeMap<TokenId, AccountId>

token_metadata_by_id: Option<LookupMap<TokenId, TokenMetadata>>

tokens_per_owner: Option<LookupMap<AccountId, UnorderedSet<TokenId>>>

approvals_by_id: Option<LookupMap<TokenId, HashMap<AccountId, u64>>>

next_approval_id_by_id: Option<LookupMap<TokenId, u64>>

Implementations

impl NonFungibleToken

pub fn new<Q, R, S, T>(
    owner_by_id_prefix: Q,
    owner_id: AccountId,
    token_metadata_prefix: Option<R>,
    enumeration_prefix: Option<S>,
    approval_prefix: Option<T>
) -> Selfwhere
    Q: IntoStorageKey,
    R: IntoStorageKey,
    S: IntoStorageKey,
    T: IntoStorageKey,

pub fn mint(
    &mut self,
    token_id: TokenId,
    token_owner_id: AccountId,
    token_metadata: Option<TokenMetadata>
) -> Token

👎Deprecated since 4.0.0: mint is deprecated, please use internal_mint instead.

Mint a new token. Not part of official standard, but needed in most situations. Consuming contract expected to wrap this with an nft_mint function.

Requirements:

• Caller must be the owner_id set during contract initialization.
• Caller of the method must attach a deposit of 1 yoctoⓃ for security purposes.
• If contract is using Metadata extension (by having provided metadata_prefix during contract initialization), token_metadata must be given.
• token_id must be unique

Returns the newly minted token

pub fn internal_mint(
    &mut self,
    token_id: TokenId,
    token_owner_id: AccountId,
    token_metadata: Option<TokenMetadata>
) -> Token

Mint a new token without checking:

• Whether the caller id is equal to the owner_id
• Assumes there will be a refund to the predecessor after covering the storage costs

Returns the newly minted token and emits the mint event

pub fn internal_mint_with_refund(
    &mut self,
    token_id: TokenId,
    token_owner_id: AccountId,
    token_metadata: Option<TokenMetadata>,
    refund_id: Option<AccountId>
) -> Token

Mint a new token without checking:

• Whether the caller id is equal to the owner_id
• refund_id will transfer the left over balance after storage costs are calculated to the provided account. Typically the account will be the owner. If None, will not refund. This is useful for delaying refunding until multiple tokens have been minted.

Returns the newly minted token and does not emit the mint event. This allows minting multiple before emitting.

pub fn internal_mint_without_refund(
    &mut self,
    token_id: TokenId,
    token_owner_id: AccountId,
    token_metadata: Option<TokenMetadata>
) -> Token

Trait Implementations

impl BorshDeserialize for NonFungibleTokenwhere
    AccountId: BorshDeserialize,
    StorageUsage: BorshDeserialize,
    TreeMap<TokenId, AccountId>: BorshDeserialize,
    Option<LookupMap<TokenId, TokenMetadata>>: BorshDeserialize,
    Option<LookupMap<AccountId, UnorderedSet<TokenId>>>: BorshDeserialize,
    Option<LookupMap<TokenId, HashMap<AccountId, u64>>>: BorshDeserialize,
    Option<LookupMap<TokenId, u64>>: 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 NonFungibleTokenwhere
    AccountId: BorshSerialize,
    StorageUsage: BorshSerialize,
    TreeMap<TokenId, AccountId>: BorshSerialize,
    Option<LookupMap<TokenId, TokenMetadata>>: BorshSerialize,
    Option<LookupMap<AccountId, UnorderedSet<TokenId>>>: BorshSerialize,
    Option<LookupMap<TokenId, HashMap<AccountId, u64>>>: BorshSerialize,
    Option<LookupMap<TokenId, u64>>: 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 NonFungibleTokenApproval for NonFungibleToken

fn nft_approve(
    &mut self,
    token_id: TokenId,
    account_id: AccountId,
    msg: Option<String>
) -> Option<Promise>

Add an approved account for a specific token.

fn nft_revoke(&mut self, token_id: TokenId, account_id: AccountId)

Revoke an approved account for a specific token.

fn nft_revoke_all(&mut self, token_id: TokenId)

Revoke all approved accounts for a specific token.

fn nft_is_approved(
    &self,
    token_id: TokenId,
    approved_account_id: AccountId,
    approval_id: Option<u64>
) -> bool

Check if a token is approved for transfer by a given account, optionally checking an approval_id

impl NonFungibleTokenCore for NonFungibleToken

fn nft_token(&self, token_id: TokenId) -> Option<Token>

Returns the token with the given token_id or null if no such token.

impl NonFungibleTokenEnumeration for NonFungibleToken

fn nft_total_supply(&self) -> U128

Returns the total supply of non-fungible tokens as a string representing an unsigned 128-bit integer to avoid JSON number limit of 2^53.

fn nft_tokens(&self, from_index: Option<U128>, limit: Option<u64>) -> Vec<Token>

Get a list of all tokens

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

Get number of tokens owned by a given account

fn nft_tokens_for_owner(
    &self,
    account_id: AccountId,
    from_index: Option<U128>,
    limit: Option<u64>
) -> Vec<Token>

Get list of all tokens owned by a given account