Skip to content

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&#x27;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&#x27;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&#x27;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&#x27;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&#x27;s default portfolio doesn&#x27;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&#x27;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&#x27;s portfolio doesn&#x27;t have enough free balance - PortfolioDoesNotExist If the portfolio doesn&#x27;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&#x27;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&#x27;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&#x27;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&#x27;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

256

Python

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

AssetMetadataTypeDefMaxLength

Value

8192

Python

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

AssetMetadataValueMaxLength

Value

8192

Python

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

AssetNameMaxLength

Value

128

Python

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

FundingRoundNameMaxLength

Value

128

Python

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

MaxAssetMediators

Value

4

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.