NonFungibleToken

This module provides the full NonFungibleToken module API.

Core

import "./node-modules/@openzeppelin-compact/non-fungible-token/src/NonFungibleToken" prefix NonFungibleToken_;

NonFungibleToken

View on GitHub

Circuits

• initialize(name_, symbol_) - circuit
• balanceOf(owner) - circuit
• ownerOf(tokenId) - circuit
• name() - circuit
• symbol() - circuit
• tokenURI(tokenId) - circuit
• _setTokenURI(tokenId, tokenURI) - circuit
• approve(to, tokenId) - circuit
• getApproved(tokenId) - circuit
• setApprovalForAll(operator, approved) - circuit
• isApprovedForAll(owner, operator) - circuit
• transferFrom(from, to, tokenId) - circuit
• _unsafeTransferFrom(from, to, tokenId) - circuit
• _ownerOf(tokenId) - circuit
• _getApproved(tokenId) - circuit
• _isAuthorized(owner, spender, tokenId) - circuit
• _checkAuthorized(owner, spender, tokenId) - circuit
• _update(to, tokenId, auth) - internal
• _mint(to, tokenId) - circuit
• _unsafeMint(to, tokenId) - circuit
• _burn(tokenId) - circuit
• _transfer(from, to, tokenId) - circuit
• _unsafeTransfer(from, to, tokenId) - circuit
• _approve(to, tokenId, auth) - circuit
• _setApprovalForAll(owner, operator, approved) - circuit
• _requireOwned(tokenId) - circuit

initialize

initialize(name_: Opaque<"string">, symbol_: Opaque<"string">) → []

Type: circuit

Initializes the contract by setting the name and symbol.

This MUST be called in the implementing contract’s constructor. Failure to do so can lead to an irreparable contract.

Requirements:

• Contract is not initialized.

Constraints:

• k=10, rows=65

balanceOf

balanceOf(owner: Either<ZswapCoinPublicKey, ContractAddress>) → Uint<128>

Type: circuit

Returns the number of tokens in owner's account.

Requirements:

• Contract is initialized.

Constraints:

• k=10, rows=309

ownerOf

ownerOf(tokenId: Uint<128>) → Either<ZswapCoinPublicKey, ContractAddress>

Type: circuit

Returns the owner of the tokenId token.

Requirements:

• The contract is initialized.
• The tokenId must exist.

Constraints:

• k=10, rows=290

name

name() → Opaque<"string">

Type: circuit

Returns the token name.

Requirements:

• Contract is initialized.

Constraints:

• k=10, rows=36

symbol

symbol() → Opaque<"string">

Type: circuit

Returns the symbol of the token.

Requirements:

• Contract is initialized.

Constraints:

• k=10, rows=36

tokenURI

tokenURI(tokenId: Uint<128>) → Opaque<"string">

Type: circuit

Returns the token URI for the given tokenId. Returns an empty string if a tokenURI does not exist.

Requirements:

• The contract is initialized.
• The tokenId must exist.

Therefore, we propose the URI storage approach; whereby, NFTs may or may not have unique "base" URIs. It’s up to the implementation to decide on how to handle this.

Constraints:

• k=10, rows=296

_setTokenURI

_setTokenURI(tokenId: Uint<128>, tokenURI: Opaque<"string">) → []

Type: circuit

Sets the the URI as tokenURI for the given tokenId.

Requirements:

• The contract is initialized.
• The tokenId must exist.

Constraints:

• k=10, rows=253

approve

approve(to: Either<ZswapCoinPublicKey, ContractAddress>, tokenId: Uint<128>) → []

Type: circuit

Gives permission to to to transfer tokenId token to another account. The approval is cleared when the token is transferred.

Only a single account can be approved at a time, so approving the zero address clears previous approvals.

Requirements:

• The contract is initialized.
• The caller must either own the token or be an approved operator.
• tokenId must exist.

Constraints:

• k=10, rows=966

getApproved

getApproved(tokenId: Uint<128>) → Either<ZswapCoinPublicKey, ContractAddress>

Type: circuit

Returns the account approved for tokenId token.

Requirements:

• The contract is initialized.
• tokenId must exist.

Constraints:

• k=10, rows=409

setApprovalForAll

setApprovalForAll(operator: Either<ZswapCoinPublicKey, ContractAddress>, approved: Boolean) → []

Type: circuit

Approve or remove operator as an operator for the caller. Operators can call transferFrom for any token owned by the caller.

Requirements:

• The contract is initialized.
• The operator cannot be the zero address.

Constraints:

• k=10, rows=409

isApprovedForAll

isApprovedForAll(owner: Either<ZswapCoinPublicKey, ContractAddress>, operator: Either<ZswapCoinPublicKey, ContractAddress>) → Boolean

Type: circuit

Returns if the operator is allowed to manage all of the assets of owner.

Requirements:

• The contract must have been initialized.

Constraints:

• k=10, rows=621

transferFrom

transferFrom(from: Either<ZswapCoinPublicKey, ContractAddress>, to: Either<ZswapCoinPublicKey, ContractAddress>, tokenId: Uint<128>) → []

Type: circuit

Transfers tokenId token from from to to.

This restriction prevents assets from being inadvertently locked in contracts that cannot currently handle token receipt.

Requirements:

• The contract is initialized.
• from is not the zero address.
• to is not the zero address.
• to is not a ContractAddress.
• tokenId token must be owned by from.
• If the caller is not from, it must be approved to move this token by either approve or setApprovalForAll.

Constraints:

• k=11, rows=1966

_unsafeTransferFrom

_unsafeTransferFrom(from: Either<ZswapCoinPublicKey, ContractAddress>, to: Either<ZswapCoinPublicKey, ContractAddress>, tokenId: Uint<128>) → []

Type: circuit

Unsafe variant of transferFrom which allows transfers to contract addresses.

Tokens sent to a contract address may become irretrievable. Once contract-to-contract calls are supported, this circuit may be deprecated.

Requirements:

• The contract is initialized.
• from is not the zero address.
• to is not the zero address.
• tokenId token must be owned by from.
• If the caller is not from, it must be approved to move this token by either approve or setApprovalForAll.

Constraints:

• k=11, rows=1963

_ownerOf

_ownerOf(tokenId: Uint<128>) → Either<ZswapCoinPublicKey, ContractAddress>

Type: circuit

Returns the owner of the tokenId. Does NOT revert if token doesn’t exist

Requirements:

• The contract is initialized.

Constraints:

• k=10, rows=253

_getApproved

_getApproved(tokenId: Uint<128>) → Either<ZswapCoinPublicKey, ContractAddress>

Type: circuit

Returns the approved address for tokenId. Returns the zero address if tokenId is not minted.

Requirements:

• The contract is initialized.

Constraints:

• k=10, rows=253

_isAuthorized

_isAuthorized(owner: Either<ZswapCoinPublicKey, ContractAddress>, spender: Either<ZswapCoinPublicKey, ContractAddress>, tokenId: Uint<128>) → Boolean

Type: circuit

Returns whether spender is allowed to manage owner's tokens, or tokenId in particular (ignoring whether it is owned by owner).

Requirements:

• The contract is initialized.

Constraints:

• k=11, rows=1098

_checkAuthorized

_checkAuthorized(owner: Either<ZswapCoinPublicKey, ContractAddress>, spender: Either<ZswapCoinPublicKey, ContractAddress>, tokenId: Uint<128>) → []

Type: circuit

Checks if spender can operate on tokenId, assuming the provided owner is the actual owner.

Requirements:

• The contract is initialized.
• spender has approval from owner for tokenId OR spender has approval to manage all of owner's assets.

Constraints:

• k=11, rows=1121

_update

_update(to: Either<ZswapCoinPublicKey, ContractAddress>, tokenId: Uint<128>, auth: Either<ZswapCoinPublicKey, ContractAddress>) → Either<ZswapCoinPublicKey, ContractAddress>

Type: internal

Transfers tokenId from its current owner to to, or alternatively mints (or burns) if the current owner (or to) is the zero address. Returns the owner of the tokenId before the update.

Requirements:

• The contract is initialized.
• If auth is non 0, then this function will check that auth is either the owner of the token, or approved to operate on the token (by the owner).

Constraints:

• k=12, rows=2049

_mint

_mint(to: Either<ZswapCoinPublicKey, ContractAddress>, tokenId: Uint<128>) → []

Type: circuit

Mints tokenId and transfers it to to.

Requirements:

• The contract is initialized.
• tokenId must not exist.
• to is not the zero address.
• to is not a ContractAddress.

Constraints:

• k=10, rows=1013

_unsafeMint

_unsafeMint(account: Either<ZswapCoinPublicKey, ContractAddress>, value: Uint<128>) → []

Type: circuit

Unsafe variant of _mint which allows transfers to contract addresses.

Requirements:

• Contract is initialized.
• tokenId must not exist.
• to is not the zero address.

Tokens sent to a contract address may become irretrievable. Once contract-to-contract calls are supported, this circuit may be deprecated.

Constraints:

• k=10, rows=1010

_burn

_burn(tokenId: Uint<128>) → []

Type: circuit

Destroys tokenId. The approval is cleared when the token is burned. This circuit does not check if the sender is authorized to operate on the token.

Requirements:

• The contract is initialized.
• tokenId must exist.

Constraints:

• k=10, rows=479

_transfer

_transfer(from: Either<ZswapCoinPublicKey, ContractAddress>, to: Either<ZswapCoinPublicKey, ContractAddress>, tokenId: Uint<128>) → []

Type: circuit

Transfers tokenId from from to to. As opposed to transferFrom, this imposes no restrictions on ownPublicKey().

This restriction prevents assets from being inadvertently locked in contracts that cannot currently handle token receipt.

Requirements:

• The contract is initialized.
• to is not the zero address.
• to is not a ContractAddress.
• tokenId token must be owned by from.

Constraints:

• k=11, rows=1224

_unsafeTransfer

_unsafeTransfer(from: Either<ZswapCoinPublicKey, ContractAddress>, to: Either<ZswapCoinPublicKey, ContractAddress>, tokenId: Uint<128>) → []

Type: circuit

Unsafe variant of _transfer which allows transfers to contract addresses.

Transfers tokenId from from to to. As opposed to _unsafeTransferFrom, this imposes no restrictions on ownPublicKey(). It does NOT check if the recipient is a ContractAddress.

Once contract-to-contract calls are supported, this circuit may be deprecated.

Requirements:

• Contract is initialized.
• to is not the zero address.
• tokenId token must be owned by from.

Constraints:

• k=11, rows=1221

_approve

_approve(to: Either<ZswapCoinPublicKey, ContractAddress>, tokenId: Uint<128>, auth: Either<ZswapCoinPublicKey, ContractAddress>) → []

Type: circuit

Approve to to operate on tokenId

Requirements:

• The contract is initialized.
• If auth is non 0, then this function will check that auth is either the owner of the token, or approved to operate on the token (by the owner).

Constraints:

• k=11, rows=1109

_setApprovalForAll

_setApprovalForAll(owner: Either<ZswapCoinPublicKey, ContractAddress>, operator: Either<ZswapCoinPublicKey, ContractAddress>, approved: Boolean) → []

Type: circuit

Approve operator to operate on all of owner tokens

Requirements:

• The contract is initialized.
• operator is not the zero address.

Constraints:

• k=10, rows=524

_requireOwned

_requireOwned(tokenId: Uint<128>) → Either<ZswapCoinPublicKey, ContractAddress>

Type: circuit

Reverts if the tokenId doesn’t have a current owner (it hasn’t been minted, or it has been burned). Returns the owner.

Requirements:

• The contract is initialized.
• tokenId must exist.

Constraints:

• k=10, rows=288