Asset¶

Calls¶

accept_asset_ownership_transfer¶

This function is used to accept a token ownership transfer. NB: To reject the transfer, call remove auth function in identity module.

# Arguments * origin It contains the secondary key of the caller (i.e. who signed the transaction to execute this function). * auth_id Authorization ID of the token ownership transfer authorization.

Attributes¶

Name	Type
auth_id	`u64`

Python¶

call = substrate.compose_call(
    'Asset', 'accept_asset_ownership_transfer', {'auth_id': 'u64'}
)

accept_ticker_transfer¶

Accepts a ticker transfer.

Consumes the authorization auth_id (see pallet_identity::consume_auth). NB: To reject the transfer, call remove auth function in identity module.

# Arguments * origin It contains the secondary key of the caller (i.e. who signed the transaction to execute this function). * auth_id Authorization ID of ticker transfer authorization.

## Errors - AuthorizationError::BadType if auth_id is not a valid ticket transfer authorization.

Attributes¶

Name	Type
auth_id	`u64`

Python¶

call = substrate.compose_call(
    'Asset', 'accept_ticker_transfer', {'auth_id': 'u64'}
)

add_documents¶

Add documents for a given token.

# Arguments * origin is a signer that has permissions to act as an agent of ticker. * ticker Ticker of the token. * docs Documents to be attached to ticker.

# Permissions * Asset

Attributes¶

Name	Type
docs	`Vec<Document>`
ticker	`Ticker`

Python¶

call = substrate.compose_call(
    'Asset', 'add_documents', {
    'docs': [
        {
            'content_hash': {
                'H128': '[u8; 16]',
                'H160': '[u8; 20]',
                'H192': '[u8; 24]',
                'H224': '[u8; 28]',
                'H256': '[u8; 32]',
                'H320': '[u8; 40]',
                'H384': '[u8; 48]',
                'H512': '[u8; 64]',
                'None': None,
            },
            'doc_type': (
                None,
                'Bytes',
            ),
            'filing_date': (
                None,
                'u64',
            ),
            'name': 'Bytes',
            'uri': 'Bytes',
        },
    ],
    'ticker': '[u8; 12]',
}
)

add_mandatory_mediators¶

Sets all identities in the mediators set as mandatory mediators for any instruction transfering ticker.

# Arguments * origin: The secondary key of the sender. * ticker: The [Ticker] of the asset that will require the mediators. * mediators: A set of [IdentityId] of all the mandatory mediators for the given ticker.

# Permissions * Asset

Attributes¶

Name	Type
ticker	`Ticker`
mediators	`BoundedBTreeSet<IdentityId, T::MaxAssetMediators>`

Python¶

call = substrate.compose_call(
    'Asset', 'add_mandatory_mediators', {
    'mediators': 'scale_info::163',
    'ticker': '[u8; 12]',
}
)

controller_transfer¶

Forces a transfer of token from from_portfolio to the caller's default portfolio.

# Arguments * origin Must be an external agent with appropriate permissions for a given ticker. * ticker Ticker symbol of the asset. * value Amount of tokens need to force transfer. * from_portfolio From whom portfolio tokens gets transferred.

Attributes¶

Name	Type
ticker	`Ticker`
value	`Balance`
from_portfolio	`PortfolioId`

Python¶

call = substrate.compose_call(
    'Asset', 'controller_transfer', {
    'from_portfolio': {
        'did': '[u8; 32]',
        'kind': {
            'Default': None,
            'User': 'u64',
        },
    },
    'ticker': '[u8; 12]',
    'value': 'u128',
}
)

create_asset¶

Initializes a new security token, with the initiating account as its owner. The total supply will initially be zero. To mint tokens, use issue.

# Arguments * origin - contains the secondary key of the caller (i.e. who signed the transaction to execute this function). * name - the name of the token. * ticker - the ticker symbol of the token. * divisible - a boolean to identify the divisibility status of the token. * asset_type - the asset type. * identifiers - a vector of asset identifiers. * funding_round - name of the funding round.

## Errors - InvalidAssetIdentifier if any of identifiers are invalid. - MaxLengthOfAssetNameExceeded if name's length exceeds T::AssetNameMaxLength. - FundingRoundNameMaxLengthExceeded if the name of the funding round is longer that T::FundingRoundNameMaxLength. - AssetAlreadyCreated if asset was already created. - TickerTooLong if ticker's length is greater than config.max_ticker_length chain parameter. - TickerNotAlphanumeric if ticker is not yet registered, and contains non-alphanumeric characters or any character after first occurrence of \0.

## Permissions * Portfolio

Attributes¶

Name	Type
name	`AssetName`
ticker	`Ticker`
divisible	`bool`
asset_type	`AssetType`
identifiers	`Vec<AssetIdentifier>`
funding_round	`Option<FundingRoundName>`

Python¶

call = substrate.compose_call(
    'Asset', 'create_asset', {
    'asset_type': {
        'Commodity': None,
        'Custom': 'u32',
        'Derivative': None,
        'EquityCommon': None,
        'EquityPreferred': None,
        'FixedIncome': None,
        'Fund': None,
        'NonFungible': {
            'Custom': 'u32',
            'Derivative': None,
            'FixedIncome': None,
            'Invoice': None,
        },
        'REIT': None,
        'RevenueShareAgreement': None,
        'StableCoin': None,
        'StructuredProduct': None,
    },
    'divisible': 'bool',
    'funding_round': (None, 'Bytes'),
    'identifiers': [
        {
            'CINS': '[u8; 9]',
            'CUSIP': '[u8; 9]',
            'FIGI': '[u8; 12]',
            'ISIN': '[u8; 12]',
            'LEI': '[u8; 20]',
        },
    ],
    'name': 'Bytes',
    'ticker': '[u8; 12]',
}
)

create_asset_with_custom_type¶

Utility extrinsic to batch create_asset and register_custom_asset_type.

Attributes¶

Name	Type
name	`AssetName`
ticker	`Ticker`
divisible	`bool`
custom_asset_type	`Vec<u8>`
identifiers	`Vec<AssetIdentifier>`
funding_round	`Option<FundingRoundName>`

Python¶

call = substrate.compose_call(
    'Asset', 'create_asset_with_custom_type', {
    'custom_asset_type': 'Bytes',
    'divisible': 'bool',
    'funding_round': (None, 'Bytes'),
    'identifiers': [
        {
            'CINS': '[u8; 9]',
            'CUSIP': '[u8; 9]',
            'FIGI': '[u8; 12]',
            'ISIN': '[u8; 12]',
            'LEI': '[u8; 20]',
        },
    ],
    'name': 'Bytes',
    'ticker': '[u8; 12]',
}
)

exempt_ticker_affirmation¶

Pre-approves the receivement of the asset for all identities.

# Arguments * origin - the secondary key of the sender. * ticker - the [Ticker] that will be exempt from affirmation.

# Permissions * Root

Attributes¶

Name	Type
ticker	`Ticker`

Python¶

call = substrate.compose_call(
    'Asset', 'exempt_ticker_affirmation', {'ticker': '[u8; 12]'}
)

freeze¶

Freezes transfers of a given token.

# Arguments * origin - the secondary key of the sender. * ticker - the ticker of the token.

## Errors - AlreadyFrozen if ticker is already frozen.

# Permissions * Asset

Attributes¶

Name	Type
ticker	`Ticker`

Python¶

call = substrate.compose_call(
    'Asset', 'freeze', {'ticker': '[u8; 12]'}
)

issue¶

Issue, or mint, new tokens to the caller, which must be an authorized external agent.

# Arguments * origin - A signer that has permissions to act as an agent of ticker. * ticker - The [Ticker] of the token. * amount - The amount of tokens that will be issued. * portfolio_kind - The [PortfolioKind] of the portfolio that will receive the minted tokens.

# Permissions * Asset * Portfolio

Attributes¶

Name	Type
ticker	`Ticker`
amount	`Balance`
portfolio_kind	`PortfolioKind`

Python¶

call = substrate.compose_call(
    'Asset', 'issue', {
    'amount': 'u128',
    'portfolio_kind': {
        'Default': None,
        'User': 'u64',
    },
    'ticker': '[u8; 12]',
}
)

make_divisible¶

Makes an indivisible token divisible.

# Arguments * origin is a signer that has permissions to act as an agent of ticker. * ticker Ticker of the token.

## Errors - AssetAlreadyDivisible if ticker is already divisible.

# Permissions * Asset

Attributes¶

Name	Type
ticker	`Ticker`

Python¶

call = substrate.compose_call(
    'Asset', 'make_divisible', {'ticker': '[u8; 12]'}
)

pre_approve_ticker¶

Pre-approves the receivement of an asset.

# Arguments * origin - the secondary key of the sender. * ticker - the [Ticker] that will be exempt from affirmation.

# Permissions * Asset

Attributes¶

Name	Type
ticker	`Ticker`

Python¶

call = substrate.compose_call(
    'Asset', 'pre_approve_ticker', {'ticker': '[u8; 12]'}
)

redeem¶

Redeems existing tokens by reducing the balance of the caller's default portfolio and the total supply of the token

# Arguments * origin is a signer that has permissions to act as an agent of ticker. * ticker Ticker of the token. * value Amount of tokens to redeem.

# Errors - Unauthorized If called by someone without the appropriate external agent permissions - InvalidGranularity If the amount is not divisible by 10^6 for non-divisible tokens - InsufficientPortfolioBalance If the caller's default portfolio doesn't have enough free balance

# Permissions * Asset * Portfolio

Attributes¶

Name	Type
ticker	`Ticker`
value	`Balance`

Python¶

call = substrate.compose_call(
    'Asset', 'redeem', {
    'ticker': '[u8; 12]',
    'value': 'u128',
}
)

redeem_from_portfolio¶

Redeems existing tokens by reducing the balance of the caller's portfolio and the total supply of the token

# Arguments * origin is a signer that has permissions to act as an agent of ticker. * ticker Ticker of the token. * value Amount of tokens to redeem. * portfolio From whom portfolio tokens gets transferred.

# Errors - Unauthorized If called by someone without the appropriate external agent permissions - InvalidGranularity If the amount is not divisible by 10^6 for non-divisible tokens - InsufficientPortfolioBalance If the caller's portfolio doesn't have enough free balance - PortfolioDoesNotExist If the portfolio doesn't exist.

# Permissions * Asset * Portfolio

Attributes¶

Name	Type
ticker	`Ticker`
value	`Balance`
portfolio	`PortfolioKind`

Python¶

call = substrate.compose_call(
    'Asset', 'redeem_from_portfolio', {
    'portfolio': {
        'Default': None,
        'User': 'u64',
    },
    'ticker': '[u8; 12]',
    'value': 'u128',
}
)

register_and_set_local_asset_metadata¶

Registers and set local asset metadata.

# Arguments * origin is a signer that has permissions to act as an agent of ticker. * ticker Ticker of the token. * name Metadata name. * spec Metadata type definition. * value Metadata value. * details Optional Metadata value details (expire, lock status).

# Errors * AssetMetadataLocalKeyAlreadyExists if a local metadata type with name already exists for ticker. * AssetMetadataNameMaxLengthExceeded if the metadata name exceeds the maximum length. * AssetMetadataTypeDefMaxLengthExceeded if the metadata spec type definition exceeds the maximum length. * AssetMetadataValueMaxLengthExceeded if the metadata value exceeds the maximum length.

# Permissions * Agent * Asset

Attributes¶

Name	Type
ticker	`Ticker`
name	`AssetMetadataName`
spec	`AssetMetadataSpec`
value	`AssetMetadataValue`
detail	`Option<AssetMetadataValueDetail<T::Moment>>`

Python¶

call = substrate.compose_call(
    'Asset', 'register_and_set_local_asset_metadata', {
    'detail': (
        None,
        {
            'expire': (None, 'u64'),
            'lock_status': {
                'Locked': None,
                'LockedUntil': 'u64',
                'Unlocked': None,
            },
        },
    ),
    'name': 'Bytes',
    'spec': {
        'description': (None, 'Bytes'),
        'type_def': (None, 'Bytes'),
        'url': (None, 'Bytes'),
    },
    'ticker': '[u8; 12]',
    'value': 'Bytes',
}
)

register_asset_metadata_global_type¶

Registers asset metadata global type.

# Arguments * origin is a signer that has permissions to act as an agent of ticker. * name Metadata name. * spec Metadata type definition.

# Errors * AssetMetadataGlobalKeyAlreadyExists if a globa metadata type with name already exists. * AssetMetadataNameMaxLengthExceeded if the metadata name exceeds the maximum length. * AssetMetadataTypeDefMaxLengthExceeded if the metadata spec type definition exceeds the maximum length.

Attributes¶

Name	Type
name	`AssetMetadataName`
spec	`AssetMetadataSpec`

Python¶

call = substrate.compose_call(
    'Asset', 'register_asset_metadata_global_type', {
    'name': 'Bytes',
    'spec': {
        'description': (None, 'Bytes'),
        'type_def': (None, 'Bytes'),
        'url': (None, 'Bytes'),
    },
}
)

register_asset_metadata_local_type¶

Registers asset metadata local type.

# Arguments * origin is a signer that has permissions to act as an agent of ticker. * ticker Ticker of the token. * name Metadata name. * spec Metadata type definition.

# Errors * AssetMetadataLocalKeyAlreadyExists if a local metadata type with name already exists for ticker. * AssetMetadataNameMaxLengthExceeded if the metadata name exceeds the maximum length. * AssetMetadataTypeDefMaxLengthExceeded if the metadata spec type definition exceeds the maximum length.

# Permissions * Agent * Asset

Attributes¶

Name	Type
ticker	`Ticker`
name	`AssetMetadataName`
spec	`AssetMetadataSpec`

Python¶

call = substrate.compose_call(
    'Asset', 'register_asset_metadata_local_type', {
    'name': 'Bytes',
    'spec': {
        'description': (None, 'Bytes'),
        'type_def': (None, 'Bytes'),
        'url': (None, 'Bytes'),
    },
    'ticker': '[u8; 12]',
}
)

register_custom_asset_type¶

Registers a custom asset type.

The provided ty will be bound to an ID in storage. The ID can then be used in AssetType::Custom. Should the ty already exist in storage, no second ID is assigned to it.

# Arguments * origin who called the extrinsic. * ty contains the string representation of the asset type.

Attributes¶

Name	Type
ty	`Vec<u8>`

Python¶

call = substrate.compose_call(
    'Asset', 'register_custom_asset_type', {'ty': 'Bytes'}
)

register_ticker¶

Registers a new ticker or extends validity of an existing ticker. NB: Ticker validity does not get carry forward when renewing ticker.

# Arguments * origin It contains the secondary key of the caller (i.e. who signed the transaction to execute this function). * ticker ticker to register.

# Permissions * Asset

Attributes¶

Name	Type
ticker	`Ticker`

Python¶

call = substrate.compose_call(
    'Asset', 'register_ticker', {'ticker': '[u8; 12]'}
)

remove_documents¶

Remove documents for a given token.

# Arguments * origin is a signer that has permissions to act as an agent of ticker. * ticker Ticker of the token. * ids Documents ids to be removed from ticker.

# Permissions * Asset

Attributes¶

Name	Type
ids	`Vec<DocumentId>`
ticker	`Ticker`

Python¶

call = substrate.compose_call(
    'Asset', 'remove_documents', {'ids': ['u32'], 'ticker': '[u8; 12]'}
)

remove_local_metadata_key¶

Removes the asset metadata key and value of a local key.

# Arguments * origin - the secondary key of the sender. * ticker - the ticker of the local metadata key. * local_key - the local metadata key.

# Errors - SecondaryKeyNotAuthorizedForAsset - if called by someone without the appropriate external agent permissions. - UnauthorizedAgent - if called by someone without the appropriate external agent permissions. - AssetMetadataKeyIsMissing - if the key doens't exist. - AssetMetadataValueIsLocked - if the value of the key is locked. - AssetMetadataKeyBelongsToNFTCollection - if the key is a mandatory key in an NFT collection.

# Permissions * Asset

Attributes¶

Name	Type
ticker	`Ticker`
local_key	`AssetMetadataLocalKey`

Python¶

call = substrate.compose_call(
    'Asset', 'remove_local_metadata_key', {
    'local_key': 'u64',
    'ticker': '[u8; 12]',
}
)

remove_mandatory_mediators¶

Removes all identities in the mediators set from the mandatory mediators list for the given ticker.

# Arguments * origin: The secondary key of the sender. * ticker: The [Ticker] of the asset that will have mediators removed. * mediators: A set of [IdentityId] of all the mediators that will be removed from the mandatory mediators list.

# Permissions * Asset

Attributes¶

Name	Type
ticker	`Ticker`
mediators	`BoundedBTreeSet<IdentityId, T::MaxAssetMediators>`

Python¶

call = substrate.compose_call(
    'Asset', 'remove_mandatory_mediators', {
    'mediators': 'scale_info::163',
    'ticker': '[u8; 12]',
}
)

remove_metadata_value¶

Removes the asset metadata value of a metadata key.

# Arguments * origin - the secondary key of the sender. * ticker - the ticker of the local metadata key. * metadata_key - the metadata key that will have its value deleted.

# Errors - SecondaryKeyNotAuthorizedForAsset - if called by someone without the appropriate external agent permissions. - UnauthorizedAgent - if called by someone without the appropriate external agent permissions. - AssetMetadataKeyIsMissing - if the key doens't exist. - AssetMetadataValueIsLocked - if the value of the key is locked.

# Permissions * Asset

Attributes¶

Name	Type
ticker	`Ticker`
metadata_key	`AssetMetadataKey`

Python¶

call = substrate.compose_call(
    'Asset', 'remove_metadata_value', {
    'metadata_key': {
        'Global': 'u64',
        'Local': 'u64',
    },
    'ticker': '[u8; 12]',
}
)

remove_ticker_affirmation_exemption¶

Removes the pre-approval of the asset for all identities.

# Arguments * origin - the secondary key of the sender. * ticker - the [Ticker] that will have its exemption removed.

# Permissions * Root

Attributes¶

Name	Type
ticker	`Ticker`

Python¶

call = substrate.compose_call(
    'Asset', 'remove_ticker_affirmation_exemption', {'ticker': '[u8; 12]'}
)

remove_ticker_pre_approval¶

Removes the pre approval of an asset.

# Arguments * origin - the secondary key of the sender. * ticker - the [Ticker] that will have its exemption removed.

# Permissions * Asset

Attributes¶

Name	Type
ticker	`Ticker`

Python¶

call = substrate.compose_call(
    'Asset', 'remove_ticker_pre_approval', {'ticker': '[u8; 12]'}
)

rename_asset¶

Renames a given token.

# Arguments * origin - the secondary key of the sender. * ticker - the ticker of the token. * name - the new name of the token.

## Errors - MaxLengthOfAssetNameExceeded if length of name is greater than T::AssetNameMaxLength.

# Permissions * Asset

Attributes¶

Name	Type
ticker	`Ticker`
name	`AssetName`

Python¶

call = substrate.compose_call(
    'Asset', 'rename_asset', {
    'name': 'Bytes',
    'ticker': '[u8; 12]',
}
)

set_asset_metadata¶

Set asset metadata value.

# Arguments * origin is a signer that has permissions to act as an agent of ticker. * ticker Ticker of the token. * key Metadata key. * value Metadata value. * details Optional Metadata value details (expire, lock status).

# Errors * AssetMetadataKeyIsMissing if the metadata type key doesn't exist. * AssetMetadataValueIsLocked if the metadata value for key is locked. * AssetMetadataValueMaxLengthExceeded if the metadata value exceeds the maximum length.

# Permissions * Agent * Asset

Attributes¶

Name	Type
ticker	`Ticker`
key	`AssetMetadataKey`
value	`AssetMetadataValue`
detail	`Option<AssetMetadataValueDetail<T::Moment>>`

Python¶

call = substrate.compose_call(
    'Asset', 'set_asset_metadata', {
    'detail': (
        None,
        {
            'expire': (None, 'u64'),
            'lock_status': {
                'Locked': None,
                'LockedUntil': 'u64',
                'Unlocked': None,
            },
        },
    ),
    'key': {
        'Global': 'u64',
        'Local': 'u64',
    },
    'ticker': '[u8; 12]',
    'value': 'Bytes',
}
)

set_asset_metadata_details¶

Set asset metadata value details (expire, lock status).

# Arguments * origin is a signer that has permissions to act as an agent of ticker. * ticker Ticker of the token. * key Metadata key. * details Metadata value details (expire, lock status).

# Errors * AssetMetadataKeyIsMissing if the metadata type key doesn't exist. * AssetMetadataValueIsLocked if the metadata value for key is locked.

# Permissions * Agent * Asset

Attributes¶

Name	Type
ticker	`Ticker`
key	`AssetMetadataKey`
detail	`AssetMetadataValueDetail<T::Moment>`

Python¶

call = substrate.compose_call(
    'Asset', 'set_asset_metadata_details', {
    'detail': {
        'expire': (None, 'u64'),
        'lock_status': {
            'Locked': None,
            'LockedUntil': 'u64',
            'Unlocked': None,
        },
    },
    'key': {
        'Global': 'u64',
        'Local': 'u64',
    },
    'ticker': '[u8; 12]',
}
)

set_funding_round¶

Sets the name of the current funding round.

# Arguments * origin - a signer that has permissions to act as an agent of ticker. * ticker - the ticker of the token. * name - the desired name of the current funding round.

## Errors - FundingRoundNameMaxLengthExceeded if length of name is greater than T::FundingRoundNameMaxLength.

# Permissions * Asset

Attributes¶

Name	Type
ticker	`Ticker`
name	`FundingRoundName`

Python¶

call = substrate.compose_call(
    'Asset', 'set_funding_round', {
    'name': 'Bytes',
    'ticker': '[u8; 12]',
}
)

unfreeze¶

Unfreezes transfers of a given token.

# Arguments * origin - the secondary key of the sender. * ticker - the ticker of the frozen token.

## Errors - NotFrozen if ticker is not frozen yet.

# Permissions * Asset

Attributes¶

Name	Type
ticker	`Ticker`

Python¶

call = substrate.compose_call(
    'Asset', 'unfreeze', {'ticker': '[u8; 12]'}
)

update_asset_type¶

Updates the type of an asset.

# Arguments * origin - the secondary key of the sender. * ticker - the ticker of the token. * asset_type - the new type of the token.

## Errors - InvalidCustomAssetTypeId if asset_type is of type custom and has an invalid type id.

# Permissions * Asset

Attributes¶

Name	Type
ticker	`Ticker`
asset_type	`AssetType`

Python¶

call = substrate.compose_call(
    'Asset', 'update_asset_type', {
    'asset_type': {
        'Commodity': None,
        'Custom': 'u32',
        'Derivative': None,
        'EquityCommon': None,
        'EquityPreferred': None,
        'FixedIncome': None,
        'Fund': None,
        'NonFungible': {
            'Custom': 'u32',
            'Derivative': None,
            'FixedIncome': None,
            'Invoice': None,
        },
        'REIT': None,
        'RevenueShareAgreement': None,
        'StableCoin': None,
        'StructuredProduct': None,
    },
    'ticker': '[u8; 12]',
}
)

update_identifiers¶

Updates the asset identifiers.

# Arguments * origin - a signer that has permissions to act as an agent of ticker. * ticker - the ticker of the token. * asset_identifiers - the asset identifiers to be updated in the form of a vector of pairs of IdentifierType and AssetIdentifier value.

## Errors - InvalidAssetIdentifier if identifiers contains any invalid identifier.

# Permissions * Asset

Attributes¶

Name	Type
ticker	`Ticker`
asset_identifiers	`Vec<AssetIdentifier>`

Python¶

call = substrate.compose_call(
    'Asset', 'update_identifiers', {
    'asset_identifiers': [
        {
            'CINS': '[u8; 9]',
            'CUSIP': '[u8; 9]',
            'FIGI': '[u8; 12]',
            'ISIN': '[u8; 12]',
            'LEI': '[u8; 20]',
        },
    ],
    'ticker': '[u8; 12]',
}
)

Events¶

AssetAffirmationExemption¶

An asset has been added to the list of pre aprroved receivement (valid for all identities). Parameters: [Ticker] of the pre approved asset.

Attributes¶

Name	Type	Composition
None	`Ticker`	`[u8; 12]`

AssetBalanceUpdated¶

Emitted when Tokens were issued, redeemed or transferred. Contains the [IdentityId] of the receiver/issuer/redeemer, the [Ticker] for the token, the balance that was issued/transferred/redeemed, the [PortfolioId] of the source, the [PortfolioId] of the destination and the [PortfolioUpdateReason].

Attributes¶

Name	Type	Composition
None	`IdentityId`	`[u8; 32]`
None	`Ticker`	`[u8; 12]`
None	`Balance`	`u128`
None	`Option<PortfolioId>`	`(None, {'did': '[u8; 32]', 'kind': {'Default': None, 'User': 'u64'}})`
None	`Option<PortfolioId>`	`(None, {'did': '[u8; 32]', 'kind': {'Default': None, 'User': 'u64'}})`
None	`PortfolioUpdateReason`	`{'Issued': {'funding_round_name': (None, 'Bytes')}, 'Redeemed': None, 'Transferred': {'instruction_id': (None, 'u64'), 'instruction_memo': (None, '[u8; 32]')}, 'ControllerTransfer': None}`

AssetCreated¶

Event for creation of the asset. caller DID/ owner DID, ticker, divisibility, asset type, beneficiary DID, asset name, identifiers, funding round

Attributes¶

Name	Type	Composition
None	`IdentityId`	`[u8; 32]`
None	`Ticker`	`[u8; 12]`
None	`bool`	`bool`
None	`AssetType`	`{'EquityCommon': None, 'EquityPreferred': None, 'Commodity': None, 'FixedIncome': None, 'REIT': None, 'Fund': None, 'RevenueShareAgreement': None, 'StructuredProduct': None, 'Derivative': None, 'Custom': 'u32', 'StableCoin': None, 'NonFungible': {'Derivative': None, 'FixedIncome': None, 'Invoice': None, 'Custom': 'u32'}}`
None	`IdentityId`	`[u8; 32]`
None	`AssetName`	`Bytes`
None	`Vec<AssetIdentifier>`	`[{'CUSIP': '[u8; 9]', 'CINS': '[u8; 9]', 'ISIN': '[u8; 12]', 'LEI': '[u8; 20]', 'FIGI': '[u8; 12]'}]`
None	`Option<FundingRoundName>`	`(None, 'Bytes')`

AssetFrozen¶

An event emitted when an asset is frozen. Parameter: caller DID, ticker.

Attributes¶

Name	Type	Composition
None	`IdentityId`	`[u8; 32]`
None	`Ticker`	`[u8; 12]`

AssetMediatorsAdded¶

An identity has added mandatory mediators to an asset. Parameters: [IdentityId] of caller, [Ticker] of the asset, the identity of all mediators added.

Attributes¶

Name	Type	Composition
None	`IdentityId`	`[u8; 32]`
None	`Ticker`	`[u8; 12]`
None	`BTreeSet<IdentityId>`	`scale_info::163`

AssetMediatorsRemoved¶

An identity has removed mediators from an asset. Parameters: [IdentityId] of caller, [Ticker] of the asset, the identity of all mediators removed.

Attributes¶

Name	Type	Composition
None	`IdentityId`	`[u8; 32]`
None	`Ticker`	`[u8; 12]`
None	`BTreeSet<IdentityId>`	`scale_info::163`

AssetOwnershipTransferred¶

Emit when token ownership is transferred. caller DID / token ownership transferred to DID, ticker, from

Attributes¶

Name	Type	Composition
None	`IdentityId`	`[u8; 32]`
None	`Ticker`	`[u8; 12]`
None	`IdentityId`	`[u8; 32]`

AssetRenamed¶

An event emitted when a token is renamed. Parameters: caller DID, ticker, new token name.

Attributes¶

Name	Type	Composition
None	`IdentityId`	`[u8; 32]`
None	`Ticker`	`[u8; 12]`
None	`AssetName`	`Bytes`

AssetTypeChanged¶

An event emitted when the type of an asset changed. Parameters: caller DID, ticker, new token type.

Attributes¶

Name	Type	Composition
None	`IdentityId`	`[u8; 32]`
None	`Ticker`	`[u8; 12]`
None	`AssetType`	`{'EquityCommon': None, 'EquityPreferred': None, 'Commodity': None, 'FixedIncome': None, 'REIT': None, 'Fund': None, 'RevenueShareAgreement': None, 'StructuredProduct': None, 'Derivative': None, 'Custom': 'u32', 'StableCoin': None, 'NonFungible': {'Derivative': None, 'FixedIncome': None, 'Invoice': None, 'Custom': 'u32'}}`

AssetUnfrozen¶

An event emitted when an asset is unfrozen. Parameter: caller DID, ticker.

Attributes¶

Name	Type	Composition
None	`IdentityId`	`[u8; 32]`
None	`Ticker`	`[u8; 12]`

ControllerTransfer¶

Event for when a forced transfer takes place. caller DID/ controller DID, ticker, Portfolio of token holder, value.

Attributes¶

Name	Type	Composition
None	`IdentityId`	`[u8; 32]`
None	`Ticker`	`[u8; 12]`
None	`PortfolioId`	`{'did': '[u8; 32]', 'kind': {'Default': None, 'User': 'u64'}}`
None	`Balance`	`u128`

CustomAssetTypeExists¶

A custom asset type already exists on-chain. caller DID, the ID of the custom asset type, the string contents registered.

Attributes¶

Name	Type	Composition
None	`IdentityId`	`[u8; 32]`
None	`CustomAssetTypeId`	`u32`
None	`Vec<u8>`	`Bytes`

CustomAssetTypeRegistered¶

A custom asset type was registered on-chain. caller DID, the ID of the custom asset type, the string contents registered.

Attributes¶

Name	Type	Composition
None	`IdentityId`	`[u8; 32]`
None	`CustomAssetTypeId`	`u32`
None	`Vec<u8>`	`Bytes`

DivisibilityChanged¶

Event for change in divisibility. caller DID, ticker, divisibility

Attributes¶

Name	Type	Composition
None	`IdentityId`	`[u8; 32]`
None	`Ticker`	`[u8; 12]`
None	`bool`	`bool`

DocumentAdded¶

A new document attached to an asset

Attributes¶

Name	Type	Composition
None	`IdentityId`	`[u8; 32]`
None	`Ticker`	`[u8; 12]`
None	`DocumentId`	`u32`
None	`Document`	`{'uri': 'Bytes', 'content_hash': {'None': None, 'H512': '[u8; 64]', 'H384': '[u8; 48]', 'H320': '[u8; 40]', 'H256': '[u8; 32]', 'H224': '[u8; 28]', 'H192': '[u8; 24]', 'H160': '[u8; 20]', 'H128': '[u8; 16]'}, 'name': 'Bytes', 'doc_type': (None, 'Bytes'), 'filing_date': (None, 'u64')}`

DocumentRemoved¶

A document removed from an asset

Attributes¶

Name	Type	Composition
None	`IdentityId`	`[u8; 32]`
None	`Ticker`	`[u8; 12]`
None	`DocumentId`	`u32`

ExtensionRemoved¶

A extension got removed. caller DID, ticker, AccountId

Attributes¶

Name	Type	Composition
None	`IdentityId`	`[u8; 32]`
None	`Ticker`	`[u8; 12]`
None	`AccountId`	`AccountId`

FundingRoundSet¶

An event carrying the name of the current funding round of a ticker. Parameters: caller DID, ticker, funding round name.

Attributes¶

Name	Type	Composition
None	`IdentityId`	`[u8; 32]`
None	`Ticker`	`[u8; 12]`
None	`FundingRoundName`	`Bytes`

IdentifiersUpdated¶

Event emitted when any token identifiers are updated. caller DID, ticker, a vector of (identifier type, identifier value)

Attributes¶

Name	Type	Composition
None	`IdentityId`	`[u8; 32]`
None	`Ticker`	`[u8; 12]`
None	`Vec<AssetIdentifier>`	`[{'CUSIP': '[u8; 9]', 'CINS': '[u8; 9]', 'ISIN': '[u8; 12]', 'LEI': '[u8; 20]', 'FIGI': '[u8; 12]'}]`

IsIssuable¶

is_issuable() output ticker, return value (true if issuable)

Attributes¶

Name	Type	Composition
None	`Ticker`	`[u8; 12]`
None	`bool`	`bool`

LocalMetadataKeyDeleted¶

An event emitted when a local metadata key has been removed. Parameters: caller ticker, Local type name

Attributes¶

Name	Type	Composition
None	`IdentityId`	`[u8; 32]`
None	`Ticker`	`[u8; 12]`
None	`AssetMetadataLocalKey`	`u64`

MetadataValueDeleted¶

An event emitted when a local metadata value has been removed. Parameters: caller ticker, Local type name

Attributes¶

Name	Type	Composition
None	`IdentityId`	`[u8; 32]`
None	`Ticker`	`[u8; 12]`
None	`AssetMetadataKey`	`{'Global': 'u64', 'Local': 'u64'}`

PreApprovedAsset¶

An identity has added an asset to the list of pre aprroved receivement. Parameters: [IdentityId] of caller, [Ticker] of the pre approved asset.

Attributes¶

Name	Type	Composition
None	`IdentityId`	`[u8; 32]`
None	`Ticker`	`[u8; 12]`

RegisterAssetMetadataGlobalType¶

Register asset metadata global type. (Global type name, Global type key, type specs)

Attributes¶

Name	Type	Composition
None	`AssetMetadataName`	`Bytes`
None	`AssetMetadataGlobalKey`	`u64`
None	`AssetMetadataSpec`	`{'url': (None, 'Bytes'), 'description': (None, 'Bytes'), 'type_def': (None, 'Bytes')}`

RegisterAssetMetadataLocalType¶

Register asset metadata local type. (Caller DID, ticker, Local type name, Local type key, type specs)

Attributes¶

Name	Type	Composition
None	`IdentityId`	`[u8; 32]`
None	`Ticker`	`[u8; 12]`
None	`AssetMetadataName`	`Bytes`
None	`AssetMetadataLocalKey`	`u64`
None	`AssetMetadataSpec`	`{'url': (None, 'Bytes'), 'description': (None, 'Bytes'), 'type_def': (None, 'Bytes')}`

RemoveAssetAffirmationExemption¶

An asset has been removed from the list of pre aprroved receivement (valid for all identities). Parameters: [Ticker] of the asset.

Attributes¶

Name	Type	Composition
None	`Ticker`	`[u8; 12]`

RemovePreApprovedAsset¶

An identity has removed an asset to the list of pre aprroved receivement. Parameters: [IdentityId] of caller, [Ticker] of the asset.

Attributes¶

Name	Type	Composition
None	`IdentityId`	`[u8; 32]`
None	`Ticker`	`[u8; 12]`

SetAssetMetadataValue¶

Set asset metadata value. (Caller DID, ticker, metadata value, optional value details)

Attributes¶

Name	Type	Composition
None	`IdentityId`	`[u8; 32]`
None	`Ticker`	`[u8; 12]`
None	`AssetMetadataValue`	`Bytes`
None	`Option<AssetMetadataValueDetail<Moment>>`	`(None, {'expire': (None, 'u64'), 'lock_status': {'Unlocked': None, 'Locked': None, 'LockedUntil': 'u64'}})`

SetAssetMetadataValueDetails¶

Set asset metadata value details (expire, lock status). (Caller DID, ticker, value details)

Attributes¶

Name	Type	Composition
None	`IdentityId`	`[u8; 32]`
None	`Ticker`	`[u8; 12]`
None	`AssetMetadataValueDetail<Moment>`	`{'expire': (None, 'u64'), 'lock_status': {'Unlocked': None, 'Locked': None, 'LockedUntil': 'u64'}}`

TickerRegistered¶

Emit when ticker is registered. caller DID / ticker owner did, ticker, ticker owner, expiry

Attributes¶

Name	Type	Composition
None	`IdentityId`	`[u8; 32]`
None	`Ticker`	`[u8; 12]`
None	`Option<Moment>`	`(None, 'u64')`

TickerTransferred¶

Emit when ticker is transferred. caller DID / ticker transferred to DID, ticker, from

Attributes¶

Name	Type	Composition
None	`IdentityId`	`[u8; 32]`
None	`Ticker`	`[u8; 12]`
None	`IdentityId`	`[u8; 32]`

TransferWithData¶

An additional event to Transfer; emitted when transfer_with_data is called. caller DID , ticker, from DID, to DID, value, data

Attributes¶

Name	Type	Composition
None	`IdentityId`	`[u8; 32]`
None	`Ticker`	`[u8; 12]`
None	`IdentityId`	`[u8; 32]`
None	`IdentityId`	`[u8; 32]`
None	`Balance`	`u128`
None	`Vec<u8>`	`Bytes`

Storage functions¶

AssetDocuments¶

Documents attached to an Asset (ticker, doc_id) -> document

Python¶

result = substrate.query(
    'Asset', 'AssetDocuments', ['[u8; 12]', 'u32']
)

Return value¶

{
    'content_hash': {
        'H128': '[u8; 16]',
        'H160': '[u8; 20]',
        'H192': '[u8; 24]',
        'H224': '[u8; 28]',
        'H256': '[u8; 32]',
        'H320': '[u8; 40]',
        'H384': '[u8; 48]',
        'H512': '[u8; 64]',
        'None': None,
    },
    'doc_type': (None, 'Bytes'),
    'filing_date': (None, 'u64'),
    'name': 'Bytes',
    'uri': 'Bytes',
}

AssetDocumentsIdSequence¶

Per-ticker document ID counter. (ticker) -> doc_id

Python¶

result = substrate.query(
    'Asset', 'AssetDocumentsIdSequence', ['[u8; 12]']
)

Return value¶

'u32'

AssetMetadataGlobalKeyToName¶

Asset Metadata Global Key -> Name.

Python¶

result = substrate.query(
    'Asset', 'AssetMetadataGlobalKeyToName', ['u64']
)

Return value¶

'Bytes'

AssetMetadataGlobalNameToKey¶

Asset Metadata Global Name -> Key.

Python¶

result = substrate.query(
    'Asset', 'AssetMetadataGlobalNameToKey', ['Bytes']
)

Return value¶

'u64'

AssetMetadataGlobalSpecs¶

Asset Metadata Global Key specs.

Python¶

result = substrate.query(
    'Asset', 'AssetMetadataGlobalSpecs', ['u64']
)

Return value¶

{
    'description': (None, 'Bytes'),
    'type_def': (None, 'Bytes'),
    'url': (None, 'Bytes'),
}

AssetMetadataLocalKeyToName¶

Asset Metadata Local Key -> Name.

Python¶

result = substrate.query(
    'Asset', 'AssetMetadataLocalKeyToName', ['[u8; 12]', 'u64']
)

Return value¶

'Bytes'

AssetMetadataLocalNameToKey¶

Asset Metadata Local Name -> Key.

Python¶

result = substrate.query(
    'Asset', 'AssetMetadataLocalNameToKey', ['[u8; 12]', 'Bytes']
)

Return value¶

'u64'

AssetMetadataLocalSpecs¶

Asset Metadata Local Key specs.

Python¶

result = substrate.query(
    'Asset', 'AssetMetadataLocalSpecs', ['[u8; 12]', 'u64']
)

Return value¶

{
    'description': (None, 'Bytes'),
    'type_def': (None, 'Bytes'),
    'url': (None, 'Bytes'),
}

AssetMetadataNextGlobalKey¶

Next Asset Metadata Global Key.

Python¶

result = substrate.query(
    'Asset', 'AssetMetadataNextGlobalKey', []
)

Return value¶

'u64'

AssetMetadataNextLocalKey¶

Next Asset Metadata Local Key.

Python¶

result = substrate.query(
    'Asset', 'AssetMetadataNextLocalKey', ['[u8; 12]']
)

Return value¶

'u64'

AssetMetadataValueDetails¶

Details for an asset's Metadata values.

Python¶

result = substrate.query(
    'Asset', 'AssetMetadataValueDetails', [
    '[u8; 12]',
    {'Global': 'u64', 'Local': 'u64'},
]
)

Return value¶

{
    'expire': (None, 'u64'),
    'lock_status': {'Locked': None, 'LockedUntil': 'u64', 'Unlocked': None},
}

AssetMetadataValues¶

Metatdata values for an asset.

Python¶

result = substrate.query(
    'Asset', 'AssetMetadataValues', [
    '[u8; 12]',
    {'Global': 'u64', 'Local': 'u64'},
]
)

Return value¶

'Bytes'

AssetNames¶

Asset name of the token corresponding to the token ticker. (ticker) -> AssetName

Python¶

result = substrate.query(
    'Asset', 'AssetNames', ['[u8; 12]']
)

Return value¶

'Bytes'

AssetOwnershipRelations¶

Tickers and token owned by a user (user, ticker) -> AssetOwnership

Python¶

result = substrate.query(
    'Asset', 'AssetOwnershipRelations', ['[u8; 32]', '[u8; 12]']
)

Return value¶

('NotOwned', 'TickerOwned', 'AssetOwned')

BalanceOf¶

The total asset ticker balance per identity. (ticker, DID) -> Balance

Python¶

result = substrate.query(
    'Asset', 'BalanceOf', ['[u8; 12]', '[u8; 32]']
)

Return value¶

'u128'

CurrentAssetMetadataGlobalKey¶

The last [AssetMetadataGlobalKey] used for a global key.

Python¶

result = substrate.query(
    'Asset', 'CurrentAssetMetadataGlobalKey', []
)

Return value¶

'u64'

CurrentAssetMetadataLocalKey¶

The last [AssetMetadataLocalKey] used for [Ticker].

Python¶

result = substrate.query(
    'Asset', 'CurrentAssetMetadataLocalKey', ['[u8; 12]']
)

Return value¶

'u64'

CustomTypeIdSequence¶

The next AssetType::Custom ID in the sequence.

Numbers in the sequence start from 1 rather than 0.

Python¶

result = substrate.query(
    'Asset', 'CustomTypeIdSequence', []
)

Return value¶

'u32'

CustomTypes¶

Maps custom asset type ids to the registered string contents.

Python¶

result = substrate.query(
    'Asset', 'CustomTypes', ['u32']
)

Return value¶

'Bytes'

CustomTypesInverse¶

Inverse map of CustomTypes, from registered string contents to custom asset type ids.

Python¶

result = substrate.query(
    'Asset', 'CustomTypesInverse', ['Bytes']
)

Return value¶

'u32'

Frozen¶

The set of frozen assets implemented as a membership map. ticker -> bool

Python¶

result = substrate.query(
    'Asset', 'Frozen', ['[u8; 12]']
)

Return value¶

'bool'

FundingRound¶

The name of the current funding round. ticker -> funding round

Python¶

result = substrate.query(
    'Asset', 'FundingRound', ['[u8; 12]']
)

Return value¶

'Bytes'

Identifiers¶

A map of a ticker name and asset identifiers.

Python¶

result = substrate.query(
    'Asset', 'Identifiers', ['[u8; 12]']
)

Return value¶

[
    {
        'CINS': '[u8; 9]',
        'CUSIP': '[u8; 9]',
        'FIGI': '[u8; 12]',
        'ISIN': '[u8; 12]',
        'LEI': '[u8; 20]',
    },
]

IssuedInFundingRound¶

The total balances of tokens issued in all recorded funding rounds. (ticker, funding round) -> balance

Python¶

result = substrate.query(
    'Asset', 'IssuedInFundingRound', [('[u8; 12]', 'Bytes')]
)

Return value¶

'u128'

MandatoryMediators¶

The list of mandatory mediators for every ticker.

Python¶

result = substrate.query(
    'Asset', 'MandatoryMediators', ['[u8; 12]']
)

Return value¶

'scale_info::163'

PreApprovedTicker¶

All tickers that don't need an affirmation to be received by an identity.

Python¶

result = substrate.query(
    'Asset', 'PreApprovedTicker', ['[u8; 32]', '[u8; 12]']
)

Return value¶

'bool'

StorageVersion¶

Storage version.

Python¶

result = substrate.query(
    'Asset', 'StorageVersion', []
)

Return value¶

'u8'

TickerConfig¶

Ticker registration config. (ticker) -> TickerRegistrationConfig

Python¶

result = substrate.query(
    'Asset', 'TickerConfig', []
)

Return value¶

{'max_ticker_length': 'u8', 'registration_length': (None, 'u64')}

Tickers¶

Ticker registration details. (ticker) -> TickerRegistration

Python¶

result = substrate.query(
    'Asset', 'Tickers', ['[u8; 12]']
)

Return value¶

{'expiry': (None, 'u64'), 'owner': '[u8; 32]'}

TickersExemptFromAffirmation¶

A list of tickers that exempt all users from affirming the receivement of the asset.

Python¶

result = substrate.query(
    'Asset', 'TickersExemptFromAffirmation', ['[u8; 12]']
)

Return value¶

'bool'

Tokens¶

Details of the token corresponding to the token ticker. (ticker) -> SecurityToken details [returns SecurityToken struct]

Python¶

result = substrate.query(
    'Asset', 'Tokens', ['[u8; 12]']
)

Return value¶

{
    'asset_type': {
        'Commodity': None,
        'Custom': 'u32',
        'Derivative': None,
        'EquityCommon': None,
        'EquityPreferred': None,
        'FixedIncome': None,
        'Fund': None,
        'NonFungible': {
            'Custom': 'u32',
            'Derivative': None,
            'FixedIncome': None,
            'Invoice': None,
        },
        'REIT': None,
        'RevenueShareAgreement': None,
        'StableCoin': None,
        'StructuredProduct': None,
    },
    'divisible': 'bool',
    'owner_did': '[u8; 32]',
    'total_supply': 'u128',
}

Constants¶

AssetMetadataNameMaxLength¶

Value¶

Python¶

constant = substrate.get_constant('Asset', 'AssetMetadataNameMaxLength')

AssetMetadataTypeDefMaxLength¶

Value¶

Python¶

constant = substrate.get_constant('Asset', 'AssetMetadataTypeDefMaxLength')

AssetMetadataValueMaxLength¶

Value¶

Python¶

constant = substrate.get_constant('Asset', 'AssetMetadataValueMaxLength')

AssetNameMaxLength¶

Value¶

Python¶

constant = substrate.get_constant('Asset', 'AssetNameMaxLength')

FundingRoundNameMaxLength¶

Value¶

Python¶

constant = substrate.get_constant('Asset', 'FundingRoundNameMaxLength')

MaxAssetMediators¶

Value¶

Python¶

constant = substrate.get_constant('Asset', 'MaxAssetMediators')

Errors¶

AlreadyFrozen¶

The token is already frozen.

AssetAlreadyCreated¶

The token has already been created.

AssetAlreadyDivisible¶

The token is already divisible.

AssetMetadataGlobalKeyAlreadyExists¶

Asset Metadata Global type already exists.

AssetMetadataKeyBelongsToNFTCollection¶

Attempt to delete a key that is needed for an NFT collection.

AssetMetadataKeyIsMissing¶

Asset Metadata key is missing.

AssetMetadataLocalKeyAlreadyExists¶

Asset Metadata Local type already exists for asset.

AssetMetadataNameMaxLengthExceeded¶

Maximum length of the asset metadata type name has been exceeded.

AssetMetadataTypeDefMaxLengthExceeded¶

Maximum length of the asset metadata type definition has been exceeded.

AssetMetadataValueIsEmpty¶

Attempt to lock a metadata value that is empty.

AssetMetadataValueIsLocked¶

Asset Metadata value is locked.

AssetMetadataValueMaxLengthExceeded¶

Maximum length of the asset metadata value has been exceeded.

BalanceOverflow¶

An overflow while calculating the balance.

FundingRoundNameMaxLengthExceeded¶

Maximum length of the funding round name has been exceeded.

IncompatibleAssetTypeUpdate¶

Attempt to update the type of a non fungible token to a fungible token or the other way around.

InsufficientBalance¶

The sender balance is not sufficient.

InvalidAssetIdentifier¶

Some AssetIdentifier was invalid.

InvalidCustomAssetTypeId¶

Invalid CustomAssetTypeId.

InvalidEthereumSignature¶

An invalid Ethereum EcdsaSignature.

InvalidGranularity¶

An invalid granularity.

InvalidTickerCharacter¶

Invalid ticker character - valid set: A..Z0..9_-./`.

InvalidTransfer¶

Transfer validation check failed.

InvalidTransferComplianceFailure¶

Failed to transfer an NFT - compliance failed.

InvalidTransferFrozenAsset¶

Failed to transfer the asset - asset is frozen.

InvalidTransferInvalidReceiverCDD¶

Failed to transfer the asset - receiver cdd is not valid.

InvalidTransferInvalidSenderCDD¶

Failed to transfer the asset - sender cdd is not valid.

InvestorUniquenessClaimNotAllowed¶

Investor Uniqueness claims are not allowed for this asset.

MaxLengthOfAssetNameExceeded¶

Maximum length of asset name has been exceeded.

NoSuchAsset¶

No such token.

NoSuchDoc¶

The given Document does not exist.

NotAnOwner¶

Not an owner of the token on Ethereum.

NotFrozen¶

The asset must be frozen.

NumberOfAssetMediatorsExceeded¶

Number of asset mediators would exceed the maximum allowed.

SenderSameAsReceiver¶

Transfers to self are not allowed

TickerAlreadyRegistered¶

The ticker is already registered to someone else.

TickerFirstByteNotValid¶

Tickers should start with at least one valid byte.

TickerNotAlphanumeric¶

The ticker has non-alphanumeric parts.

TickerRegistrationExpired¶

Registration of ticker has expired.

TickerTooLong¶

The ticker length is over the limit.

TotalSupplyAboveLimit¶

The total supply is above the limit.

TotalSupplyOverflow¶

An overflow while calculating the total supply.

Unauthorized¶

The user is not authorized.

UnexpectedNonFungibleToken¶

Attempt to call an extrinsic that is only permitted for fungible tokens.