Struct near_contract_standards::non_fungible_token::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>
) -> Self where
    Q: IntoStorageKey,
    R: IntoStorageKey,
    S: IntoStorageKey,
    T: IntoStorageKey, 

pub fn internal_transfer_unguarded(
    &mut self,
    token_id: &TokenId,
    from: &AccountId,
    to: &AccountId
)

Transfer token_id from from to to

Do not perform any safety checks or do any logging

pub fn internal_transfer(
    &mut self,
    sender_id: &AccountId,
    receiver_id: &AccountId,
    token_id: &TokenId,
    approval_id: Option<u64>,
    memo: Option<String>
) -> (AccountId, Option<HashMap<AccountId, u64>>)

Transfer from current owner to receiver_id, checking that sender is allowed to transfer. Clear approvals, if approval extension being used. Return previous owner and approvals.

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

Trait Implementations

impl BorshDeserialize for NonFungibleToken where
    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.

fn is_u8() -> bool

Whether Self is u8. NOTE: Vec<u8> is the most common use-case for serialization and deserialization, it’s worth handling it as a special case to improve performance. It’s a workaround for specific Vec<u8> implementation versus generic Vec<T> implementation. See https://github.com/rust-lang/rfcs/pull/1210 for details.

impl BorshSerialize for NonFungibleToken where
    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.

fn is_u8() -> bool

Whether Self is u8. NOTE: Vec<u8> is the most common use-case for serialization and deserialization, it’s worth handling it as a special case to improve performance. It’s a workaround for specific Vec<u8> implementation versus generic Vec<T> implementation. See https://github.com/rust-lang/rfcs/pull/1210 for details.

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_transfer(
    &mut self,
    receiver_id: AccountId,
    token_id: TokenId,
    approval_id: Option<u64>,
    memo: Option<String>
)

Simple transfer. Transfer a given token_id from current owner to receiver_id.

fn nft_transfer_call(
    &mut self,
    receiver_id: AccountId,
    token_id: TokenId,
    approval_id: Option<u64>,
    memo: Option<String>,
    msg: String
) -> PromiseOrValue<bool>

Transfer token and call a method on a receiver contract. A successful workflow will end in a success execution outcome to the callback on the NFT contract at the method nft_resolve_transfer.

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

impl NonFungibleTokenResolver for NonFungibleToken

fn nft_resolve_transfer(
    &mut self,
    previous_owner_id: AccountId,
    receiver_id: AccountId,
    token_id: TokenId,
    approved_account_ids: Option<HashMap<AccountId, u64>>
) -> bool

Returns true if token was successfully transferred to receiver_id.