Struct NFTState 

pub struct NFTState {
    pub token_data: Cid,
    pub owner_data: Cid,
    pub next_token: TokenID,
    pub total_supply: u64,
}

NFT state IPLD structure.

Fields

token_data: Cid

Amt<TokenId, TokenData> encodes information per token - ownership, operators, metadata etc.

owner_data: Cid

Hamt<ActorID, OwnerData> index for faster lookup of data often queried by owner.

next_token: TokenID

The next available token id for minting.

total_supply: u64

The number of minted tokens less the number of burned tokens.

Implementations

impl NFTState

pub fn new<BS: Blockstore>(store: &BS) -> Result<Self, StateError>

Create a new NFT state-tree, without committing it (the root Cid) to a blockstore.

pub fn load<BS: Blockstore>(store: &BS, root: &Cid) -> Result<Self, StateError>

pub fn save<BS: Blockstore>(&self, store: &BS) -> Result<Cid, StateError>

pub fn get_token_data_amt<'bs, BS: Blockstore>( &self, store: &'bs BS, ) -> Result<Amt<TokenData, &'bs BS>, StateError>

pub fn get_owner_data_hamt<'bs, BS: Blockstore>( &self, store: &'bs BS, ) -> Result<Hamt<&'bs BS, OwnerData, BytesKey>, StateError>

pub fn get_token_amt_for_cursor<'bs, BS: Blockstore>( &self, store: &'bs BS, cursor: &Option<Cursor>, ) -> Result<Amt<TokenData, &'bs BS>, StateError>

Retrieves the token data amt, asserting that the cursor is valid for the current state. If the root cid has changed since the cursor was created, the data has mutated and the cursor is invalid.

impl NFTState

pub fn mint_tokens<BS: Blockstore>( &mut self, bs: &BS, initial_owner: ActorID, metadatas: Vec<String>, ) -> Result<MintIntermediate, StateError>

Mint a new token to the specified address.

pub fn get_balance<BS: Blockstore>( &self, bs: &BS, owner: ActorID, ) -> Result<u64, StateError>

Get the number of tokens owned by a particular address.

pub fn approve_for_tokens<F, BS: Blockstore>( &mut self, bs: &BS, operator: ActorID, token_ids: &[TokenID], approve_predicate: F, ) -> Result<(), StateError>

where F: Fn(&TokenData, TokenID) -> Result<(), StateError>,

Approves an operator to transfer a set of specified tokens.

The caller should own the tokens or an account-level operator on the owner of the tokens.

pub fn revoke_for_tokens<F, BS: Blockstore>( &mut self, bs: &BS, operator: ActorID, token_ids: &[TokenID], revoke_predicate: F, ) -> Result<(), StateError>

where F: Fn(&TokenData, TokenID) -> Result<(), StateError>,

Revokes an operator’s permission to transfer the specified tokens.

The caller should own the tokens or be an account-level operator on the owner of the tokens.

pub fn approve_for_owner<BS: Blockstore>( &mut self, bs: &BS, owner: ActorID, operator: ActorID, ) -> Result<(), StateError>

Approves an operator to transfer tokens on behalf of the owner.

The operator becomes authorized at account level, meaning all tokens owned by the account can be transferred, approved or burned by the operator, including future tokens owned by the account.

The caller should be the owning account.

pub fn revoke_for_all<BS: Blockstore>( &mut self, bs: &BS, owner: ActorID, operator: ActorID, ) -> Result<(), StateError>

Revokes an operator’s authorization to transfer tokens on behalf of the owner account.

The caller should be the owner of the account.

pub fn burn_tokens<F, BS: Blockstore>( &mut self, bs: &BS, owner: ActorID, token_ids: &[TokenID], burn_predicate: F, ) -> Result<u64, StateError>

where F: Fn(&TokenData, TokenID) -> Result<(), StateError>,

Burns a set of tokens, removing them from circulation and deleting associated metadata.

If any of the token_ids cannot be burned (e.g. non-existent, already burned), the entire transaction should fail atomically.

The tokens must all be owned by the same owner.

Returns the new balance of the owner if all tokens were burned successfully.

pub fn transfer<F, BS: Blockstore>( &mut self, bs: &BS, token_ids: &[TokenID], owner: ActorID, receiver: ActorID, transfer_predicate: &F, ) -> Result<TransferIntermediate, StateError>

where F: Fn(&TokenData, TokenID) -> Result<(), StateError>,

Transfers a batch of tokens between the owner and receiver.

The predicate is checked for each token to be transferred, and the entire transfer is aborted if the predicate fails. It is the caller’s responsibility to check that the actor using this method is permitted to do so.

pub fn is_account_operator<BS: Blockstore>( owner_map: &Hamt<&BS, OwnerData>, owner: ActorID, operator: ActorID, ) -> Result<bool, StateError>

Checks for account-level approval between owner and operator.

pub fn assert_can_approve_token( token_data: &TokenData, actor: ActorID, token_id: TokenID, ) -> Result<(), StateError>

Asserts that the actor either owns the token or is an account level operator on the owner of the token.

pub fn assert_token_level_approval( token_data: &TokenData, token_id: TokenID, operator: ActorID, ) -> Result<(), StateError>

Asserts that the given operator is permitted authorised for the specified token.

pub fn assert_owns_token( token_data: &TokenData, token_id: TokenID, actor: ActorID, ) -> Result<(), StateError>

Asserts that a given account owns the specified token.

pub fn mint_return<BS: Blockstore>( &self, bs: &BS, intermediate: MintIntermediate, ) -> Result<MintReturn, StateError>

Converts a MintIntermediate to a MintReturn.

This function should be called on a freshly loaded or known-up-to-date state.

pub fn transfer_return<BS: Blockstore>( &self, bs: &BS, intermediate: TransferIntermediate, ) -> Result<TransferReturn, StateError>

Converts a TransferIntermediate to a TransferReturn.

This function should be called on a freshly loaded or known-up-to-date state.

pub fn get_metadata<BS: Blockstore>( &self, bs: &BS, token_id: TokenID, ) -> Result<String, StateError>

Get the metadata for a token.

pub fn get_owner<BS: Blockstore>( &self, bs: &BS, token_id: TokenID, ) -> Result<ActorID, StateError>

Get the owner of a token.

pub fn list_tokens<BS: Blockstore>( &self, bs: &BS, cursor: Option<Cursor>, limit: u64, ) -> Result<(TokenSet, Option<Cursor>), StateError>

List all the minted tokens.

pub fn list_owned_tokens<BS: Blockstore>( &self, bs: &BS, owner: ActorID, cursor: Option<Cursor>, limit: u64, ) -> Result<(TokenSet, Option<Cursor>), StateError>

List the tokens owned by an actor. In the reference implementation this is may be a prohibitievly expensive operation as it involves iterating over the entire token set. Returns a bitfield of the tokens owned by the actor and a cursor to the next page of data.

pub fn list_token_operators<BS: Blockstore>( &self, bs: &BS, token_id: TokenID, cursor: Option<Cursor>, limit: u64, ) -> Result<(ActorIDSet, Option<Cursor>), StateError>

List all the token operators for a given token_id.

pub fn list_operator_tokens<BS: Blockstore>( &self, bs: &BS, operator: ActorID, cursor: Option<Cursor>, limit: u64, ) -> Result<(TokenSet, Option<Cursor>), StateError>

Enumerates tokens for which an account is an operator.

pub fn list_account_operators<BS: Blockstore>( &self, bs: &BS, actor_id: ActorID, cursor: Option<Cursor>, limit: u64, ) -> Result<(ActorIDSet, Option<Cursor>), StateError>

List all the token operators for a given account.

impl NFTState

pub fn check_invariants<BS: Blockstore>( &self, bs: &BS, ) -> (StateSummary, Vec<StateInvariantError>)

Checks that the state is internally consistent and obeys the specified invariants

Checks that balances in the TokenArray and OwnerMap are consistent. Checks that the total supply is consistent with the number of tokens in the TokenArray. Checks that the OwnerHamt is clear of semantically empty entries. Checks that all bytes keys are valid actor ids.

Returns a state summary that can be used to check application specific invariants and a list of errors that were found.

Trait Implementations

impl Clone for NFTState

fn clone(&self) -> NFTState

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for NFTState

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for NFTState

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for NFTState

fn eq(&self, other: &NFTState) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for NFTState

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for NFTState

impl StructuralPartialEq for NFTState