Calls

burn

Burn a token 🔥 Caller must be the token owner Namespace
api.tx.nft.burn
Type
function burn(
  token_id: (u32,u32)
)

claimUnownedCollection

Bridged collections from Ethereum will initially lack an owner. These collections will be assigned to the pallet. This allows for claiming those collections assuming they were assigned to the pallet Namespace
api.tx.nft.claimUnownedCollection
Type
function claimUnownedCollection(
  collection_id: u32,
  new_owner: SeedPrimitivesSignatureAccountId20
)

createCollection

Create a new collection Additional tokens can be minted via mint
  • name - the name of the collection
  • initial_issuance - number of tokens to mint now
  • max_issuance - maximum number of tokens allowed in collection
  • token_owner - the token owner, defaults to the caller
  • metadata_scheme - The off-chain metadata referencing scheme for tokens in this
  • royalties_schedule - defacto royalties plan for secondary sales, this will apply to all tokens in the collection by default
  • cross_chain_compatibility - Is this collection XLS-20 compatible. Note, if enabled, the metadata_scheme will be immutable
Namespace
api.tx.nft.createCollection
Type
function createCollection(
  name: Bytes,
  initial_issuance: u32,
  max_issuance: Option<u32>,
  token_owner: Option<SeedPrimitivesSignatureAccountId20>,
  metadata_scheme: Bytes,
  royalties_schedule: Option<SeedPrimitivesNftRoyaltiesSchedule>,
  cross_chain_compatibility: PalletNftCrossChainCompatibility
)

mint

Mint tokens for an existing collection
  • collection_id - the collection to mint tokens in
  • quantity - how many tokens to mint
  • token_owner - the token owner, defaults to the caller if unspecified Caller must be the collection owner
Namespace
api.tx.nft.mint
Type
function mint(
  collection_id: u32,
  quantity: u32,
  token_owner: Option<SeedPrimitivesSignatureAccountId20>
)

setBaseUri

Set the base URI of a collection Caller must be the current collection owner.\ Cannot change if XLS20 compatibility is enabled. Namespace
api.tx.nft.setBaseUri
Type
function setBaseUri(
  collection_id: u32,
  base_uri: Bytes
)

setMaxIssuance

Set the max issuance of a collection Caller must be the current collection owner Namespace
api.tx.nft.setMaxIssuance
Type
function setMaxIssuance(
  collection_id: u32,
  max_issuance: u32
)

setMintFee

Namespace
api.tx.nft.setMintFee
Type
function setMintFee(
  collection_id: u32,
  pricing_details: Option<(u32,u128)>
)

setName

Set the name of a collection Caller must be the current collection owner Namespace
api.tx.nft.setName
Type
function setName(
  collection_id: u32,
  name: Bytes
)

setOwner

Set the owner of a collection Caller must be the current collection owner Namespace
api.tx.nft.setOwner
Type
function setOwner(
  collection_id: u32,
  new_owner: SeedPrimitivesSignatureAccountId20
)

setRoyaltiesSchedule

Set the royalties schedule of a collection Caller must be the current collection owner Namespace
api.tx.nft.setRoyaltiesSchedule
Type
function setRoyaltiesSchedule(
  collection_id: u32,
  royalties_schedule: SeedPrimitivesNftRoyaltiesSchedule
)

togglePublicMint

Namespace
api.tx.nft.togglePublicMint
Type
function togglePublicMint(
  collection_id: u32,
  enabled: bool
)

transfer

Transfer ownership of an NFT Caller must be the token owner Namespace
api.tx.nft.transfer
Type
function transfer(
  collection_id: u32,
  serial_numbers: Vec<u32>,
  new_owner: SeedPrimitivesSignatureAccountId20
)

setUtilityFlags

Set utility flags of a collection. Allows the restriction of certain operations on a collection such as transfer, burn or mint. Flags apply to all tokens in the collection, but individual token flags take priority over collection flags.
  • collection_id - The collection to set the utility flags for
  • utility_flags - An object containing the utility flags.
    CollectionUtilityFlags {
      transferable: bool,
      burnable: bool,
      mintable: bool,
    }
    
Namespace
api.tx.nft.setUtilityFlags
Type
function setUtilityFlags(
  collection_id: u32,
  utility_flags: CollectionUtilityFlags,
)

setTokenTransferableFlag

Set transferable flag on a token, allowing or disallowing transfers. Token utility flags take priority over the collection utility flags, enabling fine-grained control over individual token transferability. Priority Order:
  1. Token-level flags (highest priority)
  2. Collection-level flags (fallback)
  • token_id - The token id (collection_id, serial_number) to set the flags for
  • transferable - Whether the token should be transferable
Note: Soulbound tokens cannot have their utility flags modified after issuance. Namespace
api.tx.nft.setTokenTransferableFlag
Type
function setTokenTransferableFlag(
  token_id: (u32,u32),
  transferable: bool
)

issueSoulbound

Issue soulbound tokens. The issuance will be pending until the designated token owner accepts the issuance. Soulbound tokens will always be non-transferable.
  • collection_id - The collection id to create the issuance for
  • quantity - The number of tokens to issue
  • token_owner - Account id of the token owner
  • burn_authority - The token burn authority. This value will dictate which account is allowed to burn the token, and cannot be altered post-issuance.
    TokenBurnAuthority {
      /// The token can be burned by the collection_owner
      CollectionOwner,
      /// The token can be burned by the token_owner
      TokenOwner,
      /// The token can be burned by either token or collection owner
      Both,
      /// The token cannot be burned by anyone
      Neither,
    }
    
Namespace
api.tx.nft.issueSoulbound
Type
function issueSoulbound(
  collection_id: u32,
  quantity: u32,
  token_owner: SeedPrimitivesSignatureAccountId20,
  burn_authority: TokenBurnAuthority
)

acceptSoulboundIssuance

Accept the issuance of a soulbound token
  • collection_id - The collection id the issuance is for
  • issuance_id - The issuance id. An issuance id is created and emitted when a soulbound token is issued. All pending issuances for an account can be retrieved by querying the collection’s pending issuances.
Namespace
api.tx.nft.acceptSoulboundIssuance
Type
function acceptSoulboundIssuance(
  collection_id: u32,
  issuance_id: u32,
)

setAdditionalData

Sets additional data for a token. This allows storing extra information for a token outside the collection metadata.
  • token_id - The token id (collection_id, serial_number) to set data for
  • additional_data - Optional additional data. Pass None to remove existing data
Namespace
api.tx.nft.setAdditionalData
Type
function setAdditionalData(
  token_id: (u32,u32),
  additional_data: Option<Bytes>
)

mintWithAdditionalData

Mint a single token alongside some additional data. This is equivalent to calling mint followed by setAdditionalData, but more efficient.
  • collection_id - The collection to mint the token in
  • token_owner - The token owner, defaults to the caller if unspecified
  • additional_data - Additional data to store with the token
Namespace
api.tx.nft.mintWithAdditionalData
Type
function mintWithAdditionalData(
  collection_id: u32,
  token_owner: Option<SeedPrimitivesSignatureAccountId20>,
  additional_data: Bytes
)

Storage

collectionInfo

Map from collection to its information Namespace
api.query.nft.collectionInfo
Type
function collectionInfo(
  u32
): Option<PalletNftCollectionInformation>

tokenInfo

Map from a token to its information, including owner, lock status and utility flags Namespace
api.query.nft.tokenInfo
Type
type TokenInformation = {
  owner: SeedPrimitivesSignatureAccountId20,
  lock_status: Option<SeedPrimitivesNftTokenLockReason>,
  utility_flags: {
    transferable: bool,
    burn_authority: Option<TokenBurnAuthority>
  }
}

function tokenInfo(
  collection_id: u32,
  serial_number: u32
): Option<TokenInformation>

ownedTokens

All tokens owned by a single account, organized by collection Namespace
api.query.nft.ownedTokens
Type
function ownedTokens(
  account_id: SeedPrimitivesSignatureAccountId20,
  collection_id: u32
): Vec<u32>

nextCollectionId

The next available incrementing collection id Namespace
api.query.nft.nextCollectionId
Type
function nextCollectionId(

): u32

publicMintInfo

Map from collection to its public minting information Namespace
api.query.nft.publicMintInfo
Type
function publicMintInfo(
  u32
): Option<SeedPalletCommonUtilsPublicMintInformation>

utilityFlags

Map from a collection id to its utility flags. These flags control operations at the collection level and apply to all tokens unless overridden by token-specific flags. Namespace
api.query.nft.utilityFlags
Type
type CollectionUtilityFlags = {
  transferable: bool,
  burnable: bool,
  mintable: bool,
}

function utilityFlags(u32): CollectionUtilityFlags

additionalTokenData

Map from a token_id to additional token data. Useful for assigning extra information to a token outside the collection metadata. Namespace
api.query.nft.additionalTokenData
Type
function additionalTokenData(
  (u32, u32)
): Bytes

tokenUtilityFlags

Map from a token id to its utility flags. Token-level flags take priority over collection-level flags, allowing fine-grained control over individual tokens. Namespace
api.query.nft.tokenUtilityFlags
Type
type TokenUtilityFlags = {
  transferable: bool,
  burnAuthority: Option<TokenBurnAuthority>,
}

function tokenUtilityFlags(
  (u32, u32)
): TokenUtilityFlags

pendingIssuances

Map from a collection id to the collection’s pending issuances Namespace
api.query.nft.pendingIssuances
Type
type PendingIssuance = {
  issuanceId: u32;
  quantity: u32;
  burnAuthority: TokenBurnAuthority;
}

type CollectionPendingIssuances = {
  nextIssuanceId: u32;
  pendingIssuances: Vec<(AccountId, PendingIssuance)>;
}

function pendingIssuances(
  u32
): CollectionPendingIssuances
Can be used to retrieve pending issuances for a particular account.
const collectionIssuances = await api.query.nft.pendingIssuances(collectionId);
const pendingIssuances =
  collectionIssuances.
    pendingIssuances.
    toJSON().
    find((p) => p[0] === accountId);

Events

BaseUriSet

Base URI was set Namespace
api.events.nft.BaseUriSet
Type
type BaseUriSet = {
  collection_id: u32,
  base_uri: Bytes
}

BridgedMint

Token(s) were bridged Namespace
api.events.nft.BridgedMint
Type
type BridgedMint = {
  collection_id: u32,
  serial_numbers: Vec<u32>,
  owner: SeedPrimitivesSignatureAccountId20
}

Burn

A token was burned Namespace
api.events.nft.Burn
Type
type Burn = {
  token_owner: SeedPrimitivesSignatureAccountId20,
  collection_id: u32,
  serial_number: u32
}

CollectionClaimed

Collection has been claimed Namespace
api.events.nft.CollectionClaimed
Type
type CollectionClaimed = {
  account: SeedPrimitivesSignatureAccountId20,
  collection_id: u32
}

CollectionCreate

A new collection of tokens was created Namespace
api.events.nft.CollectionCreate
Type
type CollectionCreate = {
  collection_uuid: u32,
  initial_issuance: u32,
  max_issuance: Option<u32>,
  collection_owner: SeedPrimitivesSignatureAccountId20,
  metadata_scheme: Bytes,
  name: Bytes,
  royalties_schedule: Option<SeedPrimitivesNftRoyaltiesSchedule>,
  origin_chain: SeedPrimitivesNftOriginChain,
  compatibility: PalletNftCrossChainCompatibility
}

MaxIssuanceSet

Max issuance was set Namespace
api.events.nft.MaxIssuanceSet
Type
type MaxIssuanceSet = {
  collection_id: u32,
  max_issuance: u32
}

Mint

Token(s) were minted Namespace
api.events.nft.Mint
Type
type Mint = {
  collection_id: u32,
  start: u32,
  end: u32,
  owner: SeedPrimitivesSignatureAccountId20
}

MintFeePaid

Payment was made to cover a public mint Namespace
api.events.nft.MintFeePaid
Type
type MintFeePaid = {
  who: SeedPrimitivesSignatureAccountId20,
  collection_id: u32,
  payment_asset: u32,
  payment_amount: u128,
  token_count: u32
}

MintPriceSet

A mint price was set for a collection Namespace
api.events.nft.MintPriceSet
Type
type MintPriceSet = {
  collection_id: u32,
  payment_asset: Option<u32>,
  mint_price: Option<u128>
}

NameSet

Name was set Namespace
api.events.nft.NameSet
Type
type NameSet = {
  collection_id: u32,
  name: Bytes
}

OwnerSet

A new owner was set Namespace
api.events.nft.OwnerSet
Type
type OwnerSet = {
  collection_id: u32,
  new_owner: SeedPrimitivesSignatureAccountId20
}

PublicMintToggle

Public minting was enabled/disabled for a collection Namespace
api.events.nft.PublicMintToggle
Type
type PublicMintToggle = {
  collection_id: u32,
  enabled: bool
}

RoyaltiesScheduleSet

Royalties schedule was set Namespace
api.events.nft.RoyaltiesScheduleSet
Type
type RoyaltiesScheduleSet = {
  collection_id: u32,
  royalties_schedule: SeedPrimitivesNftRoyaltiesSchedule
}

Transfer

A token was transferred Namespace
api.events.nft.Transfer
Type
type Transfer = {
  previous_owner: SeedPrimitivesSignatureAccountId20,
  collection_id: u32,
  serial_numbers: Vec<u32>,
  new_owner: SeedPrimitivesSignatureAccountId20
}

UtilityFlagsSet

Utility flags were set for a collection Namespace
api.events.nft.UtilityFlagsSet
Type
type UtilityFlagsSet = {
  collection_id: u32,
  utility_flags: CollectionUtilityFlags
}

TokenTransferableFlagSet

Token transferable flag was set Namespace
api.events.nft.TokenTransferableFlagSet
Type
type TokenTransferableFlagSet = {
  token_id: (u32, u32),
  transferable: bool
}

PendingIssuanceCreated

A pending issuance for a soulbound token was created Namespace
api.events.nft.PendingIssuanceCreated
Type
type PendingIssuanceCreated = {
  collection_id: u32,
  issuance_id: u32,
  token_owner: SeedPrimitivesSignatureAccountId20,
  quantity: u32,
  burn_authority: TokenBurnAuthority,
}

Issued

Soulbound tokens were successfully issued Namespace
api.events.nft.Issued
Type
type Issued = {
  token_owner: SeedPrimitivesSignatureAccountId20,
  start: u32,
  end: u32,
  burn_authority: TokenBurnAuthority,
}

AdditionalDataSet

Some additional data has been set for a token Namespace
api.events.nft.AdditionalDataSet
Type
type AdditionalDataSet = {
  token_id: (u32, u32),
  additional_data: Option<Bytes>,
}

Errors

AttemptedMintOnBridgedToken

Attemped to mint a token that was bridged from a different chain Namespace
api.errors.nft.AttemptedMintOnBridgedToken

BlockedMint

Token(s) blocked from minting during the bridging process Namespace
api.errors.nft.BlockedMint

CannotClaimNonClaimableCollections

Cannot claim already claimed collections Namespace
api.errors.nft.CannotClaimNonClaimableCollections

CannotUpdateMetadata

Only Root originated NFTs that are not XLS-20 compatible can have their metadata updated Namespace
api.errors.nft.CannotUpdateMetadata

CollectionIssuanceNotZero

Total issuance of collection must be zero to add xls20 compatibility Namespace
api.errors.nft.CollectionIssuanceNotZero

MintUtilityBlocked

Minting has been disabled for tokens within this collection Namespace
api.errors.nft.MintUtilityBlocked

CollectionNameInvalid

Given collection name is invalid (invalid utf-8, too long, empty) Namespace
api.errors.nft.CollectionNameInvalid

InitialIssuanceNotZero

Initial issuance on XLS-20 compatible collections must be zero Namespace
api.errors.nft.InitialIssuanceNotZero

InvalidMaxIssuance

Max issuance needs to be greater than 0 and initial_issuance Cannot exceed MaxTokensPerCollection Namespace
api.errors.nft.InvalidMaxIssuance

InvalidMetadataPath

The metadata path is invalid (non-utf8 or empty) Namespace
api.errors.nft.InvalidMetadataPath

InvalidNewOwner

The caller can not be the new owner Namespace
api.errors.nft.InvalidNewOwner

InvalidAdditionalData

The additional data cannot be an empty vec Namespace
api.errors.nft.InvalidAdditionalData

MaxIssuanceAlreadySet

The max issuance has already been set and can’t be changed Namespace
api.errors.nft.MaxIssuanceAlreadySet

MaxIssuanceReached

The collection max issuance has been reached and no more tokens can be minted Namespace
api.errors.nft.MaxIssuanceReached

MintLimitExceeded

The quantity exceeds the max tokens per mint limit Namespace
api.errors.nft.MintLimitExceeded

NoAvailableIds

No more Ids are available, they’ve been exhausted Namespace
api.errors.nft.NoAvailableIds

NoCollectionFound

The collection does not exist Namespace
api.errors.nft.NoCollectionFound

NotCollectionOwner

Origin is not the collection owner and is not permitted to perform the operation Namespace
api.errors.nft.NotCollectionOwner

NoToken

The token does not exist Namespace
api.errors.nft.NoToken

NotTokenOwner

Origin does not own the NFT Namespace
api.errors.nft.NotTokenOwner

PublicMintDisabled

This collection has not allowed public minting Namespace
api.errors.nft.PublicMintDisabled

RoyaltiesInvalid

Total royalties would exceed 100% of sale or an empty vec is supplied Namespace
api.errors.nft.RoyaltiesInvalid

TokenLimitExceeded

The number of tokens have exceeded the max tokens allowed Namespace
api.errors.nft.TokenLimitExceeded

TokenLocked

Cannot operate on a listed NFT Namespace
api.errors.nft.TokenLocked

TransferUtilityBlocked

Transfer has been disabled for tokens within this collection Namespace
api.errors.nft.TransferUtilityBlocked

BurnUtilityBlocked

Burning has been disabled for tokens within this collection Namespace
api.errors.nft.BurnUtilityBlocked

PendingIssuanceLimitExceeded

The number of pending issuances has exceeded the max for a collection Namespace
api.errors.nft.PendingIssuanceLimitExceeded

InvalidPendingIssuance

Attempted to accept an issuance that does not exist, or is not set for the caller Namespace
api.errors.nft.InvalidPendingIssuance

CannotUpdateTokenUtility

Attempted to update the token utility flags for a soulbound token Namespace
api.errors.nft.CannotUpdateTokenUtility

InvalidBurnAuthority

Attempted to burn a token from an account that does not adhere to the token’s burn authority Namespace
api.errors.nft.InvalidBurnAuthority

SerialNumbersNotUnique

The SerialNumbers attempting to be transferred are not unique Namespace
api.errors.nft.SerialNumbersNotUnique

Constants

palletId

This pallet’s Id, used for deriving a sovereign account ID Namespace
api.consts.nft.palletId
Type
type palletId = FrameSupportPalletId

stringLimit

The maximum length of a collection name, stored on-chain Namespace
api.consts.nft.stringLimit
Type
type stringLimit = u32

JSON-RPC Methods

ownedTokens

Get all NFTs owned by an account Interface
api.rpc.nft.ownedTokens(collectionId: CollectionUuid, who: AccountId, cursor: SerialNumber, limit: u16): Json
JSON
{ "id":1, "jsonrpc":"2.0", "method":"nft_ownedTokens", "params":[collectionId: CollectionUuid, who: AccountId, cursor: SerialNumber, limit: u16] }

tokenUri

Get the URI of a token Interface
api.rpc.nft.tokenUri(tokenId: TokenId): Json
JSON
{ "id":1, "jsonrpc":"2.0", "method":"nft_tokenUri", "params":[tokenId: TokenId] }

collectionDetails

Get information related to a collection such as name, owner and max issuance Interface
api.rpc.nft.collectionDetails(collectionId: CollectionUuid): Json
JSON
{ "id":1, "jsonrpc":"2.0", "method":"nft_collectionDetails", "params":[collectionId: CollectionUuid] }