> ## Documentation Index
> Fetch the complete documentation index at: https://docs.therootnetwork.com/llms.txt
> Use this file to discover all available pages before exploring further.

# NFT

## 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](./nft#acceptsoulboundissuance).

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](./nft#pendingissuances).

**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] }
```