> ## 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. # Sft ## Calls ### burn Burn a token 🔥 Caller must be the token owner **Namespace** ``` api.tx.sft.burn ``` **Type** ``` function burn( collection_id: u32, serial_numbers: Vec<(u32,u128)> ) ``` ### createCollection Create a new collection to group multiple semi-fungible tokens Tokens can be created within the collection by calling create\_token `collection_name` - the name of the collection `collection_owner` - the collection 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. The collectionUuid used to store the SFT CollectionInfo is retrieved from the NFT pallet. This is so that CollectionUuids are unique across all collections, regardless of if they are SFT or NFT collections. **Namespace** ``` api.tx.sft.createCollection ``` **Type** ``` function createCollection( collection_name: Bytes, collection_owner: Option, metadata_scheme: Bytes, royalties_schedule: Option ) ``` ### createToken Create additional tokens for an existing collection These tokens act similar to tokens within an ERC1155 contract Each token has individual issuance, max\_issuance, **Namespace** ``` api.tx.sft.createToken ``` **Type** ``` function createToken( collection_id: u32, token_name: Bytes, initial_issuance: u128, max_issuance: Option, token_owner: Option ) ``` ### createTokenWithAdditionalData Create additional tokens for an existing collection with additional data. These tokens act similar to tokens within an ERC1155 contract. Each token has individual issuance, max\_issuance, and additional data. **Namespace** ``` api.tx.sft.createTokenWithAdditionalData ``` **Type** ``` function createTokenWithAdditionalData( collection_id: u32, token_name: Bytes, initial_issuance: u128, max_issuance: Option, token_owner: Option, additional_data: Bytes ) ``` ### mint Mints some balances into some serial numbers for an account This acts as a batch mint function and allows for multiple serial numbers and quantities to be passed in simultaneously. Must be called by the collection owner `collection_id` - the SFT collection to mint into `serial_numbers` - A list of serial numbers to mint into `quantities` - A list of quantities to mint into each serial number `token_owner` - The owner of the tokens, defaults to the caller **Namespace** ``` api.tx.sft.mint ``` **Type** ``` function mint( collection_id: u32, serial_numbers: Vec<(u32,u128)>, token_owner: Option ) ``` ### setBaseUri Set the base URI of a collection (MetadataScheme) Caller must be the current collection owner **Namespace** ``` api.tx.sft.setBaseUri ``` **Type** ``` function setBaseUri( collection_id: u32, metadata_scheme: Bytes ) ``` ### setMaxIssuance Set the max issuance of a collection Caller must be the current collection owner **Namespace** ``` api.tx.sft.setMaxIssuance ``` **Type** ``` function setMaxIssuance( token_id: (u32,u32), max_issuance: u128 ) ``` ### setMintFee **Namespace** ``` api.tx.sft.setMintFee ``` **Type** ``` function setMintFee( token_id: (u32,u32), pricing_details: Option<(u32,u128)> ) ``` ### setName Set the name of a collection Caller must be the current collection owner **Namespace** ``` api.tx.sft.setName ``` **Type** ``` function setName( collection_id: u32, collection_name: Bytes ) ``` ### setOwner Set the owner of a collection Caller must be the current collection owner **Namespace** ``` api.tx.sft.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.sft.setRoyaltiesSchedule ``` **Type** ``` function setRoyaltiesSchedule( collection_id: u32, royalties_schedule: SeedPrimitivesNftRoyaltiesSchedule ) ``` ### togglePublicMint **Namespace** ``` api.tx.sft.togglePublicMint ``` **Type** ``` function togglePublicMint( token_id: (u32,u32), enabled: bool ) ``` ### setTokenName **Namespace** ``` api.tx.sft.setTokenName ``` **Type** ``` function setTokenName( token_id: (u32, u32), token_name: Bytes ) ``` ### transfer Transfer ownership of an SFT Caller must be the token owner **Namespace** ``` api.tx.sft.transfer ``` **Type** ``` function transfer( collection_id: u32, serial_numbers: Vec<(u32,u128)>, new_owner: SeedPrimitivesSignatureAccountId20 ) ``` ### setUtilityFlags Set utility flags of a collection. This allows restricting certain operations on a collection such as transfer, burn or mint. Caller must be the collection owner. * *collection\_id* - The id of the collection * *utility\_flags* - An object containing the utility flags. ``` CollectionUtilityFlags { transferable: bool, burnable: bool, mintable: bool, } ``` **Namespace** ``` api.tx.sft.setUtilityFlags ``` **Type** ``` function setUtilityFlags( collection_id: u32, utility_flags: CollectionUtilityFlags, ) ``` ### setTokenTransferableFlag Set transferable flag on a token, allowing or disallowing transfers. Caller must be the collection owner. **Namespace** ``` api.tx.sft.setTokenTransferableFlag ``` **Type** ``` function setTokenTransferableFlag( token_id: (u32, u32), transferable: bool, ) ``` ### setTokenBurnAuthority Set burn authority on a token. This value will be immutable once set. Caller must be the collection owner. * *token\_id* -. The token id * *burn\_authority* - The token burn authority. This value will dictate which account is allowed to burn the token. ``` 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.sft.setTokenBurnAuthority` **Type** ``` function setTokenBurnAuthority( token_id: (u32, u32), burn_authority: TokenBurnAuthority ) ``` ### setAdditionalData Set additional data for a token. This allows collection owners or token owners to store custom data associated with specific tokens. * `token_id` - The token id to set additional data for * `additional_data` - Custom data to associate with the token **Namespace** ``` api.tx.sft.setAdditionalData ``` **Type** ``` function setAdditionalData( token_id: (u32,u32), additional_data: Bytes ) ``` ### burnAsCollectionOwner Burn a token as the collection owner. The burn authority must have already been set and set to either the collection owner or both. * *token\_owner* - The account id of the token owner * *collection\_id* - The collection id * *serial\_numbers* - Array of serial number and the amount of tokens to burn **Namespace** ``` api.tx.sft.burnAsCollectionOwner ``` **Type** ``` function burnAsCollectionOwner( token_owner: SeedPrimitivesSignatureAccountId20, collection_id: u32, serial_numbers: Vec ) ``` ### issueSoulbound Issue soulbound tokens. The issuance will be pending until the token owner accepts the issuance. The burn authority for the specified tokens must already have been set prior to attempting to issue the tokens. * *token\_owner* - Account id of the token owner. The tokens will be burned for this account. * *collection\_id* - The collection id to issue the tokens for * *serial\_numbers* - List of token ids and the amount to issue **Namespace** ``` api.tx.sft.issueSoulbound ``` **Type** ``` function issueSoulbound( colelction_id: u32, serial_numbers: Vec<(u32, u32)>, token_owner: ) ``` ### acceptSoulboundIssuance Accept the issuance of a soulbound tokens * *collection\_id* - The collection id * *issuance\_id* - The issuance id. An issuance id is created and emitted on issuance. All pending issuances for an account can be retrieved by querying the collection's [pending issuances](./sft#pendingissuances). **Namespace** ``` api.tx.sft.acceptSoulboundIssuance ``` **Type** ``` function acceptSoulboundIssuance( collection_id: u32, issuance_idL u32 ) ``` ## Storage ### publicMintInfo Map from collection to its public minting information **Namespace** ``` api.query.sft.publicMintInfo ``` **Type** ``` function publicMintInfo( (u32,u32) ): Option ``` ### sftCollectionInfo Map from collection to its information **Namespace** ``` api.query.sft.sftCollectionInfo ``` **Type** ``` function sftCollectionInfo( u32 ): Option ``` ### tokenInfo Map from token to its token information, including ownership information **Namespace** ``` api.query.sft.tokenInfo ``` **Type** ``` function tokenInfo( (u32,u32) ): Option ``` ### utilityFlags Map from a collection id to it's utility flags **Namespace** ``` api.query.sft.utilityFlags ``` **Type** ``` function utilityFlags(u32): CollectionUtilityFlags ``` ### tokenUtilityFlags Map from a token id to its utility flags **Namespace** ``` api.query.sft.tokenUtilityFlags ``` **Type** ``` type TokenUtilityFlags = { transferable: bool, burnAuthority: Option, } function tokenUtilityFlags( (u32, u32) ): TokenUtilityFlags ``` ### additionalData Map from a token id to its additional data **Namespace** ``` api.query.sft.additionalData ``` **Type** ``` function additionalData( (u32, u32) ): Option ``` ### pendingIssuances Map from a collection id to the collection's pending issuances **Namespace** ``` api.query.sft.pendingIssuances ``` **Type** ``` type SftPendingIssuance = { issuanceId: u32; serial_numbers: Vec<(u32, u32)> } 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.sft.pendingIssuances(collectionId); const pendingIssuances = collectionIssuances. pendingIssuances. toJSON(). find((p) => p[0] === accountId); ``` ## Events ### BaseUriSet Base URI was set **Namespace** ``` api.events.sft.BaseUriSet ``` **Type** ``` type BaseUriSet = { collection_id: u32, metadata_scheme: Bytes } ``` ### Burn A token was burned **Namespace** ``` api.events.sft.Burn ``` **Type** ``` type Burn = { collection_id: u32, serial_numbers: Vec, balances: Vec, owner: SeedPrimitivesSignatureAccountId20 } ``` ### CollectionCreate A new collection of tokens was created **Namespace** ``` api.events.sft.CollectionCreate ``` **Type** ``` type CollectionCreate = { collection_id: u32, collection_owner: SeedPrimitivesSignatureAccountId20, metadata_scheme: Bytes, name: Bytes, royalties_schedule: Option, origin_chain: SeedPrimitivesNftOriginChain } ``` ### MaxIssuanceSet Max issuance was set **Namespace** ``` api.events.sft.MaxIssuanceSet ``` **Type** ``` type MaxIssuanceSet = { token_id: (u32,u32), max_issuance: u128 } ``` ### Mint Token(s) were minted **Namespace** ``` api.events.sft.Mint ``` **Type** ``` type Mint = { collection_id: u32, serial_numbers: Vec, balances: Vec, owner: SeedPrimitivesSignatureAccountId20 } ``` ### MintFeePaid Payment was made to cover a public mint **Namespace** ``` api.events.sft.MintFeePaid ``` **Type** ``` type MintFeePaid = { who: SeedPrimitivesSignatureAccountId20, token_id: (u32,u32), payment_asset: u32, payment_amount: u128, token_count: u128 } ``` ### MintPriceSet A mint price was set for a collection **Namespace** ``` api.events.sft.MintPriceSet ``` **Type** ``` type MintPriceSet = { token_id: (u32,u32), payment_asset: Option, mint_price: Option } ``` ### NameSet Name was set **Namespace** ``` api.events.sft.NameSet ``` **Type** ``` type NameSet = { collection_id: u32, collection_name: Bytes } ``` ### OwnerSet A new owner was set **Namespace** ``` api.events.sft.OwnerSet ``` **Type** ``` type OwnerSet = { collection_id: u32, new_owner: SeedPrimitivesSignatureAccountId20 } ``` ### PublicMintToggle Public minting was enabled/disabled for a collection **Namespace** ``` api.events.sft.PublicMintToggle ``` **Type** ``` type PublicMintToggle = { token_id: (u32,u32), enabled: bool } ``` ### RoyaltiesScheduleSet Royalties schedule was set **Namespace** ``` api.events.sft.RoyaltiesScheduleSet ``` **Type** ``` type RoyaltiesScheduleSet = { collection_id: u32, royalties_schedule: SeedPrimitivesNftRoyaltiesSchedule } ``` ### TokenCreate A new token was created within a collection **Namespace** ``` api.events.sft.TokenCreate ``` **Type** ``` type TokenCreate = { token_id: (u32,u32), initial_issuance: u128, max_issuance: Option, token_name: Bytes, token_owner: SeedPrimitivesSignatureAccountId20 } ``` ### Transfer A token was transferred **Namespace** ``` api.events.sft.Transfer ``` **Type** ``` type Transfer = { previous_owner: SeedPrimitivesSignatureAccountId20, collection_id: u32, serial_numbers: Vec, balances: Vec, new_owner: SeedPrimitivesSignatureAccountId20 } ``` ### UtilityFlagsSet Utility flags were set for a collection **Namespace** ``` api.events.sft.UtilityFlagsSet ``` **Type** ``` type UtilityFlagsSet = { collection_id: u32, utility_flags: CollectionUtilityFlags, } ``` ### TokenTransferableFlagSet Token transferable flag was set **Namespace** ``` api.events.sft.TokenTransferableFlagSet ``` **Type** ``` type TokenTransferableFlagSet = { token_id: (u32, u32), transferable: bool, } ``` ### AdditionalDataSet Additional data was set for a token **Namespace** ``` api.events.sft.AdditionalDataSet ``` **Type** ``` type AdditionalDataSet = { token_id: (u32, u32), additional_data: Bytes } ``` ### PendingIssuanceCreated A pending issuance for a soulbound token has been created **Namespace** ``` api.events.sft.PendingIssuanceCreated ``` **Type** ``` PendingIssuanceCreated = { collection_id: u32, issuance_id: u32, serial_numbers: Vec, balances: Vec, token_owner: SeedPrimitivesSignatureAccountId20, } ``` ### Issued Soulbound tokens were successfully issued **Namespace** ``` api.events.sft.Issued ``` **Type** ``` type Issued = { token_owner: SeedPrimitivesSignatureAccountId20, serial_numbers: Vec, balances: Vec, } ``` ## Errors ### InsufficientBalance The user does not own enough of this token to perform the operation **Namespace** ``` api.errors.sft.InsufficientBalance ``` ### InvalidMaxIssuance Max issuance needs to be greater than 0 and initial\_issuance Cannot exceed MaxTokensPerCollection **Namespace** ``` api.errors.sft.InvalidMaxIssuance ``` ### InvalidNewOwner Caller can not be the new owner **Namespace** ``` api.errors.sft.InvalidNewOwner ``` ### InvalidQuantity The specified quantity must be greater than 0 **Namespace** ``` api.errors.sft.InvalidQuantity ``` ### MaxIssuanceAlreadySet The max issuance has already been set and can't be changed **Namespace** ``` api.errors.sft.MaxIssuanceAlreadySet ``` ### MaxIssuanceReached The collection max issuance has been reached and no more tokens can be minted **Namespace** ``` api.errors.sft.MaxIssuanceReached ``` ### MaxOwnersReached The max amount of owners per token has been reached **Namespace** ``` api.errors.sft.MaxOwnersReached ``` ### NameInvalid Given collection or token name is invalid (invalid utf-8, empty) **Namespace** ``` api.errors.sft.NameInvalid ``` ### NoCollectionFound The collection does not exist **Namespace** ``` api.errors.sft.NoCollectionFound ``` ### NotCollectionOwner Origin is not the collection owner and is not permitted to perform the operation **Namespace** ``` api.errors.sft.NotCollectionOwner ``` ### NoToken The token does not exist **Namespace** ``` api.errors.sft.NoToken ``` ### Overflow The operation would cause a numeric overflow **Namespace** ``` api.errors.sft.Overflow ``` ### PublicMintDisabled This collection has not allowed public minting **Namespace** ``` api.errors.sft.PublicMintDisabled ``` ### RoyaltiesInvalid Total royalties would exceed 100% of sale or an empty vec is supplied **Namespace** ``` api.errors.sft.RoyaltiesInvalid ``` ### InvalidAdditionalData The additional data provided is invalid or exceeds the maximum allowed size **Namespace** ``` api.errors.sft.InvalidAdditionalData ``` ## Constants ### maxOwnersPerSftToken Max unique owners that can own an SFT token **Namespace** ``` api.consts.sft.maxOwnersPerSftToken ``` **Type** ``` type maxOwnersPerSftToken = u32 ``` ### maxSerialsPerMint Max tokens that can be minted in one transaction **Namespace** ``` api.consts.sft.maxSerialsPerMint ``` **Type** ``` type maxSerialsPerMint = u32 ``` ### maxTokensPerSftCollection Max tokens that a collection can contain **Namespace** ``` api.consts.sft.maxTokensPerSftCollection ``` **Type** ``` type maxTokensPerSftCollection = u32 ``` ### palletId This pallet's Id, used for deriving a sovereign account ID **Namespace** ``` api.consts.sft.palletId ``` **Type** ``` type palletId = FrameSupportPalletId ``` ### stringLimit The maximum length of a collection or token name, stored on-chain **Namespace** ``` api.consts.sft.stringLimit ``` **Type** ``` type stringLimit = u32 ```