Polymesh Testnet Runtime Api Documentation

title: Constants

The following sections contain the module constants, also known as parameter types. These can only be changed as part of a runtime upgrade. On the api, these are exposed via api.consts.<module>.<method>.

(NOTE: These were generated from a static/snapshot view of a recent Substrate master node. Some items may not be available in older nodes, or in any customized implementations.)

asset

assetNameMaxLength: `u32`

interface: api.consts.asset.assetNameMaxLength

fundingRoundNameMaxLength: `u32`

interface: api.consts.asset.fundingRoundNameMaxLength

maxNumberOfTMExtensionForAsset: `u32`

interface: api.consts.asset.maxNumberOfTMExtensionForAsset

babe

epochDuration: `u64`

interface: api.consts.babe.epochDuration
summary: The number of slots that an epoch takes. We couple sessions to epochs, i.e. we start a new session once the new epoch begins. NOTE: Currently it is not possible to change the epoch duration after the chain has started. Attempting to do so will brick block production.

expectedBlockTime: `Moment`

interface: api.consts.babe.expectedBlockTime
summary: The expected average block time at which BABE should be creating blocks. Since BABE is probabilistic it is not trivial to figure out what the expected average block time should be based on the slot duration and the security parameter c (where 1 - c represents the probability of a slot being empty).

balances

existentialDeposit: `Balance`

interface: api.consts.balances.existentialDeposit
summary: The minimum amount required to keep an account open.

base

maxLen: `u32`

interface: api.consts.base.maxLen

complianceManager

maxConditionComplexity: `u32`

interface: api.consts.complianceManager.maxConditionComplexity

corporateAction

maxDidWhts: `u32`

interface: api.consts.corporateAction.maxDidWhts

maxTargetIds: `u32`

interface: api.consts.corporateAction.maxTargetIds

identity

initialPOLYX: `Balance`

interface: api.consts.identity.initialPOLYX

indices

deposit: `BalanceOf`

interface: api.consts.indices.deposit
summary: The deposit needed for reserving an index.

staking

bondingDuration: `EraIndex`

interface: api.consts.staking.bondingDuration
summary: Number of eras that staked funds must remain bonded for.

electionLookahead: `BlockNumber`

interface: api.consts.staking.electionLookahead
summary: The number of blocks before the end of the era from which election submissions are allowed.

Setting this to zero will disable the offchain compute and only on-chain seq-phragmen will be used.

This is bounded by being within the last session. Hence, setting it to a value more than the length of a session will be pointless.

fixedYearlyReward: `BalanceOf`

interface: api.consts.staking.fixedYearlyReward
summary: Total year rewards that gets paid during fixed reward schedule.

maxIterations: `u32`

interface: api.consts.staking.maxIterations
summary: Maximum number of balancing iterations to run in the offchain submission.

If set to 0, balance_solution will not be executed at all.

maxNominatorRewardedPerValidator: `u32`

interface: api.consts.staking.maxNominatorRewardedPerValidator
summary: The maximum number of nominators rewarded for each validator.

For each validator only the $MaxNominatorRewardedPerValidator biggest stakers can claim their reward. This used to limit the i/o cost for the nominator payout.

maxValidatorPerIdentity: `Permill`

interface: api.consts.staking.maxValidatorPerIdentity
summary: Maximum number of validators for each permissioned identity.

Max number of validators count = MaxValidatorPerIdentity * Self::validator_count().

maxVariableInflationTotalIssuance: `BalanceOf`

interface: api.consts.staking.maxVariableInflationTotalIssuance
summary: Maximum amount of T::currency::total_issuance() after that non-inflated rewards get paid.

minimumBond: `BalanceOf`

interface: api.consts.staking.minimumBond
summary: Minimum amount of POLYX that must be bonded for a new bond.

minSolutionScoreBump: `Perbill`

interface: api.consts.staking.minSolutionScoreBump
summary: The threshold of improvement that should be provided for a new solution to be accepted.

sessionsPerEra: `SessionIndex`

interface: api.consts.staking.sessionsPerEra
summary: Number of sessions per era.

slashDeferDuration: `EraIndex`

interface: api.consts.staking.slashDeferDuration
summary: Number of eras that slashes are deferred by, after computation.

This should be less than the bonding duration. Set to 0 if slashes should be applied immediately, without opportunity for intervention.

statistics

maxTransferManagersPerAsset: `u32`

interface: api.consts.statistics.maxTransferManagersPerAsset

system

blockHashCount: `BlockNumber`

interface: api.consts.system.blockHashCount
summary: Maximum number of block number to block hash mappings to keep (oldest pruned first).

blockLength: `BlockLength`

interface: api.consts.system.blockLength
summary: The maximum length of a block (in bytes).

blockWeights: `BlockWeights`

interface: api.consts.system.blockWeights
summary: Block & extrinsics weights: base values and limits.

dbWeight: `RuntimeDbWeight`

interface: api.consts.system.dbWeight
summary: The weight of runtime database operations the runtime can invoke.

ss58Prefix: `u8`

interface: api.consts.system.ss58Prefix
summary: The designated SS85 prefix of this chain.

This replaces the "ss58Format" property declared in the chain spec. Reason is that the runtime should know about the prefix in order to make use of it as an identifier of the chain.

version: `RuntimeVersion`

interface: api.consts.system.version
summary: Get the chain's current version.

timestamp

minimumPeriod: `Moment`

interface: api.consts.timestamp.minimumPeriod
summary: The minimum period between blocks. Beware that this is different to the expected period that the block production apparatus provides. Your chosen consensus system will generally work with this to determine a sensible block time. e.g. For Aura, it will be double this period on default settings.

transactionPayment

transactionByteFee: `BalanceOf`

interface: api.consts.transactionPayment.transactionByteFee
summary: The fee to be paid for making a transaction; the per-byte portion.

weightToFee: `Vec<WeightToFeeCoefficient>`

interface: api.consts.transactionPayment.weightToFee
summary: The polynomial that is applied in order to derive fee from weight.

title: Extrinsics

The following sections contain Extrinsics methods are part of the default Substrate runtime. On the api, these are exposed via api.tx.<module>.<method>.

(NOTE: These were generated from a static/snapshot view of a recent Substrate master node. Some items may not be available in older nodes, or in any customized implementations.)

asset

acceptAssetOwnershipTransfer(auth_id: `u64`)

interface: api.tx.asset.acceptAssetOwnershipTransfer
summary: 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.

acceptTickerTransfer(auth_id: `u64`)

interface: api.tx.asset.acceptTickerTransfer
summary: 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.

addDocuments(docs: `Vec<Document>`, ticker: `Ticker`)

interface: api.tx.asset.addDocuments
summary: 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

claimClassicTicker(ticker: `Ticker`, ethereum_signature: `EcdsaSignature`)

interface: api.tx.asset.claimClassicTicker
summary: Claim a systematically reserved Polymath Classic (PMC) ticker and transfer it to the origin's identity.

To verify that the origin is in control of the Ethereum account on the books, an ethereum_signature containing the origin's DID as the message must be provided by that Ethereum account.

Errors
- NoSuchClassicTicker if this is not a systematically reserved PMC ticker.
- TickerAlreadyRegistered if the ticker was already registered, e.g., by origin.
- TickerRegistrationExpired if the ticker's registration has expired.
- BadOrigin if not signed.
- InvalidEthereumSignature if the ethereum_signature is not valid.
- NotAnOwner if the ethereum account is not the owner of the PMC ticker.

controllerTransfer(ticker: `Ticker`, value: `Balance`, from_portfolio: `PortfolioId`)

interface: api.tx.asset.controllerTransfer
summary: 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.

createAsset(name: `AssetName`, ticker: `Ticker`, divisible: `bool`, asset_type: `AssetType`, identifiers: `Vec<AssetIdentifier>`, funding_round: `Option<FundingRoundName>`, disable_iu: `bool`)

interface: api.tx.asset.createAsset
summary: 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.
- disable_iu - whether or not investor uniqueness enforcement should be disabled. This cannot be changed after creating the asset.
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.
- TickerNotAscii if ticker is not yet registered, and contains non-ascii printable characters (from code 32 to 126) or any character after first occurrence of \0.
Permissions
- Portfolio

freeze(ticker: `Ticker`)

interface: api.tx.asset.freeze
summary: Freezes transfers and minting 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

issue(ticker: `Ticker`, amount: `Balance`)

interface: api.tx.asset.issue
summary: Issue, or mint, new tokens to the caller, which must be an authorized external agent.

Arguments
- origin is a signer that has permissions to act as an agent of ticker.
- ticker of the token.
- amount of tokens that get issued.
Permissions
- Asset
- Portfolio

makeDivisible(ticker: `Ticker`)

interface: api.tx.asset.makeDivisible
summary: 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

redeem(ticker: `Ticker`, value: `Balance`)

interface: api.tx.asset.redeem
summary: 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

registerCustomAssetType(ty: `Bytes`)

interface: api.tx.asset.registerCustomAssetType
summary: 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.

registerTicker(ticker: `Ticker`)

interface: api.tx.asset.registerTicker
summary: 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

removeDocuments(ids: `Vec<DocumentId>`, ticker: `Ticker`)

interface: api.tx.asset.removeDocuments
summary: 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

renameAsset(ticker: `Ticker`, name: `AssetName`)

interface: api.tx.asset.renameAsset
summary: 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

reserveClassicTicker(classic_ticker_import: `ClassicTickerImport`, contract_did: `IdentityId`, config: `TickerRegistrationConfig`)

interface: api.tx.asset.reserveClassicTicker
summary: Reserve a Polymath Classic (PMC) ticker. Must be called by root, and assigns the ticker to a systematic DID.

Arguments
- origin which must be root.
- classic_ticker_import specification for the PMC ticker.
- contract_did to reserve the ticker to if classic_ticker_import.is_contract holds.
- config to use for expiry and ticker length.
Errors
- AssetAlreadyCreated if classic_ticker_import.ticker was created as an asset.
- TickerTooLong if the config considers the classic_ticker_import.ticker too long.
- TickerAlreadyRegistered if classic_ticker_import.ticker was already registered.

setFundingRound(ticker: `Ticker`, name: `FundingRoundName`)

interface: api.tx.asset.setFundingRound
summary: 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

unfreeze(ticker: `Ticker`)

interface: api.tx.asset.unfreeze
summary: Unfreezes transfers and minting 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

updateIdentifiers(ticker: `Ticker`, identifiers: `Vec<AssetIdentifier>`)

interface: api.tx.asset.updateIdentifiers
summary: Updates the asset identifiers.

Arguments
- origin - a signer that has permissions to act as an agent of ticker.
- ticker - the ticker of the token.
- 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

authorityDiscovery

authorship

setUncles(new_uncles: `Vec<Header>`)

interface: api.tx.authorship.setUncles
summary: Provide a set of uncles.

babe

reportEquivocation(equivocation_proof: `BabeEquivocationProof`, key_owner_proof: `KeyOwnerProof`)

interface: api.tx.babe.reportEquivocation
summary: Report authority equivocation/misbehavior. This method will verify the equivocation proof and validate the given key ownership proof against the extracted offender. If both are valid, the offence will be reported.

reportEquivocationUnsigned(equivocation_proof: `BabeEquivocationProof`, key_owner_proof: `KeyOwnerProof`)

interface: api.tx.babe.reportEquivocationUnsigned
summary: Report authority equivocation/misbehavior. This method will verify the equivocation proof and validate the given key ownership proof against the extracted offender. If both are valid, the offence will be reported. This extrinsic must be called unsigned and it is expected that only block authors will call it (validated in ValidateUnsigned), as such if the block author is defined it will be defined as the equivocation reporter.

balances

burnAccountBalance(amount: `Balance`)

interface: api.tx.balances.burnAccountBalance
summary: Burns the given amount of tokens from the caller's free, unlocked balance.

depositBlockRewardReserveBalance(value: `Compact<Balance>`)

interface: api.tx.balances.depositBlockRewardReserveBalance
summary: Move some POLYX from balance of self to balance of BRR.

forceTransfer(source: `LookupSource`, dest: `LookupSource`, value: `Compact<Balance>`)

interface: api.tx.balances.forceTransfer
summary: Exactly as transfer, except the origin must be root and the source account may be specified.

setBalance(who: `LookupSource`, new_free: `Compact<Balance>`, new_reserved: `Compact<Balance>`)

interface: api.tx.balances.setBalance
summary: Set the balances of a given account.

This will alter FreeBalance and ReservedBalance in storage. it will also decrease the total issuance of the system (TotalIssuance).

The dispatch origin for this call is root.

transfer(dest: `LookupSource`, value: `Compact<Balance>`)

interface: api.tx.balances.transfer
summary: Transfer some liquid free balance to another account.

transfer will set the FreeBalance of the sender and receiver. It will decrease the total issuance of the system by the TransferFee.

The dispatch origin for this call must be Signed by the transactor.

transferWithMemo(dest: `LookupSource`, value: `Compact<Balance>`, memo: `Option<Memo>`)

interface: api.tx.balances.transferWithMemo
summary: Transfer the native currency with the help of identifier string this functionality can help to differentiate the transfers.

base

bridge

addFreezeAdmin(freeze_admin: `AccountId`)

interface: api.tx.bridge.addFreezeAdmin
summary: Add a freeze admin.

Errors
- BadAdmin if origin is not Self::admin() account.

batchProposeBridgeTx(bridge_txs: `Vec<BridgeTx>`)

interface: api.tx.bridge.batchProposeBridgeTx
summary: Proposes a vector of bridge transactions. The vector is processed until the first proposal which causes an error, in which case the error is returned and the rest of proposals are not processed.

Errors
- ControllerNotSet if Controllers was not set.
Weight 500_000_000 + 7_000_000 * bridge_txs.len()

changeAdmin(admin: `AccountId`)

interface: api.tx.bridge.changeAdmin
summary: Changes the bridge admin key.

Errors
- BadAdmin if origin is not Self::admin() account.

changeBridgeExempted(exempted: `Vec<(IdentityId,bool)>`)

interface: api.tx.bridge.changeBridgeExempted
summary: Changes the bridge limit exempted list.

Errors
- BadAdmin if origin is not Self::admin() account.

changeBridgeLimit(amount: `Balance`, duration: `BlockNumber`)

interface: api.tx.bridge.changeBridgeLimit
summary: Changes the bridge limits.

Errors
- BadAdmin if origin is not Self::admin() account.
- DivisionByZero if duration is zero.

changeController(controller: `AccountId`)

interface: api.tx.bridge.changeController
summary: Changes the controller account as admin.

Errors
- BadAdmin if origin is not Self::admin() account.

changeTimelock(timelock: `BlockNumber`)

interface: api.tx.bridge.changeTimelock
summary: Changes the timelock period.

Errors
- BadAdmin if origin is not Self::admin() account.

forceHandleBridgeTx(bridge_tx: `BridgeTx`)

interface: api.tx.bridge.forceHandleBridgeTx
summary: Forces handling a transaction by bypassing the bridge limit and timelock.

Errors
- BadAdmin if origin is not Self::admin() account.
- NoValidCdd if bridge_tx.recipient does not have a valid CDD claim.

freeze()

interface: api.tx.bridge.freeze
summary: Freezes transaction handling in the bridge module if it is not already frozen. When the bridge is frozen, attempted transactions get postponed instead of getting handled.

Errors
- BadAdmin if origin is not Self::admin() account.

freezeTxs(bridge_txs: `Vec<BridgeTx>`)

interface: api.tx.bridge.freezeTxs
summary: Freezes given bridge transactions. If any bridge txn is already handled then this function will just ignore it and process next one.

Errors
- BadAdmin if origin is not Self::admin() account.
Weight 400_000_000 + 2_000_000 * bridge_txs.len()

handleBridgeTx(bridge_tx: `BridgeTx`)

interface: api.tx.bridge.handleBridgeTx
summary: Handles an approved bridge transaction proposal.

Errors
- BadCaller if origin is not Self::controller or Self::admin.
- TimelockedTx if the transaction status is Timelocked.
- ProposalAlreadyHandled if the transaction status is Handled.

handleScheduledBridgeTx(bridge_tx: `BridgeTx`)

interface: api.tx.bridge.handleScheduledBridgeTx
summary: Root callable extrinsic, used as an internal call to handle a scheduled timelocked bridge transaction.

Errors
- BadOrigin if origin is not root.
- ProposalAlreadyHandled if transaction status is Handled.
- FrozenTx if transaction status is Frozen.

proposeBridgeTx(bridge_tx: `BridgeTx`)

interface: api.tx.bridge.proposeBridgeTx
summary: Proposes a bridge transaction, which amounts to making a multisig proposal for the bridge transaction if the transaction is new or approving an existing proposal if the transaction has already been proposed.

Errors
- ControllerNotSet if Controllers was not set.

removeFreezeAdmin(freeze_admin: `AccountId`)

interface: api.tx.bridge.removeFreezeAdmin
summary: Remove a freeze admin.

Errors
- BadAdmin if origin is not Self::admin() account.

removeTxs(bridge_txs: `Vec<BridgeTx>`)

interface: api.tx.bridge.removeTxs
summary: Remove given bridge transactions.

Errors
- BadAdmin if origin is not Self::admin() account.
- NotFrozen if a tx in bridge_txs is not frozen.

unfreeze()

interface: api.tx.bridge.unfreeze
summary: Unfreezes transaction handling in the bridge module if it is frozen.

Errors
- BadAdmin if origin is not Self::admin() account.

unfreezeTxs(bridge_txs: `Vec<BridgeTx>`)

interface: api.tx.bridge.unfreezeTxs
summary: Unfreezes given bridge transactions. If any bridge txn is already handled then this function will just ignore it and process next one.

Errors
- BadAdmin if origin is not Self::admin() account.
Weight 400_000_000 + 7_000_000 * bridge_txs.len()

capitalDistribution

claim(ca_id: `CAId`)

interface: api.tx.capitalDistribution.claim
summary: Claim a benefit of the capital distribution attached to ca_id.

Taxes are withheld as specified by the CA. Post-tax earnings are then transferred to the default portfolio of the origin's DID.

All benefits are rounded by truncation, down to first integer below. Moreover, before post-tax earnings, in indivisible currencies are transferred, they are rounded down to a whole unit.

Arguments
- origin which must be a holder of the asset and eligible for the distribution.
- ca_id identifies the CA to start a capital distribution for.
Errors
- HolderAlreadyPaid if origin's DID has already received its benefit.
- NoSuchDistribution if there's no capital distribution for ca_id.
- CannotClaimBeforeStart if now < payment_at.
- CannotClaimAfterExpiry if now > expiry_at.unwrap().
- NoSuchCA if ca_id does not identify an existing CA.
- NotTargetedByCA if the CA does not target origin's DID.
- BalanceAmountProductOverflowed if ba = balance * amount would overflow.
- BalanceAmountProductSupplyDivisionFailed if ba * supply would overflow.
- Other errors can occur if the compliance manager rejects the transfer.

distribute(ca_id: `CAId`, portfolio: `Option<PortfolioNumber>`, currency: `Ticker`, per_share: `Balance`, amount: `Balance`, payment_at: `Moment`, expires_at: `Option<Moment>`)

interface: api.tx.capitalDistribution.distribute
summary: Start and attach a capital distribution, to the CA identified by ca_id, with amount funds in currency withdrawn from portfolio belonging to origin's DID.

The distribution will commence at payment_at and expire at expires_at, if provided, or if None, then there's no expiry.

The funds will be locked in portfolio from when distribute is called. When there's no expiry, some funds may be locked indefinitely in portfolio, due to claimants not withdrawing or no benefits being pushed to them. For indivisible currencies, unlocked amounts, of less than one whole unit, will not be transferable from portfolio. However, if we imagine that users Alice and Bob both are entitled to 1.5 units, and only receive 1 units each, then 0.5 + 0.5 = 1 units are left in portfolio, which is now transferrable.

Arguments
- origin is a signer that has permissions to act as an agent of ca_id.ticker.
- ca_id identifies the CA to start a capital distribution for.
- portfolio specifies the portfolio number of the agent to distribute amount from.
- currency to withdraw and distribute from the portfolio.
- per_share amount of currency to withdraw and distribute. Specified as a per-million, i.e. 1 / 10^6th of one currency token.
- amount of currency to withdraw and distribute at most.
- payment_at specifies when benefits may first be pushed or claimed.
- expires_at specifies, if provided, when remaining benefits are forfeit and may be reclaimed by origin.
Errors
- UnauthorizedAgent if origin is not agent-permissioned for ticker.
- DistributingAsset if ca_id.ticker == currency.
- ExpiryBeforePayment if expires_at.unwrap() <= payment_at.
- NoSuchCA if ca_id does not identify an existing CA.
- NoRecordDate if CA has no record date.
- RecordDateAfterStart if CA's record date > payment_at.
- UnauthorizedCustodian if the caller is not the custodian of portfolio.
- InsufficientPortfolioBalance if portfolio has less than amount of currency.
- InsufficientBalance if the protocol fee couldn't be charged.
- CANotBenefit if the CA is not of kind PredictableBenefit/UnpredictableBenefit
Permissions
- Asset
- Portfolio

pushBenefit(ca_id: `CAId`, holder: `IdentityId`)

interface: api.tx.capitalDistribution.pushBenefit
summary: Push benefit of an ongoing distribution to the given holder.

Taxes are withheld as specified by the CA. Post-tax earnings are then transferred to the default portfolio of the origin's DID.

All benefits are rounded by truncation, down to first integer below. Moreover, before post-tax earnings, in indivisible currencies are transferred, they are rounded down to a whole unit.

Arguments
- origin is a signer that has permissions to act as an agent of ca_id.ticker.
- ca_id identifies the CA with a capital distributions to push benefits for.
- holder to push benefits to.
Errors
- UnauthorizedAgent if origin is not agent-permissioned for ticker.
- NoSuchDistribution if there's no capital distribution for ca_id.
- CannotClaimBeforeStart if now < payment_at.
- CannotClaimAfterExpiry if now > expiry_at.unwrap().
- NoSuchCA if ca_id does not identify an existing CA.
- NotTargetedByCA if the CA does not target holder.
- BalanceAmountProductOverflowed if ba = balance * amount would overflow.
- BalanceAmountProductSupplyDivisionFailed if ba * supply would overflow.
- Other errors can occur if the compliance manager rejects the transfer.

reclaim(ca_id: `CAId`)

interface: api.tx.capitalDistribution.reclaim
summary: Assuming a distribution has expired, unlock the remaining amount in the distributor portfolio.

Arguments
- origin which must be the creator of the capital distribution tied to ca_id.
- ca_id identifies the CA with a capital distribution to reclaim for.
Errors
- NoSuchDistribution if there's no capital distribution for ca_id.
- AlreadyReclaimed if this function has already been called successfully.
- NotExpired if now < expiry.

removeDistribution(ca_id: `CAId`)

interface: api.tx.capitalDistribution.removeDistribution
summary: Removes a distribution that hasn't started yet, unlocking the full amount in the distributor portfolio.

Arguments
- origin is a signer that has permissions to act as an agent of ca_id.ticker.
- ca_id identifies the CA with a not-yet-started capital distribution to remove.
Errors
- UnauthorizedAgent if origin is not agent-permissioned for ticker.
- NoSuchDistribution if there's no capital distribution for ca_id.
- DistributionStarted if payment_at <= now.

cddServiceProviders

abdicateMembership()

interface: api.tx.cddServiceProviders.abdicateMembership
summary: Allows the calling member to unilaterally quit without this being subject to a GC vote.

Arguments
- origin - Member of committee who wants to quit.
Error
- Only primary key can abdicate.
- Last member of a group cannot abdicate.

addMember(who: `IdentityId`)

interface: api.tx.cddServiceProviders.addMember
summary: Adds a member who to the group. May only be called from AddOrigin or root.

Arguments
- origin - Origin representing AddOrigin or root
- who - IdentityId to be added to the group.

disableMember(who: `IdentityId`, expiry: `Option<Moment>`, at: `Option<Moment>`)

interface: api.tx.cddServiceProviders.disableMember
summary: Disables a member at specific moment.

Please note that if member is already revoked (a "valid member"), its revocation time-stamp will be updated.

Any disabled member should NOT allow to act like an active member of the group. For instance, a disabled CDD member should NOT be able to generate a CDD claim. However any generated claim issued before at would be considered as a valid one.

If you want to invalidate any generated claim, you should use Self::remove_member.

Arguments
- at - Revocation time-stamp.
- who - Target member of the group.
- expiry - Time-stamp when who is removed from CDD. As soon as it is expired, the generated claims will be "invalid" as who is not considered a member of the group.

removeMember(who: `IdentityId`)

interface: api.tx.cddServiceProviders.removeMember
summary: Removes a member who from the set. May only be called from RemoveOrigin or root.

Any claim previously generated by this member is not valid as a group claim. For instance, if a CDD member group generated a claim for a target identity and then it is removed, that claim will be invalid. In case you want to keep the validity of generated claims, you have to use Self::disable_member function

Arguments
- origin - Origin representing RemoveOrigin or root
- who - IdentityId to be removed from the group.

resetMembers(members: `Vec<IdentityId>`)

interface: api.tx.cddServiceProviders.resetMembers
summary: Changes the membership to a new set, disregarding the existing membership. May only be called from ResetOrigin or root.

Arguments
- origin - Origin representing ResetOrigin or root
- members - New set of identities

setActiveMembersLimit(limit: `MemberCount`)

interface: api.tx.cddServiceProviders.setActiveMembersLimit
summary: Change this group's limit for how many concurrent active members they may be.

Arguments
- limit - the number of active members there may be concurrently.

swapMember(remove: `IdentityId`, add: `IdentityId`)

interface: api.tx.cddServiceProviders.swapMember
summary: Swaps out one member remove for another member add.

May only be called from SwapOrigin or root.

Arguments
- origin - Origin representing SwapOrigin or root
- remove - IdentityId to be removed from the group.
- add - IdentityId to be added in place of remove.

checkpoint

createCheckpoint(ticker: `Ticker`)

interface: api.tx.checkpoint.createCheckpoint
summary: Creates a single checkpoint at the current time.

Arguments
- origin is a signer that has permissions to act as an agent of ticker.
- ticker to create the checkpoint for.
Errors
- UnauthorizedAgent if the DID of origin isn't a permissioned agent for ticker.
- CounterOverflow if the total checkpoint counter would overflow.

createSchedule(ticker: `Ticker`, schedule: `ScheduleSpec`)

interface: api.tx.checkpoint.createSchedule
summary: Creates a schedule generating checkpoints in the future at either a fixed time or at intervals.

The schedule starts out with strong_ref_count(schedule_id) <- 0.

Arguments
- origin is a signer that has permissions to act as owner of ticker.
- ticker to create the schedule for.
- schedule that will generate checkpoints.
Errors
- UnauthorizedAgent if the DID of origin isn't a permissioned agent for ticker.
- ScheduleDurationTooShort if the schedule duration is too short.
- InsufficientAccountBalance if the protocol fee could not be charged.
- CounterOverflow if the schedule ID or total checkpoint counters would overflow.
- FailedToComputeNextCheckpoint if the next checkpoint for schedule is in the past.
Permissions
- Asset

removeSchedule(ticker: `Ticker`, id: `ScheduleId`)

interface: api.tx.checkpoint.removeSchedule
summary: Removes the checkpoint schedule of an asset identified by id.

Arguments
- origin is a signer that has permissions to act as owner of ticker.
- ticker to remove the schedule from.
- id of the schedule, when it was created by created_schedule.
Errors
- UnauthorizedAgent if the DID of origin isn't a permissioned agent for ticker.
- NoCheckpointSchedule if id does not identify a schedule for this ticker.
- ScheduleNotRemovable if id exists but is not removable.
Permissions
- Asset

setSchedulesMaxComplexity(max_complexity: `u64`)

interface: api.tx.checkpoint.setSchedulesMaxComplexity
summary: Sets the max complexity of a schedule set for an arbitrary ticker to max_complexity. The new maximum is not enforced retroactively, and only applies once new schedules are made.

Must be called as a PIP (requires "root").

Arguments
- origin is the root origin.
- max_complexity allowed for an arbitrary ticker's schedule set.

committeeMembership

abdicateMembership()

interface: api.tx.committeeMembership.abdicateMembership
summary: Allows the calling member to unilaterally quit without this being subject to a GC vote.

Arguments
- origin - Member of committee who wants to quit.
Error
- Only primary key can abdicate.
- Last member of a group cannot abdicate.

addMember(who: `IdentityId`)

interface: api.tx.committeeMembership.addMember
summary: Adds a member who to the group. May only be called from AddOrigin or root.

Arguments
- origin - Origin representing AddOrigin or root
- who - IdentityId to be added to the group.

disableMember(who: `IdentityId`, expiry: `Option<Moment>`, at: `Option<Moment>`)

interface: api.tx.committeeMembership.disableMember
summary: Disables a member at specific moment.

Please note that if member is already revoked (a "valid member"), its revocation time-stamp will be updated.

Any disabled member should NOT allow to act like an active member of the group. For instance, a disabled CDD member should NOT be able to generate a CDD claim. However any generated claim issued before at would be considered as a valid one.

If you want to invalidate any generated claim, you should use Self::remove_member.

Arguments
- at - Revocation time-stamp.
- who - Target member of the group.
- expiry - Time-stamp when who is removed from CDD. As soon as it is expired, the generated claims will be "invalid" as who is not considered a member of the group.

removeMember(who: `IdentityId`)

interface: api.tx.committeeMembership.removeMember
summary: Removes a member who from the set. May only be called from RemoveOrigin or root.

Any claim previously generated by this member is not valid as a group claim. For instance, if a CDD member group generated a claim for a target identity and then it is removed, that claim will be invalid. In case you want to keep the validity of generated claims, you have to use Self::disable_member function

Arguments
- origin - Origin representing RemoveOrigin or root
- who - IdentityId to be removed from the group.

resetMembers(members: `Vec<IdentityId>`)

interface: api.tx.committeeMembership.resetMembers
summary: Changes the membership to a new set, disregarding the existing membership. May only be called from ResetOrigin or root.

Arguments
- origin - Origin representing ResetOrigin or root
- members - New set of identities

setActiveMembersLimit(limit: `MemberCount`)

interface: api.tx.committeeMembership.setActiveMembersLimit
summary: Change this group's limit for how many concurrent active members they may be.

Arguments
- limit - the number of active members there may be concurrently.

swapMember(remove: `IdentityId`, add: `IdentityId`)

interface: api.tx.committeeMembership.swapMember
summary: Swaps out one member remove for another member add.

May only be called from SwapOrigin or root.

Arguments
- origin - Origin representing SwapOrigin or root
- remove - IdentityId to be removed from the group.
- add - IdentityId to be added in place of remove.

complianceManager

addComplianceRequirement(ticker: `Ticker`, sender_conditions: `Vec<Condition>`, receiver_conditions: `Vec<Condition>`)

interface: api.tx.complianceManager.addComplianceRequirement
summary: Adds a compliance requirement to an asset's compliance by ticker. If the compliance requirement is a duplicate, it does nothing.

Arguments
- origin - Signer of the dispatchable. It should be the owner of the ticker
- ticker - Symbol of the asset
- sender_conditions - Sender transfer conditions.
- receiver_conditions - Receiver transfer conditions.
Permissions
- Asset

addDefaultTrustedClaimIssuer(ticker: `Ticker`, issuer: `TrustedIssuer`)

interface: api.tx.complianceManager.addDefaultTrustedClaimIssuer
summary: Adds another default trusted claim issuer at the ticker level.

Arguments
- origin - Signer of the dispatchable. It should be the owner of the ticker.
- ticker - Symbol of the asset.
- issuer - IdentityId of the trusted claim issuer.
Permissions
- Asset

changeComplianceRequirement(ticker: `Ticker`, new_req: `ComplianceRequirement`)

interface: api.tx.complianceManager.changeComplianceRequirement
summary: Modify an existing compliance requirement of a given ticker.

Arguments
- origin - Signer of the dispatchable. It should be the owner of the ticker.
- ticker - Symbol of the asset.
- new_req - Compliance requirement.
Permissions
- Asset

pauseAssetCompliance(ticker: `Ticker`)

interface: api.tx.complianceManager.pauseAssetCompliance
summary: Pauses the verification of conditions for ticker during transfers.

Arguments
- origin - Signer of the dispatchable. It should be the owner of the ticker
- ticker - Symbol of the asset
Permissions
- Asset

removeComplianceRequirement(ticker: `Ticker`, id: `u32`)

interface: api.tx.complianceManager.removeComplianceRequirement
summary: Removes a compliance requirement from an asset's compliance.

Arguments
- origin - Signer of the dispatchable. It should be the owner of the ticker
- ticker - Symbol of the asset
- id - Compliance requirement id which is need to be removed
Permissions
- Asset

removeDefaultTrustedClaimIssuer(ticker: `Ticker`, issuer: `IdentityId`)

interface: api.tx.complianceManager.removeDefaultTrustedClaimIssuer
summary: Removes the given issuer from the set of default trusted claim issuers at the ticker level.

Arguments
- origin - Signer of the dispatchable. It should be the owner of the ticker.
- ticker - Symbol of the asset.
- issuer - IdentityId of the trusted claim issuer.
Permissions
- Asset

replaceAssetCompliance(ticker: `Ticker`, asset_compliance: `Vec<ComplianceRequirement>`)

interface: api.tx.complianceManager.replaceAssetCompliance
summary: Replaces an asset's compliance by ticker with a new compliance.

Compliance requirements will be sorted (ascending by id) before replacing the current requirements.

Arguments
- ticker - the asset ticker,
- `asset_compliance - the new asset compliance.
Errors
- Unauthorized if origin is not the owner of the ticker.
- DuplicateAssetCompliance if asset_compliance contains multiple entries with the same requirement_id.
Permissions
- Asset

resetAssetCompliance(ticker: `Ticker`)

interface: api.tx.complianceManager.resetAssetCompliance
summary: Removes an asset's compliance

Arguments
- origin - Signer of the dispatchable. It should be the owner of the ticker
- ticker - Symbol of the asset
Permissions
- Asset

resumeAssetCompliance(ticker: `Ticker`)

interface: api.tx.complianceManager.resumeAssetCompliance
summary: Resumes the verification of conditions for ticker during transfers.

Arguments
- origin - Signer of the dispatchable. It should be the owner of the ticker
- ticker - Symbol of the asset
Permissions
- Asset

corporateAction

changeRecordDate(ca_id: `CAId`, record_date: `Option<RecordDateSpec>`)

interface: api.tx.corporateAction.changeRecordDate
summary: Changes the record date of the CA identified by ca_id.

Arguments
- origin which must be an external agent of ca_id.ticker with relevant permissions.
- ca_id of the CA to alter.
- record_date, if any, to calculate the impact of the CA. If provided, this results in a scheduled balance snapshot ("checkpoint") at the date.
Errors
- UnauthorizedAgent if origin is not agent-permissioned for ticker.
- NoSuchCA if id does not identify an existing CA.
- When record_date.is_some(), other errors due to checkpoint scheduling may occur.
Permissions
- Asset

initiateCorporateAction(ticker: `Ticker`, kind: `CAKind`, decl_date: `Moment`, record_date: `Option<RecordDateSpec>`, details: `CADetails`, targets: `Option<TargetIdentities>`, default_withholding_tax: `Option<Tax>`, withholding_tax: `Option<Vec<(IdentityId,Tax)>>`)

interface: api.tx.corporateAction.initiateCorporateAction
summary: Initiates a CA for ticker of kind with details and other provided arguments.

Arguments
- origin which must be an external agent of ticker with relevant permissions.
- ticker that the CA is made for.
- kind of CA being initiated.
- decl_date of CA bring initialized.
- record_date, if any, to calculate the impact of this CA. If provided, this results in a scheduled balance snapshot ("checkpoint") at the date.
- details of the CA in free-text form, up to a certain number of bytes in length.
- targets, if any, which this CA is relevant/irrelevant to. Overrides, if provided, the default at the asset level (set_default_targets).
- default_withholding_tax, if any, is the default withholding tax to use for this CA. Overrides, if provided, the default at the asset level (set_default_withholding_tax).
- withholding_tax, if any, provides per-DID withholding tax overrides. Overrides, if provided, the default at the asset level (set_did_withholding_tax).
Errors
- DetailsTooLong if details.len() goes beyond max_details_length.
- UnauthorizedAgent if origin is not agent-permissioned for ticker.
- CounterOverflow in the unlikely event that so many CAs were created for this ticker, that integer overflow would have occured if instead allowed.
- TooManyDidTaxes if withholding_tax.unwrap().len() would go over the limit MaxDidWhts.
- DuplicateDidTax if a DID is included more than once in wt.
- TooManyTargetIds if targets.unwrap().identities.len() > T::MaxTargetIds::get().
- DeclDateInFuture if the declaration date is not in the past.
- When record_date.is_some(), other errors due to checkpoint scheduling may occur.
Permissions
- Asset

linkCaDoc(id: `CAId`, docs: `Vec<DocumentId>`)

interface: api.tx.corporateAction.linkCaDoc
summary: Link the given CA id to the given docs. Any previous links for the CA are removed in favor of docs.

The workflow here is to add the documents and initiating the CA in any order desired. Once both exist, they can now be linked together.

Arguments
- origin which must be an external agent of id.ticker with relevant permissions.
- id of the CA to associate with docs.
- docs to associate with the CA with id.
Errors
- UnauthorizedAgent if origin is not agent-permissioned for ticker.
- NoSuchCA if id does not identify an existing CA.
- NoSuchDoc if any of docs does not identify an existing document.
Permissions
- Asset

removeCa(ca_id: `CAId`)

interface: api.tx.corporateAction.removeCa
summary: Removes the CA identified by ca_id.

Associated data, such as document links, ballots, and capital distributions are also removed.

Any schedule associated with the record date will see strong_ref_count(schedule_id) decremented.

Arguments
- origin which must be an external agent of ca_id.ticker with relevant permissions.
- ca_id of the CA to remove.
Errors
- UnauthorizedAgent if origin is not agent-permissioned for ticker.
- NoSuchCA if id does not identify an existing CA.
Permissions
- Asset

setDefaultTargets(ticker: `Ticker`, targets: `TargetIdentities`)

interface: api.tx.corporateAction.setDefaultTargets
summary: Set the default CA TargetIdentities to targets.

Arguments
- origin which must be an external agent of ticker with relevant permissions.
- ticker for which the default identities are changing.
- targets the default target identities for a CA.
Errors
- UnauthorizedAgent if origin is not agent-permissioned for ticker.
- TooManyTargetIds if targets.identities.len() > T::MaxTargetIds::get().
Permissions
- Asset

setDefaultWithholdingTax(ticker: `Ticker`, tax: `Tax`)

interface: api.tx.corporateAction.setDefaultWithholdingTax
summary: Set the default withholding tax for all DIDs and CAs relevant to this ticker.

Arguments
- origin which must be an external agent of ticker with relevant permissions.
- ticker that the withholding tax will apply to.
- tax that should be withheld when distributing dividends, etc.
Errors
- UnauthorizedAgent if origin is not agent-permissioned for ticker.
Permissions
- Asset

setDidWithholdingTax(ticker: `Ticker`, taxed_did: `IdentityId`, tax: `Option<Tax>`)

interface: api.tx.corporateAction.setDidWithholdingTax
summary: Set the withholding tax of ticker for taxed_did to tax. If Some(tax), this overrides the default withholding tax of ticker to tax for taxed_did. Otherwise, if None, the default withholding tax will be used.

Arguments
- origin which must be an external agent of ticker with relevant permissions.
- ticker that the withholding tax will apply to.
- taxed_did that will have its withholding tax updated.
- tax that should be withheld when distributing dividends, etc.
Errors
- UnauthorizedAgent if origin is not agent-permissioned for ticker.
- TooManyDidTaxes if Some(tax) and adding the override would go over the limit MaxDidWhts.
Permissions
- Asset

setMaxDetailsLength(length: `u32`)

interface: api.tx.corporateAction.setMaxDetailsLength
summary: Set the max length of details in terms of bytes. May only be called via a PIP.

corporateBallot

attachBallot(ca_id: `CAId`, range: `BallotTimeRange`, meta: `BallotMeta`, rcv: `bool`)

interface: api.tx.corporateBallot.attachBallot
summary: Attach a corporate ballot to the CA identified by ca_id.

The ballot will admit votes within range. The ballot's metadata is provided by meta, which includes the ballot title, the motions, their choices, etc. See the BallotMeta for more.

Arguments
- origin is a signer that has permissions to act as an agent of ca_id.ticker.
- ca_id identifies the CA to attach the ballot to.
- range specifies when voting starts and ends.
- meta specifies the ballot's metadata as aforementioned.
- rcv specifies whether RCV is enabled for this ballot.
Errors
- UnauthorizedAgent if origin is not agent-permissioned for ticker.
- NoSuchCA if ca_id does not identify an existing CA.
- CANotNotice if the CA is not of the IssuerNotice kind.
- StartAfterEnd if range.start > range.end.
- NowAfterEnd if now > range.end where now is the current timestamp.
- NoRecordDate if CA has no record date.
- RecordDateAfterStart if date > range.start where date is the CA's record date.
- AlreadyExists if there's a ballot already.
- NumberOfChoicesOverflow if the total choice in meta overflows usize.
- TooLong if any of the embedded strings in meta are too long.
- InsufficientBalance if the protocol fee couldn't be charged.

changeEnd(ca_id: `CAId`, end: `Moment`)

interface: api.tx.corporateBallot.changeEnd
summary: Amend the end date of the ballot of the CA identified by ca_id.

Arguments
- origin is a signer that has permissions to act as an agent of ca_id.ticker.
- ca_id identifies the attached ballot's CA.
- end specifies the new end date of the ballot.
Errors
- UnauthorizedAgent if origin is not agent-permissioned for ticker.
- NoSuchBallot if ca_id does not identify a ballot.
- VotingAlreadyStarted if start >= now, where now is the current time.
- StartAfterEnd if start > end.

changeMeta(ca_id: `CAId`, meta: `BallotMeta`)

interface: api.tx.corporateBallot.changeMeta
summary: Amend the metadata (title, motions, etc.) of the ballot of the CA identified by ca_id.

Arguments
- origin is a signer that has permissions to act as an agent of ca_id.ticker.
- ca_id identifies the attached ballot's CA.
- meta specifies the new metadata.
Errors
- UnauthorizedAgent if origin is not agent-permissioned for ticker.
- NoSuchBallot if ca_id does not identify a ballot.
- VotingAlreadyStarted if start >= now, where now is the current time.
- NumberOfChoicesOverflow if the total choice in meta overflows usize.
- TooLong if any of the embedded strings in meta are too long.

changeRcv(ca_id: `CAId`, rcv: `bool`)

interface: api.tx.corporateBallot.changeRcv
summary: Amend RCV support for the ballot of the CA identified by ca_id.

Arguments
- origin is a signer that has permissions to act as an agent of ca_id.ticker.
- ca_id identifies the attached ballot's CA.
- rcv specifies if RCV is to be supported or not.
Errors
- UnauthorizedAgent if origin is not agent-permissioned for ticker.
- NoSuchBallot if ca_id does not identify a ballot.
- VotingAlreadyStarted if start >= now, where now is the current time.

removeBallot(ca_id: `CAId`)

interface: api.tx.corporateBallot.removeBallot
summary: Remove the ballot of the CA identified by ca_id.

Arguments
- origin is a signer that has permissions to act as an agent of ca_id.ticker.
- ca_id identifies the attached ballot's CA.
Errors
- UnauthorizedAgent if origin is not agent-permissioned for ticker.
- NoSuchBallot if ca_id does not identify a ballot.
- VotingAlreadyStarted if start >= now, where now is the current time.

vote(ca_id: `CAId`, votes: `Vec<BallotVote>`)

interface: api.tx.corporateBallot.vote
summary: Cast votes in the ballot attached to the CA identified by ca_id.

Arguments
- origin which must be a permissioned signer targeted by the CA.
- ca_id identifies the attached ballot's CA.
- votes specifies the balances to assign to each choice in the ballot. The full voting power of origin's DID may be used for each motion in the ballot.
Errors
- NoSuchBallot if ca_id does not identify a ballot.
- VotingNotStarted if the voting period hasn't commenced yet.
- VotingAlreadyEnded if the voting period has ended.
- WrongVoteCount if the number of choices in the ballot does not match votes.len().
- NoSuchCA if ca_id does not identify an existing CA.
- NotTargetedByCA if the CA does not target origin's DID.
- InsufficientVotes if the voting power used for any motion in votes exceeds origin's DID's voting power.

externalAgents

abdicate(ticker: `Ticker`)

interface: api.tx.externalAgents.abdicate
summary: Abdicate agentship for ticker.

Arguments
- ticker of which the caller is an agent.
Errors
- NotAnAgent if the caller is not an agent of ticker.
- RemovingLastFullAgent if the caller is the last full agent.
Permissions
- Asset

acceptBecomeAgent(auth_id: `u64`)

interface: api.tx.externalAgents.acceptBecomeAgent
summary: Accept an authorization by an agent "Alice" who issued auth_id to also become an agent of the ticker Alice specified.

Arguments
- auth_id identifying the authorization to accept.
Errors
- AuthorizationError::Invalid if auth_id does not exist for the given caller.
- AuthorizationError::Expired if auth_id is for an auth that has expired.
- AuthorizationError::BadType if auth_id was not for a BecomeAgent auth type.
- UnauthorizedAgent if "Alice" is not permissioned to provide the auth.
- NoSuchAG if the group referred to a custom that does not exist.
- AlreadyAnAgent if the caller is already an agent of the ticker.
Permissions
- Agent

changeGroup(ticker: `Ticker`, agent: `IdentityId`, group: `AgentGroup`)

interface: api.tx.externalAgents.changeGroup
summary: Change the agent group that agent belongs to in ticker.

Arguments
- ticker that has the agent.
- agent of ticker to change the group for.
- group that agent will belong to in ticker.
Errors
- UnauthorizedAgent if origin was not authorized as an agent to call this.
- NoSuchAG if id does not identify a custom AG.
- NotAnAgent if agent is not an agent of ticker.
- RemovingLastFullAgent if agent was a Full one and is being demoted.
Permissions
- Asset
- Agent

createGroup(ticker: `Ticker`, perms: `ExtrinsicPermissions`)

interface: api.tx.externalAgents.createGroup
summary: Creates a custom agent group (AG) for the given ticker.

The AG will have the permissions as given by perms. This new AG is then assigned id = AGIdSequence::get() + 1 as its AGId, which you can use as AgentGroup::Custom(id) when adding agents for ticker.

Arguments
- ticker to add the custom group for.
- perms that the new AG will have.
Errors
- UnauthorizedAgent if origin was not authorized as an agent to call this.
- TooLong if perms had some string or list length that was too long.
- CounterOverflow if AGIdSequence::get() + 1 would exceed u32::MAX.
Permissions
- Asset
- Agent

removeAgent(ticker: `Ticker`, agent: `IdentityId`)

interface: api.tx.externalAgents.removeAgent
summary: Remove the given agent from ticker.

Arguments
- ticker that has the agent to remove.
- agent of ticker to remove.
Errors
- UnauthorizedAgent if origin was not authorized as an agent to call this.
- NotAnAgent if agent is not an agent of ticker.
- RemovingLastFullAgent if agent is the last full one.
Permissions
- Asset
- Agent

setGroupPermissions(ticker: `Ticker`, id: `AGId`, perms: `ExtrinsicPermissions`)

interface: api.tx.externalAgents.setGroupPermissions
summary: Updates the permissions of the custom AG identified by id, for the given ticker.

Arguments
- ticker the custom AG belongs to.
- id for the custom AG within ticker.
- perms to update the custom AG to.
Errors
- UnauthorizedAgent if origin was not authorized as an agent to call this.
- TooLong if perms had some string or list length that was too long.
- NoSuchAG if id does not identify a custom AG.
Permissions
- Asset
- Agent

grandpa

noteStalled(delay: `BlockNumber`, best_finalized_block_number: `BlockNumber`)

interface: api.tx.grandpa.noteStalled
summary: Note that the current authority set of the GRANDPA finality gadget has stalled. This will trigger a forced authority set change at the beginning of the next session, to be enacted delay blocks after that. The delay should be high enough to safely assume that the block signalling the forced change will not be re-orged (e.g. 1000 blocks). The GRANDPA voters will start the new authority set using the given finalized block as base. Only callable by root.

reportEquivocation(equivocation_proof: `GrandpaEquivocationProof`, key_owner_proof: `KeyOwnerProof`)

interface: api.tx.grandpa.reportEquivocation
summary: Report voter equivocation/misbehavior. This method will verify the equivocation proof and validate the given key ownership proof against the extracted offender. If both are valid, the offence will be reported.

reportEquivocationUnsigned(equivocation_proof: `GrandpaEquivocationProof`, key_owner_proof: `KeyOwnerProof`)

interface: api.tx.grandpa.reportEquivocationUnsigned
summary: Report voter equivocation/misbehavior. This method will verify the equivocation proof and validate the given key ownership proof against the extracted offender. If both are valid, the offence will be reported.

This extrinsic must be called unsigned and it is expected that only block authors will call it (validated in ValidateUnsigned), as such if the block author is defined it will be defined as the equivocation reporter.

identity

acceptPrimaryKey(rotation_auth_id: `u64`, optional_cdd_auth_id: `Option<u64>`)

interface: api.tx.identity.acceptPrimaryKey
summary: Call this with the new primary key. By invoking this method, caller accepts authorization to become the new primary key of the issuing identity. If a CDD service provider approved this change (or this is not required), primary key of the DID is updated.

The caller (new primary key) must be either a secondary key of the issuing identity, or unlinked to any identity.

Differs from rotate_primary_key_to_secondary in that it will unlink the old primary key instead of leaving it as a secondary key.

Arguments
- owner_auth_id Authorization from the owner who initiated the change
- cdd_auth_id Authorization from a CDD service provider

addAuthorization(target: `Signatory`, data: `AuthorizationData`, expiry: `Option<Moment>`)

interface: api.tx.identity.addAuthorization
summary: Adds an authorization.

addClaim(target: `IdentityId`, claim: `Claim`, expiry: `Option<Moment>`)

interface: api.tx.identity.addClaim
summary: Adds a new claim record or edits an existing one.

Only called by did_issuer's secondary key.

addInvestorUniquenessClaim(target: `IdentityId`, claim: `Claim`, proof: `InvestorZKProofData`, expiry: `Option<Moment>`)

interface: api.tx.identity.addInvestorUniquenessClaim
summary: Add Claim::InvestorUniqueness claim for a given target identity.

Arguments
- origin - Who provides the claim to the user? In this case, it's the user's account id as the user provides.
- target - IdentityId to which the claim gets assigned.
- claim - InvestorUniqueness claim details.
- proof - To validate the self attestation.
- expiry - Expiry of claim.
Errors
- DidMustAlreadyExist Target should already been a part of the ecosystem.
- ClaimVariantNotAllowed When origin trying to pass claim variant other than InvestorUniqueness.
- ConfidentialScopeClaimNotAllowed When issuer is different from target or CDD_ID is invalid for given user.
- `InvalidScopeClaim When proof is invalid.

addInvestorUniquenessClaimV2(target: `IdentityId`, scope: `Scope`, claim: `Claim`, proof: `ScopeClaimProof`, expiry: `Option<Moment>`)

interface: api.tx.identity.addInvestorUniquenessClaimV2

addSecondaryKeysWithAuthorization(additional_keys: `Vec<SecondaryKeyWithAuth>`, expires_at: `Moment`)

interface: api.tx.identity.addSecondaryKeysWithAuthorization
summary: It adds secondary keys to target identity id. Keys are directly added to identity because each of them has an authorization.

Arguments:
- origin Primary key of id identity.
- id Identity where new secondary keys will be added.
- additional_keys New secondary items (and their authorization data) to add to target identity.
Failure
- It can only called by primary key owner.
- Keys should be able to linked to any identity.

cddRegisterDid(target_account: `AccountId`, secondary_keys: `Vec<SecondaryKey>`)

interface: api.tx.identity.cddRegisterDid
summary: Register target_account with a new Identity.

Failure
- origin has to be a active CDD provider. Inactive CDD providers cannot add new claims.
- target_account (primary key of the new Identity) can be linked to just one and only one identity.
- External secondary keys can be linked to just one identity.
Weight 7_000_000_000 + 600_000 * secondary_keys.len()

changeCddRequirementForMkRotation(auth_required: `bool`)

interface: api.tx.identity.changeCddRequirementForMkRotation
summary: Set if CDD authorization is required for updating primary key of an identity. Callable via root (governance)

Arguments
- auth_required CDD Authorization required or not

freezeSecondaryKeys()

interface: api.tx.identity.freezeSecondaryKeys
summary: It disables all secondary keys at did identity.

Errors

gcAddCddClaim(target: `IdentityId`)

interface: api.tx.identity.gcAddCddClaim
summary: Assuming this is executed by the GC voting majority, adds a new cdd claim record.

gcRevokeCddClaim(target: `IdentityId`)

interface: api.tx.identity.gcRevokeCddClaim
summary: Assuming this is executed by the GC voting majority, removes an existing cdd claim record.

invalidateCddClaims(cdd: `IdentityId`, disable_from: `Moment`, expiry: `Option<Moment>`)

interface: api.tx.identity.invalidateCddClaims
summary: Invalidates any claim generated by cdd from disable_from timestamps.

You can also define an expiration time, which will invalidate all claims generated by that cdd and remove it as CDD member group.

joinIdentityAsKey(auth_id: `u64`)

interface: api.tx.identity.joinIdentityAsKey
summary: Join an identity as a secondary key.

leaveIdentityAsKey()

interface: api.tx.identity.leaveIdentityAsKey
summary: Leave the secondary key's identity.

legacySetPermissionToSigner(signer: `Signatory`, permissions: `LegacyPermissions`)

interface: api.tx.identity.legacySetPermissionToSigner
summary: This function is a workaround for https://github.com/polkadot-js/apps/issues/3632 It sets permissions for an specific target_key key. Only the primary key of an identity is able to set secondary key permissions.

removeAuthorization(target: `Signatory`, auth_id: `u64`, _auth_issuer_pays: `bool`)

interface: api.tx.identity.removeAuthorization
summary: Removes an authorization. _auth_issuer_pays determines whether the issuer of the authorisation pays the transaction fee

removeSecondaryKeys(signers_to_remove: `Vec<Signatory>`)

interface: api.tx.identity.removeSecondaryKeys
summary: Removes specified secondary keys of a DID if present.

Failure It can only called by primary key owner.

Weight 950_000_000 + 60_000 * signers_to_remove.len()

revokeClaim(target: `IdentityId`, claim: `Claim`)

interface: api.tx.identity.revokeClaim
summary: Marks the specified claim as revoked.

revokeClaimByIndex(target: `IdentityId`, claim_type: `ClaimType`, scope: `Option<Scope>`)

interface: api.tx.identity.revokeClaimByIndex
summary: Revokes a specific claim using its Claim Unique Index composed by target, claim_type, and scope.

Please note that origin must be the issuer of the target claim.

Errors
- TargetHasNonZeroBalanceAtScopeId when you try to revoke a InvestorUniqueness* claim, and target identity still have any balance on the given scope.

rotatePrimaryKeyToSecondary(auth_id: `u64`, optional_cdd_auth_id: `Option<u64>`)

interface: api.tx.identity.rotatePrimaryKeyToSecondary
summary: Call this with the new primary key. By invoking this method, caller accepts authorization to become the new primary key of the issuing identity. If a CDD service provider approved this change, (or this is not required), primary key of the DID is updated.

The caller (new primary key) must be either a secondary key of the issuing identity, or unlinked to any identity.

Differs from accept_primary_key in that it will leave the old primary key as a secondary key with the permissions specified in the corresponding RotatePrimaryKeyToSecondary authorization instead of unlinking the old primary key.

Arguments
- owner_auth_id Authorization from the owner who initiated the change
- cdd_auth_id Authorization from a CDD service provider

setPermissionToSigner(signer: `Signatory`, perms: `Permissions`)

interface: api.tx.identity.setPermissionToSigner
summary: Sets permissions for an specific target_key key.

Only the primary key of an identity is able to set secondary key permissions.

unfreezeSecondaryKeys()

interface: api.tx.identity.unfreezeSecondaryKeys
summary: Re-enables all secondary keys of the caller's identity.

imOnline

heartbeat(heartbeat: `Heartbeat`, _signature: `Signature`)

interface: api.tx.imOnline.heartbeat
summary:

indices

claim(index: `AccountIndex`)

interface: api.tx.indices.claim
summary: Assign an previously unassigned index.

Payment: Deposit is reserved from the sender account.

The dispatch origin for this call must be Signed.
- index: the index to be claimed. This must not be in use.
Emits IndexAssigned if successful.

forceTransfer(new: `AccountId`, index: `AccountIndex`, freeze: `bool`)

interface: api.tx.indices.forceTransfer
summary: Force an index to an account. This doesn't require a deposit. If the index is already held, then any deposit is reimbursed to its current owner.

The dispatch origin for this call must be Root.
- index: the index to be (re-)assigned.
- new: the new owner of the index. This function is a no-op if it is equal to sender.
- freeze: if set to true, will freeze the index so it cannot be transferred.
Emits IndexAssigned if successful.

free(index: `AccountIndex`)

interface: api.tx.indices.free
summary: Free up an index owned by the sender.

Payment: Any previous deposit placed for the index is unreserved in the sender account.

The dispatch origin for this call must be Signed and the sender must own the index.
- index: the index to be freed. This must be owned by the sender.
Emits IndexFreed if successful.

freeze(index: `AccountIndex`)

interface: api.tx.indices.freeze
summary: Freeze an index so it will always point to the sender account. This consumes the deposit.

The dispatch origin for this call must be Signed and the signing account must have a non-frozen account index.
- index: the index to be frozen in place.
Emits IndexFrozen if successful.

transfer(new: `AccountId`, index: `AccountIndex`)

interface: api.tx.indices.transfer
summary: Assign an index already owned by the sender to another account. The balance reservation is effectively transferred to the new account.

The dispatch origin for this call must be Signed.
- index: the index to be re-assigned. This must be owned by the sender.
- new: the new owner of the index. This function is a no-op if it is equal to sender.
Emits IndexAssigned if successful.

multiSig

acceptMultisigSignerAsIdentity(auth_id: `u64`)

interface: api.tx.multiSig.acceptMultisigSignerAsIdentity
summary: Accepts a multisig signer authorization given to signer's identity.

Arguments
- auth_id - Auth id of the authorization.

acceptMultisigSignerAsKey(auth_id: `u64`)

interface: api.tx.multiSig.acceptMultisigSignerAsKey
summary: Accepts a multisig signer authorization given to signer's key (AccountId).

Arguments
- auth_id - Auth id of the authorization.

addMultisigSigner(signer: `Signatory`)

interface: api.tx.multiSig.addMultisigSigner
summary: Adds a signer to the multisig. This must be called by the multisig itself.

Arguments
- signer - Signatory to add.

addMultisigSignersViaCreator(multisig: `AccountId`, signers: `Vec<Signatory>`)

interface: api.tx.multiSig.addMultisigSignersViaCreator
summary: Adds a signer to the multisig. This must be called by the creator identity of the multisig.

Arguments
- multisig - Address of the multi sig
- signers - Signatories to add.
Weight 900_000_000 + 3_000_000 * signers.len()

approveAsIdentity(multisig: `AccountId`, proposal_id: `u64`)

interface: api.tx.multiSig.approveAsIdentity
summary: Approves a multisig proposal using the caller's identity.

Arguments
- multisig - MultiSig address.
- proposal_id - Proposal id to approve. If quorum is reached, the proposal will be immediately executed.

approveAsKey(multisig: `AccountId`, proposal_id: `u64`)

interface: api.tx.multiSig.approveAsKey
summary: Approves a multisig proposal using the caller's secondary key (AccountId).

Arguments
- multisig - MultiSig address.
- proposal_id - Proposal id to approve. If quorum is reached, the proposal will be immediately executed.

changeSigsRequired(sigs_required: `u64`)

interface: api.tx.multiSig.changeSigsRequired
summary: Changes the number of signatures required by a multisig. This must be called by the multisig itself.

Arguments
- sigs_required - New number of required signatures.

createMultisig(signers: `Vec<Signatory>`, sigs_required: `u64`)

interface: api.tx.multiSig.createMultisig
summary: Creates a multisig

Arguments
- signers - Signers of the multisig (They need to accept authorization before they are actually added).
- sigs_required - Number of sigs required to process a multi-sig tx.

createOrApproveProposalAsIdentity(multisig: `AccountId`, proposal: `Proposal`, expiry: `Option<Moment>`, auto_close: `bool`)

interface: api.tx.multiSig.createOrApproveProposalAsIdentity
summary: Creates a multisig proposal if it hasn't been created or approves it if it has.

Arguments
- multisig - MultiSig address.
- proposal - Proposal to be voted on.
- expiry - Optional proposal expiry time.
- auto_close - Close proposal on receiving enough reject votes. If this is 1 out of m multisig, the proposal will be immediately executed.

createOrApproveProposalAsKey(multisig: `AccountId`, proposal: `Proposal`, expiry: `Option<Moment>`, auto_close: `bool`)

interface: api.tx.multiSig.createOrApproveProposalAsKey
summary: Creates a multisig proposal if it hasn't been created or approves it if it has.

Arguments
- multisig - MultiSig address.
- proposal - Proposal to be voted on.
- expiry - Optional proposal expiry time.
- auto_close - Close proposal on receiving enough reject votes. If this is 1 out of m multisig, the proposal will be immediately executed.

createProposalAsIdentity(multisig: `AccountId`, proposal: `Proposal`, expiry: `Option<Moment>`, auto_close: `bool`)

interface: api.tx.multiSig.createProposalAsIdentity
summary: Creates a multisig proposal

Arguments
- multisig - MultiSig address.
- proposal - Proposal to be voted on.
- expiry - Optional proposal expiry time.
- auto_close - Close proposal on receiving enough reject votes. If this is 1 out of m multisig, the proposal will be immediately executed.

createProposalAsKey(multisig: `AccountId`, proposal: `Proposal`, expiry: `Option<Moment>`, auto_close: `bool`)

interface: api.tx.multiSig.createProposalAsKey
summary: Creates a multisig proposal

Arguments
- multisig - MultiSig address.
- proposal - Proposal to be voted on.
- expiry - Optional proposal expiry time.
- auto_close - Close proposal on receiving enough reject votes. If this is 1 out of m multisig, the proposal will be immediately executed.

executeScheduledProposal(multisig: `AccountId`, proposal_id: `u64`, multisig_did: `IdentityId`, _proposal_weight: `Weight`)

interface: api.tx.multiSig.executeScheduledProposal
summary: Root callable extrinsic, used as an internal call for executing scheduled multisig proposal.

makeMultisigPrimary(multisig: `AccountId`, optional_cdd_auth_id: `Option<u64>`)

interface: api.tx.multiSig.makeMultisigPrimary
summary: Adds a multisig as the primary key of the current did if the current DID is the creator of the multisig.

Arguments
- multi_sig - multi sig address

makeMultisigSigner(multisig: `AccountId`)

interface: api.tx.multiSig.makeMultisigSigner
summary: Adds a multisig as a signer of current did if the current did is the creator of the multisig.

Arguments
- multisig - multi sig address

rejectAsIdentity(multisig: `AccountId`, proposal_id: `u64`)

interface: api.tx.multiSig.rejectAsIdentity
summary: Rejects a multisig proposal using the caller's identity.

Arguments
- multisig - MultiSig address.
- proposal_id - Proposal id to reject. If quorum is reached, the proposal will be immediately executed.

rejectAsKey(multisig: `AccountId`, proposal_id: `u64`)

interface: api.tx.multiSig.rejectAsKey
summary: Rejects a multisig proposal using the caller's secondary key (AccountId).

Arguments
- multisig - MultiSig address.
- proposal_id - Proposal id to reject. If quorum is reached, the proposal will be immediately executed.

removeMultisigSigner(signer: `Signatory`)

interface: api.tx.multiSig.removeMultisigSigner
summary: Removes a signer from the multisig. This must be called by the multisig itself.

Arguments
- signer - Signatory to remove.

removeMultisigSignersViaCreator(multisig: `AccountId`, signers: `Vec<Signatory>`)

interface: api.tx.multiSig.removeMultisigSignersViaCreator
summary: Removes a signer from the multisig. This must be called by the creator identity of the multisig.

Arguments
- multisig - Address of the multisig.
- signers - Signatories to remove.
Weight 900_000_000 + 3_000_000 * signers.len()

offences

pips

approveCommitteeProposal(id: `PipId`)

interface: api.tx.pips.approveCommitteeProposal
summary: Approves the pending committee PIP given by the id.

Errors
- BadOrigin unless a GC voting majority executes this function.
- NoSuchProposal if the PIP with id doesn't exist.
- IncorrectProposalState if the proposal isn't pending.
- NotByCommittee if the proposal isn't by a committee.

clearSnapshot()

interface: api.tx.pips.clearSnapshot
summary: Clears the snapshot and emits the event SnapshotCleared.

Errors
- NotACommitteeMember - triggered when a non-GC-member executes the function.

enactSnapshotResults(results: `Vec<(PipId,SnapshotResult)>`)

interface: api.tx.pips.enactSnapshotResults
summary: Enacts results for the PIPs in the snapshot queue. The snapshot will be available for further enactments until it is cleared.

The results are encoded a list of (id, result) where result is applied to id. Note that the snapshot priority queue is encoded with the lowest priority first. so results = [(id, Approve)] will approve SnapshotQueue[SnapshotQueue.len() - 1].

Errors
- BadOrigin - unless a GC voting majority executes this function.
- CannotSkipPip - a given PIP has already been skipped too many times.
- SnapshotResultTooLarge - on len(results) > len(snapshot_queue).
- SnapshotIdMismatch - if: text ∃ (i ∈ 0..SnapshotQueue.len()). results[i].0 ≠ SnapshotQueue[SnapshotQueue.len() - i].id This is protects against clearing queue while GC is voting.

executeScheduledPip(id: `PipId`)

interface: api.tx.pips.executeScheduledPip
summary: Internal dispatchable that handles execution of a PIP.

expireScheduledPip(did: `IdentityId`, id: `PipId`)

interface: api.tx.pips.expireScheduledPip
summary: Internal dispatchable that handles expiration of a PIP.

propose(proposal: `Proposal`, deposit: `Balance`, url: `Option<Url>`, description: `Option<PipDescription>`)

interface: api.tx.pips.propose
summary: A network member creates a PIP by submitting a dispatchable which changes the network in someway. A minimum deposit is required to open a new proposal.

Arguments
- proposer is either a signing key or committee. Used to understand whether this is a committee proposal and verified against origin.
- proposal a dispatchable call
- deposit minimum deposit value, which is ignored if proposer is a committee.
- url a link to a website for proposal discussion

pruneProposal(id: `PipId`)

interface: api.tx.pips.pruneProposal
summary: Prune the PIP given by the id, refunding any funds not already refunded. The PIP may not be active

This function is intended for storage garbage collection purposes.

Errors
- BadOrigin unless a GC voting majority executes this function.
- NoSuchProposal if the PIP with id doesn't exist.
- IncorrectProposalState if the proposal is active.

rejectProposal(id: `PipId`)

interface: api.tx.pips.rejectProposal
summary: Rejects the PIP given by the id, refunding any bonded funds, assuming it hasn't been cancelled or executed. Note that proposals scheduled-for-execution can also be rejected.

Errors
- BadOrigin unless a GC voting majority executes this function.
- NoSuchProposal if the PIP with id doesn't exist.
- IncorrectProposalState if the proposal was cancelled or executed.

rescheduleExecution(id: `PipId`, until: `Option<BlockNumber>`)

interface: api.tx.pips.rescheduleExecution
summary: Updates the execution schedule of the PIP given by id.

Arguments
- until defines the future block where the enactment period will finished. None value means that enactment period is going to finish in the next block.
Errors
- RescheduleNotByReleaseCoordinator unless triggered by release coordinator.
- IncorrectProposalState unless the proposal was in a scheduled state.

setActivePipLimit(limit: `u32`)

interface: api.tx.pips.setActivePipLimit
summary: Change the maximum number of active PIPs before community members cannot propose anything. Can only be called by root.

Arguments
- limit of concurrent active PIPs.

setDefaultEnactmentPeriod(duration: `BlockNumber`)

interface: api.tx.pips.setDefaultEnactmentPeriod
summary: Change the default enactment period. Can only be called by root.

Arguments
- duration the new default enactment period it takes for a scheduled PIP to be executed.

setMaxPipSkipCount(max: `SkippedCount`)

interface: api.tx.pips.setMaxPipSkipCount
summary: Change the maximum skip count (max_pip_skip_count). Can only be called by root.

Arguments
- max skips before a PIP cannot be skipped by GC anymore.

setMinProposalDeposit(deposit: `Balance`)

interface: api.tx.pips.setMinProposalDeposit
summary: Change the minimum proposal deposit amount required to start a proposal. Can only be called by root.

Arguments
- deposit the new min deposit required to start a proposal

setPendingPipExpiry(expiry: `MaybeBlock`)

interface: api.tx.pips.setPendingPipExpiry
summary: Change the amount of blocks after which a pending PIP is expired. If expiry is None then PIPs never expire. Can only be called by root.

Arguments
- expiry the block-time it takes for a still-Pending PIP to expire.

setPruneHistoricalPips(prune: `bool`)

interface: api.tx.pips.setPruneHistoricalPips
summary: Change whether completed PIPs are pruned. Can only be called by root.

Arguments
- prune specifies whether completed PIPs should be pruned.

snapshot()

interface: api.tx.pips.snapshot
summary: Takes a new snapshot of the current list of active && pending PIPs. The PIPs are then sorted into a priority queue based on each PIP's weight.

Errors
- NotACommitteeMember - triggered when a non-GC-member executes the function.

vote(id: `PipId`, aye_or_nay: `bool`, deposit: `Balance`)

interface: api.tx.pips.vote
summary: Vote either in favor (aye_or_nay == true) or against a PIP with id. The "convinction" or strength of the vote is given by deposit, which is reserved.

Note that vote is not additive. That is, vote(id, true, 50) followed by vote(id, true, 40) will first reserve 50 and then refund 50 - 10, ending up with 40 in deposit. To add atop of existing votes, you'll need existing_deposit + addition.

Arguments
- id, proposal id
- aye_or_nay, a bool representing for or against vote
- deposit, the "conviction" with which the vote is made.
Errors
- NoSuchProposal if id doesn't reference a valid PIP.
- NotFromCommunity if proposal was made by a committee.
- IncorrectProposalState if PIP isn't pending.
- InsufficientDeposit if origin cannot reserve deposit - old_deposit.

polymeshCommittee

setExpiresAfter(expiry: `MaybeBlock`)

interface: api.tx.polymeshCommittee.setExpiresAfter
summary: Changes the time after which a proposal expires.

Arguments
- expiry - The new expiry time.

setReleaseCoordinator(id: `IdentityId`)

interface: api.tx.polymeshCommittee.setReleaseCoordinator
summary: Changes the release coordinator.

Arguments
- id - The DID of the new release coordinator.
Errors
- NotAMember, If the new coordinator id is not part of the committee.

setVoteThreshold(n: `u32`, d: `u32`)

interface: api.tx.polymeshCommittee.setVoteThreshold
summary: Change the vote threshold the determines the winning proposal. For e.g., for a simple majority use (1, 2) which represents the in-equation ">= 1/2".

Arguments
- n - Numerator of the fraction representing vote threshold.
- d - Denominator of the fraction representing vote threshold.

vote(proposal: `Hash`, index: `ProposalIndex`, approve: `bool`)

interface: api.tx.polymeshCommittee.vote
summary: Votes approveingly (or not, if false) on an existing proposal given by its hash, index.

Arguments
- proposal - A hash of the proposal to be voted on.
- index - The proposal index.
- approve - If true than this is a for vote, and against otherwise.
Errors
- NotAMember, if the origin is not a member of this committee.

voteOrPropose(approve: `bool`, call: `Call`)

interface: api.tx.polymeshCommittee.voteOrPropose
summary: Proposes to the committee that call should be executed in its name. Alternatively, if the hash of call has already been recorded, i.e., already proposed, then this call counts as a vote, i.e., as if vote_by_hash was called.

Weight

The weight of this dispatchable is that of call as well as the complexity for recording the vote itself.

Arguments
- approve - is this an approving vote? If the proposal doesn't exist, passing false will result in error FirstVoteReject.
- call - the call to propose for execution.
Errors
- FirstVoteReject, if call hasn't been proposed and approve == false.
- NotAMember, if the origin is not a member of this committee.

portfolio

acceptPortfolioCustody(auth_id: `u64`)

interface: api.tx.portfolio.acceptPortfolioCustody

createPortfolio(name: `PortfolioName`)

interface: api.tx.portfolio.createPortfolio
summary: Creates a portfolio with the given name.

deletePortfolio(num: `PortfolioNumber`)

interface: api.tx.portfolio.deletePortfolio
summary: Deletes a user portfolio. A portfolio can be deleted only if it has no funds.

Errors
- PortfolioDoesNotExist if num doesn't reference a valid portfolio.
- PortfolioNotEmpty if the portfolio still holds any asset
Permissions
- Portfolio

movePortfolioFunds(from: `PortfolioId`, to: `PortfolioId`, items: `Vec<MovePortfolioItem>`)

interface: api.tx.portfolio.movePortfolioFunds
summary: Moves a token amount from one portfolio of an identity to another portfolio of the same identity. Must be called by the custodian of the sender. Funds from deleted portfolios can also be recovered via this method.

A short memo can be added to to each token amount moved.

Errors
- PortfolioDoesNotExist if one or both of the portfolios reference an invalid portfolio.
- destination_is_same_portfolio if both sender and receiver portfolio are the same
- DifferentIdentityPortfolios if the sender and receiver portfolios belong to different identities
- UnauthorizedCustodian if the caller is not the custodian of the from portfolio
- InsufficientPortfolioBalance if the sender does not have enough free balance
Permissions
- Portfolio

quitPortfolioCustody(pid: `PortfolioId`)

interface: api.tx.portfolio.quitPortfolioCustody
summary: When called by the custodian of portfolio_id, allows returning the custody of the portfolio to the portfolio owner unilaterally.

Errors
- UnauthorizedCustodian if the caller is not the current custodian of portfolio_id.
Permissions
- Portfolio

renamePortfolio(num: `PortfolioNumber`, to_name: `PortfolioName`)

interface: api.tx.portfolio.renamePortfolio
summary: Renames a non-default portfolio.

Errors
- PortfolioDoesNotExist if num doesn't reference a valid portfolio.
Permissions
- Portfolio

protocolFee

changeBaseFee(op: `ProtocolOp`, base_fee: `Balance`)

interface: api.tx.protocolFee.changeBaseFee
summary: Changes the a base fee for the root origin.

Errors
- BadOrigin - Only root allowed.

changeCoefficient(coefficient: `PosRatio`)

interface: api.tx.protocolFee.changeCoefficient
summary: Changes the fee coefficient for the root origin.

Errors
- BadOrigin - Only root allowed.

randomnessCollectiveFlip

relayer

acceptPayingKey(auth_id: `u64`)

interface: api.tx.relayer.acceptPayingKey
summary: Accepts a paying_key authorization.

Arguments
- auth_id the authorization id to accept a paying_key.
Errors
- AuthorizationError::Invalid if auth_id does not exist for the given caller.
- AuthorizationError::Expired if auth_id the authorization has expired.
- AuthorizationError::BadType if auth_id was not a AddRelayerPayingKey authorization.
- NotAuthorizedForUserKey if origin is not authorized to accept the authorization for the user_key.
- NotAuthorizedForPayingKey if the authorization was created an identity different from the paying_key's identity.
- UserKeyCddMissing if the user_key is not attached to a CDD'd identity.
- PayingKeyCddMissing if the paying_key is not attached to a CDD'd identity.
- UnauthorizedCaller if origin is not authorized to call this extrinsic.

decreasePolyxLimit(user_key: `AccountId`, amount: `Balance`)

interface: api.tx.relayer.decreasePolyxLimit
summary: Decrease the available POLYX for a user_key.

Arguments
- user_key the user key of the subsidy to update the available POLYX.
- amount the amount of POLYX to remove from the subsidy of user_key.
Errors
- NoPayingKey if the user_key doesn't have a paying_key.
- NotPayingKey if origin doesn't match the current paying_key.
- UnauthorizedCaller if origin is not authorized to call this extrinsic.
- Overlow if the subsidy has less then amount POLYX remaining.

increasePolyxLimit(user_key: `AccountId`, amount: `Balance`)

interface: api.tx.relayer.increasePolyxLimit
summary: Increase the available POLYX for a user_key.

Arguments
- user_key the user key of the subsidy to update the available POLYX.
- amount the amount of POLYX to add to the subsidy of user_key.
Errors
- NoPayingKey if the user_key doesn't have a paying_key.
- NotPayingKey if origin doesn't match the current paying_key.
- UnauthorizedCaller if origin is not authorized to call this extrinsic.
- Overlow if the subsidy's remaining POLYX would have overflowed u128::MAX.

removePayingKey(user_key: `AccountId`, paying_key: `AccountId`)

interface: api.tx.relayer.removePayingKey
summary: Removes the paying_key from a user_key.

Arguments
- user_key the user key to remove the subsidy from.
- paying_key the paying key that was subsidising the user_key.
Errors
- NotAuthorizedForUserKey if origin is not authorized to remove the subsidy for the user_key.
- NoPayingKey if the user_key doesn't have a paying_key.
- NotPayingKey if the paying_key doesn't match the current paying_key.
- UnauthorizedCaller if origin is not authorized to call this extrinsic.

setPayingKey(user_key: `AccountId`, polyx_limit: `Balance`)

interface: api.tx.relayer.setPayingKey
summary: Creates an authorization to allow user_key to accept the caller (origin == paying_key) as their subsidiser.

Arguments
- user_key the user key to subsidise.
- polyx_limit the initial POLYX limit for this subsidy.
Errors
- UnauthorizedCaller if origin is not authorized to call this extrinsic.

updatePolyxLimit(user_key: `AccountId`, polyx_limit: `Balance`)

interface: api.tx.relayer.updatePolyxLimit
summary: Updates the available POLYX for a user_key.

Arguments
- user_key the user key of the subsidy to update the available POLYX.
- polyx_limit the amount of POLYX available for subsidising the user_key.
Errors
- NoPayingKey if the user_key doesn't have a paying_key.
- NotPayingKey if origin doesn't match the current paying_key.
- UnauthorizedCaller if origin is not authorized to call this extrinsic.

rewards

claimItnReward(reward_address: `AccountId`, itn_address: `AccountId`, signature: `OffChainSignature`)

interface: api.tx.rewards.claimItnReward
summary: Claim an ITN reward.

Arguments
- itn_address specifying the awarded address on ITN.
- signature authenticating the claim to the reward. The signature should contain reward_address followed by the suffix "claim_itn_reward", and must have been signed by itn_address.
Errors
- InsufficientBalance - Itn rewards has insufficient funds to issue the reward.
- InvalidSignature - signature had an invalid signer or invalid message.
- ItnRewardAlreadyClaimed - Reward issued to the itn_address has already been claimed.
- UnknownItnAddress - itn_address is not in the rewards table and has no reward to be claimed.

setItnRewardStatus(itn_address: `AccountId`, status: `ItnRewardStatus`)

interface: api.tx.rewards.setItnRewardStatus

scheduler

cancel(when: `BlockNumber`, index: `u32`)

interface: api.tx.scheduler.cancel
summary: Cancel an anonymously scheduled task.

cancelNamed(id: `Bytes`)

interface: api.tx.scheduler.cancelNamed
summary: Cancel a named scheduled task.

schedule(when: `BlockNumber`, maybe_periodic: `Option<Period>`, priority: `Priority`, call: `Call`)

interface: api.tx.scheduler.schedule
summary: Anonymously schedule a task.

scheduleAfter(after: `BlockNumber`, maybe_periodic: `Option<Period>`, priority: `Priority`, call: `Call`)

interface: api.tx.scheduler.scheduleAfter
summary: Anonymously schedule a task after a delay.

scheduleNamed(id: `Bytes`, when: `BlockNumber`, maybe_periodic: `Option<Period>`, priority: `Priority`, call: `Call`)

interface: api.tx.scheduler.scheduleNamed
summary: Schedule a named task.

scheduleNamedAfter(id: `Bytes`, after: `BlockNumber`, maybe_periodic: `Option<Period>`, priority: `Priority`, call: `Call`)

interface: api.tx.scheduler.scheduleNamedAfter
summary: Schedule a named task after a delay.

session

purgeKeys()

interface: api.tx.session.purgeKeys
summary: Removes any session key(s) of the function caller. This doesn't take effect until the next session.

The dispatch origin of this function must be signed.

setKeys(keys: `Keys`, proof: `Bytes`)

interface: api.tx.session.setKeys
summary: Sets the session key(s) of the function caller to keys. Allows an account to set its session key prior to becoming a validator. This doesn't take effect until the next session.

The dispatch origin of this function must be signed.

settlement

addAndAffirmInstruction(venue_id: `VenueId`, settlement_type: `SettlementType`, trade_date: `Option<Moment>`, value_date: `Option<Moment>`, legs: `Vec<Leg>`, portfolios: `Vec<PortfolioId>`)

interface: api.tx.settlement.addAndAffirmInstruction
summary: Adds and affirms a new instruction.

Arguments
- venue_id - ID of the venue this instruction belongs to.
- settlement_type - Defines if the instruction should be settled in the next block after receiving all affirmations or waiting till a specific block.
- trade_date - Optional date from which people can interact with this instruction.
- value_date - Optional date after which the instruction should be settled (not enforced)
- legs - Legs included in this instruction.
- portfolios - Portfolios that the sender controls and wants to use in this affirmations.
Permissions
- Portfolio

addInstruction(venue_id: `VenueId`, settlement_type: `SettlementType`, trade_date: `Option<Moment>`, value_date: `Option<Moment>`, legs: `Vec<Leg>`)

interface: api.tx.settlement.addInstruction
summary: Adds a new instruction.

Arguments
- venue_id - ID of the venue this instruction belongs to.
- settlement_type - Defines if the instruction should be settled in the next block after receiving all affirmations or waiting till a specific block.
- trade_date - Optional date from which people can interact with this instruction.
- value_date - Optional date after which the instruction should be settled (not enforced)
- legs - Legs included in this instruction.
Weight 950_000_000 + 1_000_000 * legs.len()

affirmInstruction(id: `InstructionId`, portfolios: `Vec<PortfolioId>`, max_legs_count: `u32`)

interface: api.tx.settlement.affirmInstruction
summary: Provide affirmation to an existing instruction.

Arguments
- id - Instruction id to affirm.
- portfolios - Portfolios that the sender controls and wants to affirm this instruction.
- max_legs_count - Number of legs that need to be affirmed.
Permissions
- Portfolio

affirmWithReceipts(id: `InstructionId`, receipt_details: `Vec<ReceiptDetails>`, portfolios: `Vec<PortfolioId>`, max_legs_count: `u32`)

interface: api.tx.settlement.affirmWithReceipts
summary: Accepts an instruction and claims a signed receipt.

Arguments
- id - Target instruction id.
- leg_id - Target leg id for the receipt
- receipt_uid - Receipt ID generated by the signer.
- signer - Signer of the receipt.
- signed_data - Signed receipt.
- portfolios - Portfolios that the sender controls and wants to accept this instruction with
Permissions
- Portfolio

allowVenues(ticker: `Ticker`, venues: `Vec<VenueId>`)

interface: api.tx.settlement.allowVenues
summary: Allows additional venues to create instructions involving an asset.
- ticker - Ticker of the token in question.
- venues - Array of venues that are allowed to create instructions for the token in question.
Permissions
- Asset

changeReceiptValidity(receipt_uid: `u64`, validity: `bool`)

interface: api.tx.settlement.changeReceiptValidity
summary: Marks a receipt issued by the caller as claimed or not claimed. This allows the receipt issuer to invalidate an already issued receipt or revalidate an already claimed receipt.
- receipt_uid - Unique ID of the receipt.
- validity - New validity of the receipt.

claimReceipt(id: `InstructionId`, receipt_details: `ReceiptDetails`)

interface: api.tx.settlement.claimReceipt
summary: Claims a signed receipt.

Arguments
- id - Target instruction id for the receipt.
- leg_id - Target leg id for the receipt
- receipt_uid - Receipt ID generated by the signer.
- signer - Signer of the receipt.
- signed_data - Signed receipt.
Permissions
- Portfolio

createVenue(details: `VenueDetails`, signers: `Vec<AccountId>`, typ: `VenueType`)

interface: api.tx.settlement.createVenue
summary: Registers a new venue.
- details - Extra details about a venue
- signers - Array of signers that are allowed to sign receipts for this venue
- typ - Type of venue being created

disallowVenues(ticker: `Ticker`, venues: `Vec<VenueId>`)

interface: api.tx.settlement.disallowVenues
summary: Revokes permission given to venues for creating instructions involving a particular asset.
- ticker - Ticker of the token in question.
- venues - Array of venues that are no longer allowed to create instructions for the token in question.
Permissions
- Asset

executeScheduledInstruction(id: `InstructionId`, _legs_count: `u32`)

interface: api.tx.settlement.executeScheduledInstruction
summary: Root callable extrinsic, used as an internal call to execute a scheduled settlement instruction.

rejectInstruction(id: `InstructionId`, portfolio: `PortfolioId`, num_of_legs: `u32`)

interface: api.tx.settlement.rejectInstruction
summary: Rejects an existing instruction.

Arguments
- id - Instruction id to reject.
- portfolio - Portfolio to reject the instruction.
- num_of_legs - Number of legs in the instruction.
Permissions
- Portfolio

rescheduleInstruction(id: `InstructionId`)

interface: api.tx.settlement.rescheduleInstruction
summary: Reschedules a failed instruction.

Arguments
- id - Target instruction id to reschedule.
Permissions
- Portfolio
Errors
- InstructionNotFailed - Instruction not in a failed state or does not exist.

setVenueFiltering(ticker: `Ticker`, enabled: `bool`)

interface: api.tx.settlement.setVenueFiltering
summary: Enables or disabled venue filtering for a token.

Arguments
- ticker - Ticker of the token in question.
- enabled - Boolean that decides if the filtering should be enabled.
Permissions
- Asset

unclaimReceipt(instruction_id: `InstructionId`, leg_id: `LegId`)

interface: api.tx.settlement.unclaimReceipt
summary: Unclaims a previously claimed receipt.

Arguments
- instruction_id - Target instruction id for the receipt.
- leg_id - Target leg id for the receipt
Permissions
- Portfolio

updateVenueDetails(id: `VenueId`, details: `VenueDetails`)

interface: api.tx.settlement.updateVenueDetails
summary: Edit a venue's details.
- id specifies the ID of the venue to edit.
- details specifies the updated venue details.

updateVenueType(id: `VenueId`, typ: `VenueType`)

interface: api.tx.settlement.updateVenueType
summary: Edit a venue's type.
- id specifies the ID of the venue to edit.
- type specifies the new type of the venue.

withdrawAffirmation(id: `InstructionId`, portfolios: `Vec<PortfolioId>`, max_legs_count: `u32`)

interface: api.tx.settlement.withdrawAffirmation
summary: Withdraw an affirmation for a given instruction.

Arguments
- id - Instruction id for that affirmation get withdrawn.
- portfolios - Portfolios that the sender controls and wants to withdraw affirmation.
- max_legs_count - Number of legs that need to be un-affirmed.
Permissions
- Portfolio

staking

addPermissionedValidator(identity: `IdentityId`, intended_count: `Option<u32>`)

interface: api.tx.staking.addPermissionedValidator
summary: Governance committee on 2/3 rds majority can introduce a new potential identity to the pool of permissioned entities who can run validators. Staking module uses PermissionedIdentity to ensure validators have completed KYB compliance and considers them for validation.

Arguments
- origin Required origin for adding a potential validator.
- identity Validator's IdentityId.
- intended_count No. of validators given identity intends to run.

bond(controller: `LookupSource`, value: `Compact<BalanceOf>`, payee: `RewardDestination`)

interface: api.tx.staking.bond
summary: Take the origin account as a stash and lock up value of its balance. controller will be the account that controls it.

value must be more than the minimum_balance specified by T::Currency.

The dispatch origin for this call must be Signed by the stash account.

Emits Bonded.

bondExtra(max_additional: `Compact<BalanceOf>`)

interface: api.tx.staking.bondExtra
summary: Add some extra amount that have appeared in the stash free_balance into the balance up for staking.

Use this if there are additional funds in your stash account that you wish to bond. Unlike [bond] or [unbond] this function does not impose any limitation on the amount that can be added.

The dispatch origin for this call must be Signed by the stash, not the controller and it can be only called when [EraElectionStatus] is Closed.

Emits Bonded.

cancelDeferredSlash(era: `EraIndex`, slash_indices: `Vec<u32>`)

interface: api.tx.staking.cancelDeferredSlash
summary: Cancel enactment of a deferred slash.

Can be called by the T::SlashCancelOrigin.

Parameters: era and indices of the slashes for that era to kill.

changeSlashingAllowedFor(slashing_switch: `SlashingSwitch`)

interface: api.tx.staking.changeSlashingAllowedFor
summary: Switch slashing status on the basis of given SlashingSwitch. Can only be called by root.

Arguments
- origin - AccountId of root.
- slashing_switch - Switch used to set the targets for slashing.

chill()

interface: api.tx.staking.chill
summary: Declare no desire to either validate or nominate.

Effects will be felt at the beginning of the next era.

The dispatch origin for this call must be Signed by the controller, not the stash. And, it can be only called when [EraElectionStatus] is Closed.

forceNewEra()

interface: api.tx.staking.forceNewEra
summary: Force there to be a new era at the end of the next session. After this, it will be reset to normal (non-forced) behaviour.

The dispatch origin must be Root.

forceNewEraAlways()

interface: api.tx.staking.forceNewEraAlways
summary: Force there to be a new era at the end of sessions indefinitely.

The dispatch origin must be Root.

forceNoEras()

interface: api.tx.staking.forceNoEras
summary: Force there to be no new eras indefinitely.

The dispatch origin must be Root.

forceUnstake(stash: `AccountId`, num_slashing_spans: `u32`)

interface: api.tx.staking.forceUnstake
summary: Force a current staker to become completely unstaked, immediately.

The dispatch origin must be Root.

increaseValidatorCount(additional: `Compact<u32>`)

interface: api.tx.staking.increaseValidatorCount
summary: Increments the ideal number of validators.

The dispatch origin must be Root.

nominate(targets: `Vec<LookupSource>`)

interface: api.tx.staking.nominate
summary: Declare the desire to nominate targets for the origin controller.

Effects will be felt at the beginning of the next era. This can only be called when [EraElectionStatus] is Closed.

The dispatch origin for this call must be Signed by the controller, not the stash. And, it can be only called when [EraElectionStatus] is Closed.

payoutStakers(validator_stash: `AccountId`, era: `EraIndex`)

interface: api.tx.staking.payoutStakers
summary: Pay out all the stakers behind a single validator for a single era.
- validator_stash is the stash account of the validator. Their nominators, up to T::MaxNominatorRewardedPerValidator, will also receive their rewards.
- era may be any era between [current_era - history_depth; current_era].
The origin of this call must be Signed. Any account can call this function, even if it is not one of the stakers.

This can only be called when [EraElectionStatus] is Closed.

payoutStakersBySystem(validator_stash: `AccountId`, era: `EraIndex`)

interface: api.tx.staking.payoutStakersBySystem
summary: System version of payout_stakers(). Only be called by the root origin.

reapStash(stash: `AccountId`, num_slashing_spans: `u32`)

interface: api.tx.staking.reapStash
summary: Remove all data structure concerning a staker/stash once its balance is at the minimum. This is essentially equivalent to withdraw_unbonded except it can be called by anyone and the target stash must have no funds left beyond the ED.

This can be called from any origin.
- stash: The stash account to reap. Its balance must be zero.

rebond(value: `Compact<BalanceOf>`)

interface: api.tx.staking.rebond
summary: Rebond a portion of the stash scheduled to be unlocked.

The dispatch origin must be signed by the controller, and it can be only called when [EraElectionStatus] is Closed.

removePermissionedValidator(identity: `IdentityId`)

interface: api.tx.staking.removePermissionedValidator
summary: Remove an identity from the pool of (wannabe) validator identities. Effects are known in the next session. Staking module checks PermissionedIdentity to ensure validators have completed KYB compliance

Arguments
- origin Required origin for removing a potential validator.
- identity Validator's IdentityId.

scaleValidatorCount(factor: `Percent`)

interface: api.tx.staking.scaleValidatorCount
summary: Scale up the ideal number of validators by a factor.

The dispatch origin must be Root.

setCommissionCap(new_cap: `Perbill`)

interface: api.tx.staking.setCommissionCap
summary: Changes commission rate which applies to all validators. Only Governance committee is allowed to change this value.

Arguments
- new_cap the new commission cap.

setController(controller: `LookupSource`)

interface: api.tx.staking.setController
summary: (Re-)set the controller of a stash.

Effects will be felt at the beginning of the next era.

The dispatch origin for this call must be Signed by the stash, not the controller.

setHistoryDepth(new_history_depth: `Compact<EraIndex>`, _era_items_deleted: `Compact<u32>`)

interface: api.tx.staking.setHistoryDepth
summary: Set HistoryDepth value. This function will delete any history information when HistoryDepth is reduced.

Parameters:
- new_history_depth: The new history depth you would like to set.
- era_items_deleted: The number of items that will be deleted by this dispatch. This should report all the storage items that will be deleted by clearing old era history. Needed to report an accurate weight for the dispatch. Trusted by Root to report an accurate number.
Origin must be root.

setInvulnerables(invulnerables: `Vec<AccountId>`)

interface: api.tx.staking.setInvulnerables
summary: Set the validators who cannot be slashed (if any).

The dispatch origin must be Root.

setMinBondThreshold(new_value: `BalanceOf`)

interface: api.tx.staking.setMinBondThreshold
summary: Changes min bond value to be used in validate(). Only Governance committee is allowed to change this value.

Arguments
- new_value the new minimum

setPayee(payee: `RewardDestination`)

interface: api.tx.staking.setPayee
summary: (Re-)set the payment target for a controller.

Effects will be felt at the beginning of the next era.

The dispatch origin for this call must be Signed by the controller, not the stash.

setValidatorCount(new: `Compact<u32>`)

interface: api.tx.staking.setValidatorCount
summary: Sets the ideal number of validators.

The dispatch origin must be Root.

submitElectionSolution(winners: `Vec<ValidatorIndex>`, compact: `CompactAssignments`, score: `ElectionScore`, era: `EraIndex`, size: `ElectionSize`)

interface: api.tx.staking.submitElectionSolution
summary: Submit an election result to the chain. If the solution:
1. is valid. 2. has a better score than a potentially existing solution on chain.
then, it will be put on chain.

A solution consists of two pieces of data:
1. winners: a flat vector of all the winners of the round. 2. assignments: the compact version of an assignment vector that encodes the edge weights.
Both of which may be computed using phragmen, or any other algorithm.

Additionally, the submitter must provide:
- The score that they claim their solution has.
Both validators and nominators will be represented by indices in the solution. The indices should respect the corresponding types ([ValidatorIndex] and [NominatorIndex]). Moreover, they should be valid when used to index into [SnapshotValidators] and [SnapshotNominators]. Any invalid index will cause the solution to be rejected. These two storage items are set during the election window and may be used to determine the indices.

A solution is valid if:
1. It is submitted when [EraElectionStatus] is Open. 1. Its claimed score is equal to the score computed on-chain. 2. Presents the correct number of winners. 3. All indexes must be value according to the snapshot vectors. All edge values must also be correct and should not overflow the granularity of the ratio type (i.e. 256 or billion). 4. For each edge, all targets are actually nominated by the voter. 5. Has correct self-votes.
A solutions score is consisted of 3 parameters:
1. min { support.total } for each support of a winner. This value should be maximized. 2. sum { support.total } for each support of a winner. This value should be minimized. 3. sum { support.total^2 } for each support of a winner. This value should be minimized (to ensure less variance)

submitElectionSolutionUnsigned(winners: `Vec<ValidatorIndex>`, compact: `CompactAssignments`, score: `ElectionScore`, era: `EraIndex`, size: `ElectionSize`)

interface: api.tx.staking.submitElectionSolutionUnsigned
summary: Unsigned version of submit_election_solution.

Note that this must pass the [ValidateUnsigned] check which only allows transactions from the local node to be included. In other words, only the block author can include a transaction in the block.

unbond(value: `Compact<BalanceOf>`)

interface: api.tx.staking.unbond
summary: Schedule a portion of the stash to be unlocked ready for transfer out after the bond period ends. If this leaves an amount actively bonded less than T::Currency::minimum_balance(), then it is increased to the full amount.

Once the unlock period is done, you can call withdraw_unbonded to actually move the funds out of management ready for transfer.

No more than a limited number of unlocking chunks (see MAX_UNLOCKING_CHUNKS) can co-exists at the same time. In that case, [Call::withdraw_unbonded] need to be called first to remove some of the chunks (if possible).

The dispatch origin for this call must be Signed by the controller, not the stash. And, it can be only called when [EraElectionStatus] is Closed.

Emits Unbonded.

See also [Call::withdraw_unbonded].

updatePermissionedValidatorIntendedCount(identity: `IdentityId`, new_intended_count: `u32`)

interface: api.tx.staking.updatePermissionedValidatorIntendedCount
summary: Update the intended validator count for a given DID.

Arguments
- origin which must be the required origin for adding a potential validator.
- identity to add as a validator.
- new_intended_count New value of intended count.

validate(prefs: `ValidatorPrefs`)

interface: api.tx.staking.validate
summary: Declare the desire to validate for the origin controller.

Effects will be felt at the beginning of the next era.

The dispatch origin for this call must be Signed by the controller, not the stash. And, it can be only called when [EraElectionStatus] is Closed.

validateCddExpiryNominators(targets: `Vec<AccountId>`)

interface: api.tx.staking.validateCddExpiryNominators
summary: Validate the nominators CDD expiry time.

If an account from a given set of address is nominating then check the CDD expiry time of it and if it is expired then the account should be unbonded and removed from the nominating process.

withdrawUnbonded(num_slashing_spans: `u32`)

interface: api.tx.staking.withdrawUnbonded
summary: Remove any unlocked chunks from the unlocking queue from our management.

This essentially frees up that balance to be used by the stash account to do whatever it wants.

The dispatch origin for this call must be Signed by the controller, not the stash. And, it can be only called when [EraElectionStatus] is Closed.

Emits Withdrawn.

See also [Call::unbond].

statistics

addExemptedEntities(ticker: `Ticker`, transfer_manager: `TransferManager`, exempted_entities: `Vec<ScopeId>`)

interface: api.tx.statistics.addExemptedEntities
summary: Exempt entities from a transfer manager

Arguments
- origin It contains the secondary key of the caller (i.e who signed the transaction to execute this function).
- ticker ticker for which the exemption list is being modified.
- transfer_manager Transfer manager for which the exemption list is being modified.
- exempted_entities ScopeIds for which the exemption list is being modified.
Errors
- Unauthorized if origin is not the owner of the ticker.
Permissions
- Asset

addTransferManager(ticker: `Ticker`, new_transfer_manager: `TransferManager`)

interface: api.tx.statistics.addTransferManager
summary: Adds a new transfer manager.

Arguments
- origin It contains the secondary key of the caller (i.e who signed the transaction to execute this function).
- ticker ticker for which the transfer managers are being updated.
- new_transfer_manager Transfer manager being added.
Errors
- Unauthorized if origin is not the owner of the ticker.
- DuplicateTransferManager if new_transfer_manager is already enabled for the ticker.
- TransferManagersLimitReached if the ticker already has max TMs attached
Permissions
- Asset

removeExemptedEntities(ticker: `Ticker`, transfer_manager: `TransferManager`, entities: `Vec<ScopeId>`)

interface: api.tx.statistics.removeExemptedEntities
summary: remove entities from exemption list of a transfer manager

Arguments
- origin It contains the secondary key of the caller (i.e who signed the transaction to execute this function).
- ticker ticker for which the exemption list is being modified.
- transfer_manager Transfer manager for which the exemption list is being modified.
- scope_ids ScopeIds for which the exemption list is being modified.
Errors
- Unauthorized if origin is not the owner of the ticker.
Permissions
- Asset

removeTransferManager(ticker: `Ticker`, transfer_manager: `TransferManager`)

interface: api.tx.statistics.removeTransferManager
summary: Removes a transfer manager.

Arguments
- origin It contains the secondary key of the caller (i.e who signed the transaction to execute this function).
- ticker ticker for which the transfer managers are being updated.
- transfer_manager Transfer manager being removed.
Errors
- Unauthorized if origin is not the owner of the ticker.
- TransferManagerMissing if asset_compliance contains multiple entries with the same requirement_id.
Permissions
- Asset

sto

createFundraiser(offering_portfolio: `PortfolioId`, offering_asset: `Ticker`, raising_portfolio: `PortfolioId`, raising_asset: `Ticker`, tiers: `Vec<PriceTier>`, venue_id: `VenueId`, start: `Option<Moment>`, end: `Option<Moment>`, minimum_investment: `Balance`, fundraiser_name: `FundraiserName`)

interface: api.tx.sto.createFundraiser
summary: Create a new fundraiser.
- offering_portfolio - Portfolio containing the offering_asset.
- offering_asset - Asset being offered.
- raising_portfolio - Portfolio containing the raising_asset.
- raising_asset - Asset being exchanged for offering_asset on investment.
- tiers - Price tiers to charge investors on investment.
- venue_id - Venue to handle settlement.
- start - Fundraiser start time, if None the fundraiser will start immediately.
- end - Fundraiser end time, if None the fundraiser will never expire.
- minimum_investment - Minimum amount of raising_asset that an investor needs to spend to invest in this raise.
- fundraiser_name - Fundraiser name, only used in the UIs.
Permissions
- Asset
- Portfolio

freezeFundraiser(offering_asset: `Ticker`, id: `FundraiserId`)

interface: api.tx.sto.freezeFundraiser
summary: Freeze a fundraiser.
- offering_asset - Asset to freeze.
- id - ID of the fundraiser to freeze.
Permissions
- Asset

invest(investment_portfolio: `PortfolioId`, funding_portfolio: `PortfolioId`, offering_asset: `Ticker`, id: `FundraiserId`, purchase_amount: `Balance`, max_price: `Option<Balance>`, receipt: `Option<ReceiptDetails>`)

interface: api.tx.sto.invest
summary: Invest in a fundraiser.
- investment_portfolio - Portfolio that offering_asset will be deposited in.
- funding_portfolio - Portfolio that will fund the investment.
- offering_asset - Asset to invest in.
- id - ID of the fundraiser to invest in.
- purchase_amount - Amount of offering_asset to purchase.
- max_price - Maximum price to pay per unit of offering_asset, If Nonethere are no constraints on price.
- receipt - Off-chain receipt to use instead of on-chain balance in funding_portfolio.
Permissions
- Portfolio

modifyFundraiserWindow(offering_asset: `Ticker`, id: `FundraiserId`, start: `Moment`, end: `Option<Moment>`)

interface: api.tx.sto.modifyFundraiserWindow
summary: Modify the time window a fundraiser is active
- offering_asset - Asset to modify.
- id - ID of the fundraiser to modify.
- start - New start of the fundraiser.
- end - New end of the fundraiser to modify.
Permissions
- Asset

stop(offering_asset: `Ticker`, id: `FundraiserId`)

interface: api.tx.sto.stop
summary: Stop a fundraiser.
- offering_asset - Asset to stop.
- id - ID of the fundraiser to stop.
Permissions
- Asset

unfreezeFundraiser(offering_asset: `Ticker`, id: `FundraiserId`)

interface: api.tx.sto.unfreezeFundraiser
summary: Unfreeze a fundraiser.
- offering_asset - Asset to unfreeze.
- id - ID of the fundraiser to unfreeze.
Permissions
- Asset

sudo

setKey(new: `LookupSource`)

interface: api.tx.sudo.setKey
summary: Authenticates the current sudo key and sets the given AccountId (new) as the new sudo key.

The dispatch origin for this call must be Signed.

sudo(call: `Call`)

interface: api.tx.sudo.sudo
summary: Authenticates the sudo key and dispatches a function call with Root origin.

The dispatch origin for this call must be Signed.

sudoAs(who: `LookupSource`, call: `Call`)

interface: api.tx.sudo.sudoAs
summary: Authenticates the sudo key and dispatches a function call with Signed origin from a given account.

The dispatch origin for this call must be Signed.

sudoUncheckedWeight(call: `Call`, _weight: `Weight`)

interface: api.tx.sudo.sudoUncheckedWeight
summary: Authenticates the sudo key and dispatches a function call with Root origin. This function does not check the weight of the call, and instead allows the Sudo user to specify the weight of the call.

The dispatch origin for this call must be Signed.

system

fillBlock(_ratio: `Perbill`)

interface: api.tx.system.fillBlock
summary: A dispatch that will fill the block weight up to the given ratio.

killPrefix(prefix: `Key`, _subkeys: `u32`)

interface: api.tx.system.killPrefix
summary: Kill all storage items with a key that starts with the given prefix.

NOTE: We rely on the Root origin to provide us the number of subkeys under the prefix we are removing to accurately calculate the weight of this function.

killStorage(keys: `Vec<Key>`)

interface: api.tx.system.killStorage
summary: Kill some items from storage.

remark(_remark: `Bytes`)

interface: api.tx.system.remark
summary: Make some on-chain remark.

setChangesTrieConfig(changes_trie_config: `Option<ChangesTrieConfiguration>`)

interface: api.tx.system.setChangesTrieConfig
summary: Set the new changes trie configuration.

setCode(code: `Bytes`)

interface: api.tx.system.setCode
summary: Set the new runtime code.

setCodeWithoutChecks(code: `Bytes`)

interface: api.tx.system.setCodeWithoutChecks
summary: Set the new runtime code without doing any checks of the given code.

setHeapPages(pages: `u64`)

interface: api.tx.system.setHeapPages
summary: Set the number of pages in the WebAssembly environment's heap.

setStorage(items: `Vec<KeyValue>`)

interface: api.tx.system.setStorage
summary: Set some items of storage.

technicalCommittee

setExpiresAfter(expiry: `MaybeBlock`)

interface: api.tx.technicalCommittee.setExpiresAfter
summary: Changes the time after which a proposal expires.

Arguments
- expiry - The new expiry time.

setReleaseCoordinator(id: `IdentityId`)

interface: api.tx.technicalCommittee.setReleaseCoordinator
summary: Changes the release coordinator.

Arguments
- id - The DID of the new release coordinator.
Errors
- NotAMember, If the new coordinator id is not part of the committee.

setVoteThreshold(n: `u32`, d: `u32`)

interface: api.tx.technicalCommittee.setVoteThreshold
summary: Change the vote threshold the determines the winning proposal. For e.g., for a simple majority use (1, 2) which represents the in-equation ">= 1/2".

Arguments
- n - Numerator of the fraction representing vote threshold.
- d - Denominator of the fraction representing vote threshold.

vote(proposal: `Hash`, index: `ProposalIndex`, approve: `bool`)

interface: api.tx.technicalCommittee.vote
summary: Votes approveingly (or not, if false) on an existing proposal given by its hash, index.

Arguments
- proposal - A hash of the proposal to be voted on.
- index - The proposal index.
- approve - If true than this is a for vote, and against otherwise.
Errors
- NotAMember, if the origin is not a member of this committee.

voteOrPropose(approve: `bool`, call: `Call`)

interface: api.tx.technicalCommittee.voteOrPropose
summary: Proposes to the committee that call should be executed in its name. Alternatively, if the hash of call has already been recorded, i.e., already proposed, then this call counts as a vote, i.e., as if vote_by_hash was called.

Weight

The weight of this dispatchable is that of call as well as the complexity for recording the vote itself.

Arguments
- approve - is this an approving vote? If the proposal doesn't exist, passing false will result in error FirstVoteReject.
- call - the call to propose for execution.
Errors
- FirstVoteReject, if call hasn't been proposed and approve == false.
- NotAMember, if the origin is not a member of this committee.

technicalCommitteeMembership

abdicateMembership()

interface: api.tx.technicalCommitteeMembership.abdicateMembership
summary: Allows the calling member to unilaterally quit without this being subject to a GC vote.

Arguments
- origin - Member of committee who wants to quit.
Error
- Only primary key can abdicate.
- Last member of a group cannot abdicate.

addMember(who: `IdentityId`)

interface: api.tx.technicalCommitteeMembership.addMember
summary: Adds a member who to the group. May only be called from AddOrigin or root.

Arguments
- origin - Origin representing AddOrigin or root
- who - IdentityId to be added to the group.

disableMember(who: `IdentityId`, expiry: `Option<Moment>`, at: `Option<Moment>`)

interface: api.tx.technicalCommitteeMembership.disableMember
summary: Disables a member at specific moment.

Please note that if member is already revoked (a "valid member"), its revocation time-stamp will be updated.

Any disabled member should NOT allow to act like an active member of the group. For instance, a disabled CDD member should NOT be able to generate a CDD claim. However any generated claim issued before at would be considered as a valid one.

If you want to invalidate any generated claim, you should use Self::remove_member.

Arguments
- at - Revocation time-stamp.
- who - Target member of the group.
- expiry - Time-stamp when who is removed from CDD. As soon as it is expired, the generated claims will be "invalid" as who is not considered a member of the group.

removeMember(who: `IdentityId`)

interface: api.tx.technicalCommitteeMembership.removeMember
summary: Removes a member who from the set. May only be called from RemoveOrigin or root.

Any claim previously generated by this member is not valid as a group claim. For instance, if a CDD member group generated a claim for a target identity and then it is removed, that claim will be invalid. In case you want to keep the validity of generated claims, you have to use Self::disable_member function

Arguments
- origin - Origin representing RemoveOrigin or root
- who - IdentityId to be removed from the group.

resetMembers(members: `Vec<IdentityId>`)

interface: api.tx.technicalCommitteeMembership.resetMembers
summary: Changes the membership to a new set, disregarding the existing membership. May only be called from ResetOrigin or root.

Arguments
- origin - Origin representing ResetOrigin or root
- members - New set of identities

setActiveMembersLimit(limit: `MemberCount`)

interface: api.tx.technicalCommitteeMembership.setActiveMembersLimit
summary: Change this group's limit for how many concurrent active members they may be.

Arguments
- limit - the number of active members there may be concurrently.

swapMember(remove: `IdentityId`, add: `IdentityId`)

interface: api.tx.technicalCommitteeMembership.swapMember
summary: Swaps out one member remove for another member add.

May only be called from SwapOrigin or root.

Arguments
- origin - Origin representing SwapOrigin or root
- remove - IdentityId to be removed from the group.
- add - IdentityId to be added in place of remove.

testUtils

getCddOf(of: `AccountId`)

interface: api.tx.testUtils.getCddOf
summary: Emits an event with caller's identity and CDD status.

getMyDid()

interface: api.tx.testUtils.getMyDid
summary: Emits an event with caller's identity.

mockCddRegisterDid(target_account: `AccountId`)

interface: api.tx.testUtils.mockCddRegisterDid
summary: Registers a new Identity for the target_account and issues a CDD claim to it. The Investor UID is generated deterministically by the hash of the generated DID and then we fix it to be compliant with UUID v4.

See
- RFC 4122: UUID
Failure
- origin has to be an active CDD provider. Inactive CDD providers cannot add new claims.
- target_account (primary key of the new Identity) can be linked to just one and only one identity.

registerDid(uid: `InvestorUid`, secondary_keys: `Vec<SecondaryKey>`)

interface: api.tx.testUtils.registerDid
summary: Generates a new IdentityID for the caller, and issues a self-generated CDD claim.

The caller account will be the primary key of that identity. For each account of secondary_keys, a new JoinIdentity authorization is created, so each of them will need to accept it before become part of this new IdentityID.

Errors
- AlreadyLinked if the caller account or if any of the given secondary_keys has already linked to an IdentityID
- SecondaryKeysContainPrimaryKey if secondary_keys contains the caller account.
- DidAlreadyExists if auto-generated DID already exists.

timestamp

set(now: `Compact<Moment>`)

interface: api.tx.timestamp.set
summary: Set the current time.

This call should be invoked exactly once per block. It will panic at the finalization phase, if this call hasn't been invoked by that time.

The timestamp should be greater than the previous one by the amount specified by MinimumPeriod.

The dispatch origin for this call must be Inherent.

treasury

disbursement(beneficiaries: `Vec<Beneficiary>`)

interface: api.tx.treasury.disbursement
summary: It transfers balances from treasury to each of beneficiaries and the specific amount for each of them.

Error
- BadOrigin: Only root can execute transaction.
- InsufficientBalance: If treasury balances is not enough to cover all beneficiaries.

reimbursement(amount: `BalanceOf`)

interface: api.tx.treasury.reimbursement
summary: It transfers the specific amount from origin account into treasury.

Only accounts which are associated to an identity can make a donation to treasury.

upgradeCommittee

setExpiresAfter(expiry: `MaybeBlock`)

interface: api.tx.upgradeCommittee.setExpiresAfter
summary: Changes the time after which a proposal expires.

Arguments
- expiry - The new expiry time.

setReleaseCoordinator(id: `IdentityId`)

interface: api.tx.upgradeCommittee.setReleaseCoordinator
summary: Changes the release coordinator.

Arguments
- id - The DID of the new release coordinator.
Errors
- NotAMember, If the new coordinator id is not part of the committee.

setVoteThreshold(n: `u32`, d: `u32`)

interface: api.tx.upgradeCommittee.setVoteThreshold
summary: Change the vote threshold the determines the winning proposal. For e.g., for a simple majority use (1, 2) which represents the in-equation ">= 1/2".

Arguments
- n - Numerator of the fraction representing vote threshold.
- d - Denominator of the fraction representing vote threshold.

vote(proposal: `Hash`, index: `ProposalIndex`, approve: `bool`)

interface: api.tx.upgradeCommittee.vote
summary: Votes approveingly (or not, if false) on an existing proposal given by its hash, index.

Arguments
- proposal - A hash of the proposal to be voted on.
- index - The proposal index.
- approve - If true than this is a for vote, and against otherwise.
Errors
- NotAMember, if the origin is not a member of this committee.

voteOrPropose(approve: `bool`, call: `Call`)

interface: api.tx.upgradeCommittee.voteOrPropose
summary: Proposes to the committee that call should be executed in its name. Alternatively, if the hash of call has already been recorded, i.e., already proposed, then this call counts as a vote, i.e., as if vote_by_hash was called.

Weight

The weight of this dispatchable is that of call as well as the complexity for recording the vote itself.

Arguments
- approve - is this an approving vote? If the proposal doesn't exist, passing false will result in error FirstVoteReject.
- call - the call to propose for execution.
Errors
- FirstVoteReject, if call hasn't been proposed and approve == false.
- NotAMember, if the origin is not a member of this committee.

upgradeCommitteeMembership

abdicateMembership()

interface: api.tx.upgradeCommitteeMembership.abdicateMembership
summary: Allows the calling member to unilaterally quit without this being subject to a GC vote.

Arguments
- origin - Member of committee who wants to quit.
Error
- Only primary key can abdicate.
- Last member of a group cannot abdicate.

addMember(who: `IdentityId`)

interface: api.tx.upgradeCommitteeMembership.addMember
summary: Adds a member who to the group. May only be called from AddOrigin or root.

Arguments
- origin - Origin representing AddOrigin or root
- who - IdentityId to be added to the group.

disableMember(who: `IdentityId`, expiry: `Option<Moment>`, at: `Option<Moment>`)

interface: api.tx.upgradeCommitteeMembership.disableMember
summary: Disables a member at specific moment.

Please note that if member is already revoked (a "valid member"), its revocation time-stamp will be updated.

Any disabled member should NOT allow to act like an active member of the group. For instance, a disabled CDD member should NOT be able to generate a CDD claim. However any generated claim issued before at would be considered as a valid one.

If you want to invalidate any generated claim, you should use Self::remove_member.

Arguments
- at - Revocation time-stamp.
- who - Target member of the group.
- expiry - Time-stamp when who is removed from CDD. As soon as it is expired, the generated claims will be "invalid" as who is not considered a member of the group.

removeMember(who: `IdentityId`)

interface: api.tx.upgradeCommitteeMembership.removeMember
summary: Removes a member who from the set. May only be called from RemoveOrigin or root.

Any claim previously generated by this member is not valid as a group claim. For instance, if a CDD member group generated a claim for a target identity and then it is removed, that claim will be invalid. In case you want to keep the validity of generated claims, you have to use Self::disable_member function

Arguments
- origin - Origin representing RemoveOrigin or root
- who - IdentityId to be removed from the group.

resetMembers(members: `Vec<IdentityId>`)

interface: api.tx.upgradeCommitteeMembership.resetMembers
summary: Changes the membership to a new set, disregarding the existing membership. May only be called from ResetOrigin or root.

Arguments
- origin - Origin representing ResetOrigin or root
- members - New set of identities

setActiveMembersLimit(limit: `MemberCount`)

interface: api.tx.upgradeCommitteeMembership.setActiveMembersLimit
summary: Change this group's limit for how many concurrent active members they may be.

Arguments
- limit - the number of active members there may be concurrently.

swapMember(remove: `IdentityId`, add: `IdentityId`)

interface: api.tx.upgradeCommitteeMembership.swapMember
summary: Swaps out one member remove for another member add.

May only be called from SwapOrigin or root.

Arguments
- origin - Origin representing SwapOrigin or root
- remove - IdentityId to be removed from the group.
- add - IdentityId to be added in place of remove.

utility

batch(calls: `Vec<Call>`)

interface: api.tx.utility.batch
summary: Dispatch multiple calls from the sender's origin.

This will execute until the first one fails and then stop.

May be called from root or a signed origin.

Parameters
- calls: The calls to be dispatched from the same origin.
Weight
- The sum of the weights of the calls.
- One event.
This will return Ok in all circumstances except an unsigned origin. To determine the success of the batch, an event is deposited. If a call failed and the batch was interrupted, then the BatchInterrupted event is deposited, along with the number of successful calls made and the error of the failed call. If all were successful, then the BatchCompleted event is deposited.

batchAtomic(calls: `Vec<Call>`)

interface: api.tx.utility.batchAtomic
summary: Dispatch multiple calls from the sender's origin.

This will execute all calls, in order, stopping at the first failure, in which case the state changes are rolled back. On failure, an event BatchInterrupted(failure_idx, error) is deposited.

May be called from root or a signed origin.

Parameters
- calls: The calls to be dispatched from the same origin.
Weight
- The sum of the weights of the calls.
- One event.
This will return Ok in all circumstances except an unsigned origin. To determine the success of the batch, an event is deposited. If any call failed, then BatchInterrupted is deposited. If all were successful, then the BatchCompleted event is deposited.

batchOptimistic(calls: `Vec<Call>`)

interface: api.tx.utility.batchOptimistic
summary: Dispatch multiple calls from the sender's origin.

This will execute all calls, in order, irrespective of failures. Any failures will be available in a BatchOptimisticFailed event.

May be called from root or a signed origin.

Parameters
- calls: The calls to be dispatched from the same origin.
Weight
- The sum of the weights of the calls.
- One event.
This will return Ok in all circumstances except an unsigned origin. To determine the success of the batch, an event is deposited. If any call failed, then BatchOptimisticFailed is deposited, with a vector of event counts for each call as well as a vector of errors. If all were successful, then the BatchCompleted event is deposited.

relayTx(target: `AccountId`, signature: `OffChainSignature`, call: `UniqueCall`)

interface: api.tx.utility.relayTx
summary: Relay a call for a target from an origin

Relaying in this context refers to the ability of origin to make a call on behalf of target.

Fees are charged to origin

Parameters
- target: Account to be relayed
- signature: Signature from target authorizing the relay
- call: Call to be relayed on behalf of target

title: Events

Events are emitted for certain operations on the runtime. The following sections describe the events that are part of the default Substrate runtime.

(NOTE: These were generated from a static/snapshot view of a recent Substrate master node. Some items may not be available in older nodes, or in any customized implementations.)

asset

AssetCreated(`IdentityId`, `Ticker`, `bool`, `AssetType`, `IdentityId`, `bool`)

interface: api.events.asset.AssetCreated.is
summary: Event for creation of the asset. caller DID/ owner DID, ticker, divisibility, asset type, beneficiary DID, disable investor uniqueness

AssetFrozen(`IdentityId`, `Ticker`)

interface: api.events.asset.AssetFrozen.is
summary: An event emitted when an asset is frozen. Parameter: caller DID, ticker.

AssetOwnershipTransferred(`IdentityId`, `Ticker`, `IdentityId`)

interface: api.events.asset.AssetOwnershipTransferred.is
summary: Emit when token ownership is transferred. caller DID / token ownership transferred to DID, ticker, from

AssetRenamed(`IdentityId`, `Ticker`, `AssetName`)

interface: api.events.asset.AssetRenamed.is
summary: An event emitted when a token is renamed. Parameters: caller DID, ticker, new token name.

AssetUnfrozen(`IdentityId`, `Ticker`)

interface: api.events.asset.AssetUnfrozen.is
summary: An event emitted when an asset is unfrozen. Parameter: caller DID, ticker.

ClassicTickerClaimed(`IdentityId`, `Ticker`, `EthereumAddress`)

interface: api.events.asset.ClassicTickerClaimed.is
summary: A Polymath Classic token was claimed and transferred to a non-systematic DID.

ControllerTransfer(`IdentityId`, `Ticker`, `PortfolioId`, `Balance`)

interface: api.events.asset.ControllerTransfer.is
summary: Event for when a forced transfer takes place. caller DID/ controller DID, ticker, Portfolio of token holder, value.

CustomAssetTypeExists(`IdentityId`, `CustomAssetTypeId`, `Bytes`)

interface: api.events.asset.CustomAssetTypeExists.is
summary: A custom asset type already exists on-chain. caller DID, the ID of the custom asset type, the string contents registered.

CustomAssetTypeRegistered(`IdentityId`, `CustomAssetTypeId`, `Bytes`)

interface: api.events.asset.CustomAssetTypeRegistered.is
summary: A custom asset type was registered on-chain. caller DID, the ID of the custom asset type, the string contents registered.

DivisibilityChanged(`IdentityId`, `Ticker`, `bool`)

interface: api.events.asset.DivisibilityChanged.is
summary: Event for change in divisibility. caller DID, ticker, divisibility

DocumentAdded(`IdentityId`, `Ticker`, `DocumentId`, `Document`)

interface: api.events.asset.DocumentAdded.is
summary: A new document attached to an asset

DocumentRemoved(`IdentityId`, `Ticker`, `DocumentId`)

interface: api.events.asset.DocumentRemoved.is
summary: A document removed from an asset

ExtensionRemoved(`IdentityId`, `Ticker`, `AccountId`)

interface: api.events.asset.ExtensionRemoved.is
summary: A extension got removed. caller DID, ticker, AccountId

FundingRoundSet(`IdentityId`, `Ticker`, `FundingRoundName`)

interface: api.events.asset.FundingRoundSet.is
summary: An event carrying the name of the current funding round of a ticker. Parameters: caller DID, ticker, funding round name.

IdentifiersUpdated(`IdentityId`, `Ticker`, `Vec<AssetIdentifier>`)

interface: api.events.asset.IdentifiersUpdated.is
summary: Event emitted when any token identifiers are updated. caller DID, ticker, a vector of (identifier type, identifier value)

IsIssuable(`Ticker`, `bool`)

interface: api.events.asset.IsIssuable.is
summary: is_issuable() output ticker, return value (true if issuable)

Issued(`IdentityId`, `Ticker`, `IdentityId`, `Balance`, `FundingRoundName`, `Balance`)

interface: api.events.asset.Issued.is
summary: Emit when tokens get issued. caller DID, ticker, beneficiary DID, value, funding round, total issued in this funding round

Redeemed(`IdentityId`, `Ticker`, `IdentityId`, `Balance`)

interface: api.events.asset.Redeemed.is
summary: Emit when tokens get redeemed. caller DID, ticker, from DID, value

TickerRegistered(`IdentityId`, `Ticker`, `Option<Moment>`)

interface: api.events.asset.TickerRegistered.is
summary: Emit when ticker is registered. caller DID / ticker owner did, ticker, ticker owner, expiry

TickerTransferred(`IdentityId`, `Ticker`, `IdentityId`)

interface: api.events.asset.TickerTransferred.is
summary: Emit when ticker is transferred. caller DID / ticker transferred to DID, ticker, from

Transfer(`IdentityId`, `Ticker`, `PortfolioId`, `PortfolioId`, `Balance`)

interface: api.events.asset.Transfer.is
summary: Event for transfer of tokens. caller DID, ticker, from portfolio, to portfolio, value

TransferWithData(`IdentityId`, `Ticker`, `IdentityId`, `IdentityId`, `Balance`, `Bytes`)

interface: api.events.asset.TransferWithData.is
summary: An additional event to Transfer; emitted when transfer_with_data is called. caller DID , ticker, from DID, to DID, value, data

balances

AccountBalanceBurned(`IdentityId`, `AccountId`, `Balance`)

interface: api.events.balances.AccountBalanceBurned.is
summary: The account and the amount of unlocked balance of that account that was burned. (caller Id, caller account, amount)

BalanceSet(`IdentityId`, `AccountId`, `Balance`, `Balance`)

interface: api.events.balances.BalanceSet.is
summary: A balance was set by root (did, who, free, reserved).

Endowed(`Option<IdentityId>`, `AccountId`, `Balance`)

interface: api.events.balances.Endowed.is
summary: An account was created with some free balance. [did, account, free_balance]

Reserved(`AccountId`, `Balance`)

interface: api.events.balances.Reserved.is
summary: Some balance was reserved (moved from free to reserved). [who, value]

ReserveRepatriated(`AccountId`, `AccountId`, `Balance`, `BalanceStatus`)

interface: api.events.balances.ReserveRepatriated.is
summary: Some balance was moved from the reserve of the first account to the second account. Final argument indicates the destination balance type. [from, to, balance, destination_status]

Transfer(`Option<IdentityId>`, `AccountId`, `Option<IdentityId>`, `AccountId`, `Balance`, `Option<Memo>`)

interface: api.events.balances.Transfer.is
summary: Transfer succeeded (from_did, from, to_did, to, value, memo).

Unreserved(`AccountId`, `Balance`)

interface: api.events.balances.Unreserved.is
summary: Some balance was unreserved (moved from reserved to free). [who, value]

base

UnexpectedError(`Option<DispatchError>`)

interface: api.events.base.UnexpectedError.is
summary: An unexpected error happened that should be investigated.

bridge

AdminChanged(`IdentityId`, `AccountId`)

interface: api.events.bridge.AdminChanged.is
summary: Confirmation of Admin change.

Bridged(`IdentityId`, `BridgeTx`)

interface: api.events.bridge.Bridged.is
summary: Confirmation of POLYX upgrade on Polymesh from POLY tokens on Ethereum.

BridgeLimitUpdated(`IdentityId`, `Balance`, `BlockNumber`)

interface: api.events.bridge.BridgeLimitUpdated.is
summary: Bridge limit has been updated.

BridgeTxScheduled(`IdentityId`, `BridgeTx`, `BlockNumber`)

interface: api.events.bridge.BridgeTxScheduled.is
summary: Bridge Tx Scheduled.

BridgeTxScheduleFailed(`IdentityId`, `BridgeTx`, `Bytes`)

interface: api.events.bridge.BridgeTxScheduleFailed.is
summary: Failed to schedule Bridge Tx.

ControllerChanged(`IdentityId`, `AccountId`)

interface: api.events.bridge.ControllerChanged.is
summary: Confirmation of a signer set change.

ExemptedUpdated(`IdentityId`, `IdentityId`, `bool`)

interface: api.events.bridge.ExemptedUpdated.is
summary: Exemption status of an identity has been updated.

FreezeAdminAdded(`IdentityId`, `AccountId`)

interface: api.events.bridge.FreezeAdminAdded.is
summary: A new freeze admin has been added.

FreezeAdminRemoved(`IdentityId`, `AccountId`)

interface: api.events.bridge.FreezeAdminRemoved.is
summary: A freeze admin has been removed.

Frozen(`IdentityId`)

interface: api.events.bridge.Frozen.is
summary: Notification of freezing the bridge.

FrozenTx(`IdentityId`, `BridgeTx`)

interface: api.events.bridge.FrozenTx.is
summary: Notification of freezing a transaction.

TimelockChanged(`IdentityId`, `BlockNumber`)

interface: api.events.bridge.TimelockChanged.is
summary: Confirmation of default timelock change.

TxRemoved(`IdentityId`, `BridgeTx`)

interface: api.events.bridge.TxRemoved.is
summary: Notification of removing a transaction.

TxsHandled(`Vec<(AccountId,u32,HandledTxStatus)>`)

interface: api.events.bridge.TxsHandled.is
summary: An event emitted after a vector of transactions is handled. The parameter is a vector of tuples of recipient account, its nonce, and the status of the processed transaction.

Unfrozen(`IdentityId`)

interface: api.events.bridge.Unfrozen.is
summary: Notification of unfreezing the bridge.

UnfrozenTx(`IdentityId`, `BridgeTx`)

interface: api.events.bridge.UnfrozenTx.is
summary: Notification of unfreezing a transaction.

capitalDistribution

BenefitClaimed(`EventDid`, `EventDid`, `CAId`, `Distribution`, `Balance`, `Tax`)

interface: api.events.capitalDistribution.BenefitClaimed.is
summary: A token holder's benefit of a capital distribution for the given CAId was claimed.

(Caller DID, Holder/Claimant DID, CA's ID, updated distribution details, DID's benefit, DID's tax %)

Created(`EventDid`, `CAId`, `Distribution`)

interface: api.events.capitalDistribution.Created.is
summary: A capital distribution, with details included, was created by the DID (permissioned agent) for the CA identified by CAId.

(Agent DID, CA's ID, distribution details)

Reclaimed(`EventDid`, `CAId`, `Balance`)

interface: api.events.capitalDistribution.Reclaimed.is
summary: Stats from push_benefit was emitted.

(Agent DID, CA's ID, max requested DIDs, processed DIDs, failed DIDs)

Removed(`EventDid`, `CAId`)

interface: api.events.capitalDistribution.Removed.is
summary: A capital distribution was removed.

(Agent DID, CA's ID)

cddServiceProviders

ActiveLimitChanged(`IdentityId`, `MemberCount`, `MemberCount`)

interface: api.events.cddServiceProviders.ActiveLimitChanged.is
summary: The limit of how many active members there can be concurrently was changed.

Dummy(`PhantomData`)

interface: api.events.cddServiceProviders.Dummy.is
summary: Phantom member, never used.

MemberAdded(`IdentityId`, `IdentityId`)

interface: api.events.cddServiceProviders.MemberAdded.is
summary: The given member was added; see the transaction for who. caller DID, New member DID.

MemberRemoved(`IdentityId`, `IdentityId`)

interface: api.events.cddServiceProviders.MemberRemoved.is
summary: The given member was removed; see the transaction for who. caller DID, member DID that get removed.

MemberRevoked(`IdentityId`, `IdentityId`)

interface: api.events.cddServiceProviders.MemberRevoked.is
summary: The given member has been revoked at specific time-stamp. caller DID, member DID that get revoked.

MembersReset(`IdentityId`, `Vec<IdentityId>`)

interface: api.events.cddServiceProviders.MembersReset.is
summary: The membership was reset; see the transaction for who the new set is. caller DID, List of new members.

MembersSwapped(`IdentityId`, `IdentityId`, `IdentityId`)

interface: api.events.cddServiceProviders.MembersSwapped.is
summary: Two members were swapped; see the transaction for who. caller DID, Removed DID, New add DID.

checkpoint

CheckpointCreated(`Option<EventDid>`, `Ticker`, `CheckpointId`, `Balance`, `Moment`)

interface: api.events.checkpoint.CheckpointCreated.is
summary: A checkpoint was created.

(caller DID, ticker, checkpoint ID, total supply, checkpoint timestamp)

MaximumSchedulesComplexityChanged(`IdentityId`, `u64`)

interface: api.events.checkpoint.MaximumSchedulesComplexityChanged.is
summary: The maximum complexity for an arbitrary ticker's schedule set was changed.

(GC DID, the new maximum)

ScheduleCreated(`EventDid`, `Ticker`, `StoredSchedule`)

interface: api.events.checkpoint.ScheduleCreated.is
summary: A checkpoint schedule was created.

(caller DID, ticker, schedule)

ScheduleRemoved(`IdentityId`, `Ticker`, `StoredSchedule`)

interface: api.events.checkpoint.ScheduleRemoved.is
summary: A checkpoint schedule was removed.

(caller DID, ticker, schedule)

committeeMembership

ActiveLimitChanged(`IdentityId`, `MemberCount`, `MemberCount`)

interface: api.events.committeeMembership.ActiveLimitChanged.is
summary: The limit of how many active members there can be concurrently was changed.

Dummy(`PhantomData`)

interface: api.events.committeeMembership.Dummy.is
summary: Phantom member, never used.

MemberAdded(`IdentityId`, `IdentityId`)

interface: api.events.committeeMembership.MemberAdded.is
summary: The given member was added; see the transaction for who. caller DID, New member DID.

MemberRemoved(`IdentityId`, `IdentityId`)

interface: api.events.committeeMembership.MemberRemoved.is
summary: The given member was removed; see the transaction for who. caller DID, member DID that get removed.

MemberRevoked(`IdentityId`, `IdentityId`)

interface: api.events.committeeMembership.MemberRevoked.is
summary: The given member has been revoked at specific time-stamp. caller DID, member DID that get revoked.

MembersReset(`IdentityId`, `Vec<IdentityId>`)

interface: api.events.committeeMembership.MembersReset.is
summary: The membership was reset; see the transaction for who the new set is. caller DID, List of new members.

MembersSwapped(`IdentityId`, `IdentityId`, `IdentityId`)

interface: api.events.committeeMembership.MembersSwapped.is
summary: Two members were swapped; see the transaction for who. caller DID, Removed DID, New add DID.

complianceManager

AssetCompliancePaused(`IdentityId`, `Ticker`)

interface: api.events.complianceManager.AssetCompliancePaused.is
summary: Emitted when an asset compliance for a given ticker gets paused. (caller DID, Ticker).

AssetComplianceReplaced(`IdentityId`, `Ticker`, `Vec<ComplianceRequirement>`)

interface: api.events.complianceManager.AssetComplianceReplaced.is
summary: Emitted when an asset compliance is replaced. Parameters: caller DID, ticker, new asset compliance.

AssetComplianceReset(`IdentityId`, `Ticker`)

interface: api.events.complianceManager.AssetComplianceReset.is
summary: Emitted when an asset compliance of a ticker is reset. (caller DID, Ticker).

AssetComplianceResumed(`IdentityId`, `Ticker`)

interface: api.events.complianceManager.AssetComplianceResumed.is
summary: Emitted when an asset compliance for a given ticker gets resume. (caller DID, Ticker).

ComplianceRequirementChanged(`IdentityId`, `Ticker`, `ComplianceRequirement`)

interface: api.events.complianceManager.ComplianceRequirementChanged.is
summary: Emitted when compliance requirement get modified/change. (caller DID, Ticker, ComplianceRequirement).

ComplianceRequirementCreated(`IdentityId`, `Ticker`, `ComplianceRequirement`)

interface: api.events.complianceManager.ComplianceRequirementCreated.is
summary: Emitted when new compliance requirement is created. (caller DID, Ticker, ComplianceRequirement).

ComplianceRequirementRemoved(`IdentityId`, `Ticker`, `u32`)

interface: api.events.complianceManager.ComplianceRequirementRemoved.is
summary: Emitted when a compliance requirement is removed. (caller DID, Ticker, requirement_id).

TrustedDefaultClaimIssuerAdded(`IdentityId`, `Ticker`, `TrustedIssuer`)

interface: api.events.complianceManager.TrustedDefaultClaimIssuerAdded.is
summary: Emitted when default claim issuer list for a given ticker gets added. (caller DID, Ticker, Added TrustedIssuer).

TrustedDefaultClaimIssuerRemoved(`IdentityId`, `Ticker`, `IdentityId`)

interface: api.events.complianceManager.TrustedDefaultClaimIssuerRemoved.is
summary: Emitted when default claim issuer list for a given ticker get removed. (caller DID, Ticker, Removed TrustedIssuer).

corporateAction

CAATransferred(`IdentityId`, `Ticker`, `IdentityId`)

interface: api.events.corporateAction.CAATransferred.is
summary: A new DID was made the CAA. (New CAA DID, Ticker, New CAA DID).

CAInitiated(`EventDid`, `CAId`, `CorporateAction`, `CADetails`)

interface: api.events.corporateAction.CAInitiated.is
summary: A CA was initiated. (Agent DID, CA id, the CA, the CA details)

CALinkedToDoc(`IdentityId`, `CAId`, `Vec<DocumentId>`)

interface: api.events.corporateAction.CALinkedToDoc.is
summary: A CA was linked to a set of docs. (Agent DID, CA Id, List of doc identifiers)

CARemoved(`EventDid`, `CAId`)

interface: api.events.corporateAction.CARemoved.is
summary: A CA was removed. (Agent DID, CA Id)

DefaultTargetIdentitiesChanged(`IdentityId`, `Ticker`, `TargetIdentities`)

interface: api.events.corporateAction.DefaultTargetIdentitiesChanged.is
summary: The set of default TargetIdentities for a ticker changed. (Agent DID, Ticker, New TargetIdentities)

DefaultWithholdingTaxChanged(`IdentityId`, `Ticker`, `Tax`)

interface: api.events.corporateAction.DefaultWithholdingTaxChanged.is
summary: The default withholding tax for a ticker changed. (Agent DID, Ticker, New Tax).

DidWithholdingTaxChanged(`IdentityId`, `Ticker`, `IdentityId`, `Option<Tax>`)

interface: api.events.corporateAction.DidWithholdingTaxChanged.is
summary: The withholding tax specific to a DID for a ticker changed. (Agent DID, Ticker, Taxed DID, New Tax).

MaxDetailsLengthChanged(`IdentityId`, `u32`)

interface: api.events.corporateAction.MaxDetailsLengthChanged.is
summary: The maximum length of details in bytes was changed. (GC DID, new length)

RecordDateChanged(`EventDid`, `CAId`, `CorporateAction`)

interface: api.events.corporateAction.RecordDateChanged.is
summary: A CA's record date changed.

corporateBallot

Created(`IdentityId`, `CAId`, `BallotTimeRange`, `BallotMeta`, `bool`)

interface: api.events.corporateBallot.Created.is
summary: A corporate ballot was created.

(Agent DID, CA's ID, Voting start/end, Ballot metadata, RCV enabled?)

MetaChanged(`IdentityId`, `CAId`, `BallotMeta`)

interface: api.events.corporateBallot.MetaChanged.is
summary: A corporate ballot changed its metadata.

(Agent DID, CA's ID, New metadata)

RangeChanged(`IdentityId`, `CAId`, `BallotTimeRange`)

interface: api.events.corporateBallot.RangeChanged.is
summary: A corporate ballot changed its start/end date range.

(Agent DID, CA's ID, Voting start/end)

RCVChanged(`IdentityId`, `CAId`, `bool`)

interface: api.events.corporateBallot.RCVChanged.is
summary: A corporate ballot changed its RCV support.

(Agent DID, CA's ID, New support)

Removed(`EventDid`, `CAId`)

interface: api.events.corporateBallot.Removed.is
summary: A corporate ballot was removed.

(Agent DID, CA's ID)

VoteCast(`IdentityId`, `CAId`, `Vec<BallotVote>`)

interface: api.events.corporateBallot.VoteCast.is
summary: A vote was cast in a corporate ballot.

(voter DID, CAId, Votes)

externalAgents

AgentAdded(`EventDid`, `Ticker`, `AgentGroup`)

interface: api.events.externalAgents.AgentAdded.is
summary: An agent was added.

(Caller/Agent DID, Agent's ticker, Agent's group)

AgentRemoved(`EventDid`, `Ticker`, `IdentityId`)

interface: api.events.externalAgents.AgentRemoved.is
summary: An agent was removed.

(Caller DID, Agent's ticker, Agent's DID)

GroupChanged(`EventDid`, `Ticker`, `IdentityId`, `AgentGroup`)

interface: api.events.externalAgents.GroupChanged.is
summary: An agent's group was changed.

(Caller DID, Agent's ticker, Agent's DID, The new group of the agent)

GroupCreated(`EventDid`, `Ticker`, `AGId`, `ExtrinsicPermissions`)

interface: api.events.externalAgents.GroupCreated.is
summary: An Agent Group was created.

(Caller DID, AG's ticker, AG's ID, AG's permissions)

GroupPermissionsUpdated(`EventDid`, `Ticker`, `AGId`, `ExtrinsicPermissions`)

interface: api.events.externalAgents.GroupPermissionsUpdated.is
summary: An Agent Group's permissions was updated.

(Caller DID, AG's ticker, AG's ID, AG's new permissions)

grandpa

NewAuthorities(`AuthorityList`)

interface: api.events.grandpa.NewAuthorities.is
summary: New authority set has been applied. [authority_set]

Paused()

interface: api.events.grandpa.Paused.is
summary: Current authority set has been paused.

Resumed()

interface: api.events.grandpa.Resumed.is
summary: Current authority set has been resumed.

identity

AssetDidRegistered(`IdentityId`, `Ticker`)

interface: api.events.identity.AssetDidRegistered.is
summary: Asset DID

AuthorizationAdded(`IdentityId`, `Option<IdentityId>`, `Option<AccountId>`, `u64`, `AuthorizationData`, `Option<Moment>`)

interface: api.events.identity.AuthorizationAdded.is
summary: New authorization added. (authorised_by, target_did, target_key, auth_id, authorization_data, expiry)

AuthorizationConsumed(`Option<IdentityId>`, `Option<AccountId>`, `u64`)

interface: api.events.identity.AuthorizationConsumed.is
summary: Authorization consumed. (authorized_identity, authorized_key, auth_id)

AuthorizationRejected(`Option<IdentityId>`, `Option<AccountId>`, `u64`)

interface: api.events.identity.AuthorizationRejected.is
summary: Authorization rejected by the user who was authorized. (authorized_identity, authorized_key, auth_id)

AuthorizationRevoked(`Option<IdentityId>`, `Option<AccountId>`, `u64`)

interface: api.events.identity.AuthorizationRevoked.is
summary: Authorization revoked by the authorizer. (authorized_identity, authorized_key, auth_id)

CddClaimsInvalidated(`IdentityId`, `Moment`)

interface: api.events.identity.CddClaimsInvalidated.is
summary: CDD claims generated by IdentityId (a CDD Provider) have been invalidated from Moment.

CddRequirementForPrimaryKeyUpdated(`bool`)

interface: api.events.identity.CddRequirementForPrimaryKeyUpdated.is
summary: CDD requirement for updating primary key changed. (new_requirement)

ClaimAdded(`IdentityId`, `IdentityClaim`)

interface: api.events.identity.ClaimAdded.is
summary: DID, claims

ClaimRevoked(`IdentityId`, `IdentityClaim`)

interface: api.events.identity.ClaimRevoked.is
summary: DID, ClaimType, Claim Issuer

DidCreated(`IdentityId`, `AccountId`, `Vec<SecondaryKey>`)

interface: api.events.identity.DidCreated.is
summary: DID, primary key account ID, secondary keys

MockInvestorUIDCreated(`IdentityId`, `InvestorUid`)

interface: api.events.identity.MockInvestorUIDCreated.is
summary: Mocked InvestorUid created.

OffChainAuthorizationRevoked(`IdentityId`, `Signatory`)

interface: api.events.identity.OffChainAuthorizationRevoked.is
summary: Off-chain Authorization has been revoked. (Target Identity, Signatory)

PrimaryKeyUpdated(`IdentityId`, `AccountId`, `AccountId`)

interface: api.events.identity.PrimaryKeyUpdated.is
summary: DID, old primary key account ID, new ID

SecondaryKeyPermissionsUpdated(`IdentityId`, `SecondaryKey`, `Permissions`, `Permissions`)

interface: api.events.identity.SecondaryKeyPermissionsUpdated.is
summary: DID, updated secondary key, previous permissions, new permissions

SecondaryKeysAdded(`IdentityId`, `Vec<SecondaryKey>`)

interface: api.events.identity.SecondaryKeysAdded.is
summary: DID, new keys

SecondaryKeysFrozen(`IdentityId`)

interface: api.events.identity.SecondaryKeysFrozen.is
summary: All Secondary keys of the identity ID are frozen.

SecondaryKeysRemoved(`IdentityId`, `Vec<Signatory>`)

interface: api.events.identity.SecondaryKeysRemoved.is
summary: DID, the keys that got removed

SecondaryKeysUnfrozen(`IdentityId`)

interface: api.events.identity.SecondaryKeysUnfrozen.is
summary: All Secondary keys of the identity ID are unfrozen.

SignerLeft(`IdentityId`, `Signatory`)

interface: api.events.identity.SignerLeft.is
summary: A signer left their identity. (did, signer)

imOnline

AllGood()

interface: api.events.imOnline.AllGood.is
summary: At the end of the session, no offence was committed.

HeartbeatReceived(`AuthorityId`)

interface: api.events.imOnline.HeartbeatReceived.is
summary: A new heartbeat was received from AuthorityId [authority_id]

SomeOffline(`Vec<IdentificationTuple>`)

interface: api.events.imOnline.SomeOffline.is
summary: At the end of the session, at least one validator was found to be [offline].

indices

IndexAssigned(`AccountId`, `AccountIndex`)

interface: api.events.indices.IndexAssigned.is
summary: A account index was assigned. [index, who]

IndexFreed(`AccountIndex`)

interface: api.events.indices.IndexFreed.is
summary: A account index has been freed up (unassigned). [index]

IndexFrozen(`AccountIndex`, `AccountId`)

interface: api.events.indices.IndexFrozen.is
summary: A account index has been frozen to its current account ID. [index, who]

multiSig

MultiSigCreated(`IdentityId`, `AccountId`, `AccountId`, `Vec<Signatory>`, `u64`)

interface: api.events.multiSig.MultiSigCreated.is
summary: Event emitted after creation of a multisig. Arguments: caller DID, multisig address, signers (pending approval), signatures required.

MultiSigSignaturesRequiredChanged(`IdentityId`, `AccountId`, `u64`)

interface: api.events.multiSig.MultiSigSignaturesRequiredChanged.is
summary: Event emitted when the number of required signatures is changed. Arguments: caller DID, multisig, new required signatures.

MultiSigSignerAdded(`IdentityId`, `AccountId`, `Signatory`)

interface: api.events.multiSig.MultiSigSignerAdded.is
summary: Event emitted when a signatory is added. Arguments: caller DID, multisig, added signer.

MultiSigSignerAuthorized(`IdentityId`, `AccountId`, `Signatory`)

interface: api.events.multiSig.MultiSigSignerAuthorized.is
summary: Event emitted when a multisig signatory is authorized to be added. Arguments: caller DID, multisig, authorized signer.

MultiSigSignerRemoved(`IdentityId`, `AccountId`, `Signatory`)

interface: api.events.multiSig.MultiSigSignerRemoved.is
summary: Event emitted when a multisig signatory is removed. Arguments: caller DID, multisig, removed signer.

ProposalAdded(`IdentityId`, `AccountId`, `u64`)

interface: api.events.multiSig.ProposalAdded.is
summary: Event emitted after adding a proposal. Arguments: caller DID, multisig, proposal ID.

ProposalApproved(`IdentityId`, `AccountId`, `Signatory`, `u64`)

interface: api.events.multiSig.ProposalApproved.is
summary: Event emitted when the proposal get approved. Arguments: caller DID, multisig, authorized signer, proposal id.

ProposalExecuted(`IdentityId`, `AccountId`, `u64`, `bool`)

interface: api.events.multiSig.ProposalExecuted.is
summary: Event emitted when a proposal is executed. Arguments: caller DID, multisig, proposal ID, result.

ProposalExecutionFailed(`DispatchError`)

interface: api.events.multiSig.ProposalExecutionFailed.is
summary: Event emitted when there's an error in proposal execution

ProposalRejected(`IdentityId`, `AccountId`, `u64`)

interface: api.events.multiSig.ProposalRejected.is
summary: Event emitted when a proposal is rejected. Arguments: caller DID, multisig, proposal ID.

ProposalRejectionVote(`IdentityId`, `AccountId`, `Signatory`, `u64`)

interface: api.events.multiSig.ProposalRejectionVote.is
summary: Event emitted when a vote is cast in favor of rejecting a proposal. Arguments: caller DID, multisig, authorized signer, proposal id.

SchedulingFailed(`DispatchError`)

interface: api.events.multiSig.SchedulingFailed.is
summary: Scheduling of proposal fails.

offences

Offence(`Kind`, `OpaqueTimeSlot`, `bool`)

interface: api.events.offences.Offence.is
summary: There is an offence reported of the given kind happened at the session_index and (kind-specific) time slot. This event is not deposited for duplicate slashes. last element indicates of the offence was applied (true) or queued (false) [kind, timeslot, applied].

pips

ActivePipLimitChanged(`IdentityId`, `u32`, `u32`)

interface: api.events.pips.ActivePipLimitChanged.is
summary: The maximum number of active PIPs was changed. (caller DID, old value, new value)

DefaultEnactmentPeriodChanged(`IdentityId`, `BlockNumber`, `BlockNumber`)

interface: api.events.pips.DefaultEnactmentPeriodChanged.is
summary: Default enactment period (in blocks) has been changed. (caller DID, old period, new period)

ExecutionCancellingFailed(`PipId`)

interface: api.events.pips.ExecutionCancellingFailed.is
summary: Cancelling the PIP execution failed in the scheduler pallet.

ExecutionScheduled(`IdentityId`, `PipId`, `BlockNumber`)

interface: api.events.pips.ExecutionScheduled.is
summary: Execution of a PIP has been scheduled at specific block.

ExecutionSchedulingFailed(`IdentityId`, `PipId`, `BlockNumber`)

interface: api.events.pips.ExecutionSchedulingFailed.is
summary: Scheduling of the PIP for execution failed in the scheduler pallet.

ExpiryScheduled(`IdentityId`, `PipId`, `BlockNumber`)

interface: api.events.pips.ExpiryScheduled.is
summary: The PIP has been scheduled for expiry.

ExpirySchedulingFailed(`IdentityId`, `PipId`, `BlockNumber`)

interface: api.events.pips.ExpirySchedulingFailed.is
summary: Scheduling of the PIP for expiry failed in the scheduler pallet.

HistoricalPipsPruned(`IdentityId`, `bool`, `bool`)

interface: api.events.pips.HistoricalPipsPruned.is
summary: Pruning Historical PIPs is enabled or disabled (caller DID, old value, new value)

MaxPipSkipCountChanged(`IdentityId`, `SkippedCount`, `SkippedCount`)

interface: api.events.pips.MaxPipSkipCountChanged.is
summary: The maximum times a PIP can be skipped was changed. (caller DID, old value, new value)

MinimumProposalDepositChanged(`IdentityId`, `Balance`, `Balance`)

interface: api.events.pips.MinimumProposalDepositChanged.is
summary: Minimum deposit amount modified (caller DID, old amount, new amount)

PendingPipExpiryChanged(`IdentityId`, `MaybeBlock`, `MaybeBlock`)

interface: api.events.pips.PendingPipExpiryChanged.is
summary: Amount of blocks after which a pending PIP expires. (caller DID, old expiry, new expiry)

PipClosed(`IdentityId`, `PipId`, `bool`)

interface: api.events.pips.PipClosed.is
summary: Pip has been closed, bool indicates whether data is pruned

PipSkipped(`IdentityId`, `PipId`, `SkippedCount`)

interface: api.events.pips.PipSkipped.is
summary: A PIP in the snapshot queue was skipped. (gc_did, pip_id, new_skip_count)

ProposalCreated(`IdentityId`, `Proposer`, `PipId`, `Balance`, `Option<Url>`, `Option<PipDescription>`, `MaybeBlock`, `ProposalData`)

interface: api.events.pips.ProposalCreated.is
summary: A PIP was made with a Balance stake.

Parameters:

Caller DID, Proposer, PIP ID, deposit, URL, description, expiry time, proposal data.

ProposalRefund(`IdentityId`, `PipId`, `Balance`)

interface: api.events.pips.ProposalRefund.is
summary: Refund proposal (id, total amount)

ProposalStateUpdated(`IdentityId`, `PipId`, `ProposalState`)

interface: api.events.pips.ProposalStateUpdated.is
summary: Triggered each time the state of a proposal is amended

SnapshotCleared(`IdentityId`, `SnapshotId`)

interface: api.events.pips.SnapshotCleared.is
summary: The snapshot was cleared.

SnapshotResultsEnacted(`IdentityId`, `Option<SnapshotId>`, `Vec<(PipId,SkippedCount)>`, `Vec<PipId>`, `Vec<PipId>`)

interface: api.events.pips.SnapshotResultsEnacted.is
summary: Results (e.g., approved, rejected, and skipped), were enacted for some PIPs. (gc_did, snapshot_id_opt, skipped_pips_with_new_count, rejected_pips, approved_pips)

SnapshotTaken(`IdentityId`, `SnapshotId`, `Vec<SnapshottedPip>`)

interface: api.events.pips.SnapshotTaken.is
summary: A new snapshot was taken.

Voted(`IdentityId`, `AccountId`, `PipId`, `bool`, `Balance`)

interface: api.events.pips.Voted.is
summary: AccountId voted bool on the proposal referenced by PipId

polymeshCommittee

Approved(`IdentityId`, `Hash`, `MemberCount`, `MemberCount`, `MemberCount`)

interface: api.events.polymeshCommittee.Approved.is
summary: A motion was approved by the required threshold with the following tally (yes votes, no votes and total seats given respectively as MemberCount). Parameters: caller DID, proposal hash, yay vote count, nay vote count, total seats.

Executed(`IdentityId`, `Hash`, `DispatchResult`)

interface: api.events.polymeshCommittee.Executed.is
summary: A motion was executed; DispatchResult is Ok(()) if returned without error. Parameters: caller DID, proposal hash, result of proposal dispatch.

ExpiresAfterUpdated(`IdentityId`, `MaybeBlock`)

interface: api.events.polymeshCommittee.ExpiresAfterUpdated.is
summary: Proposal expiry time has been updated. Parameters: caller DID, new expiry time (if any).

FinalVotes(`IdentityId`, `ProposalIndex`, `Hash`, `Vec<IdentityId>`, `Vec<IdentityId>`)

interface: api.events.polymeshCommittee.FinalVotes.is
summary: Final votes on a motion (given hash) caller DID, ProposalIndex, Proposal hash, yes voters, no voter

Proposed(`IdentityId`, `ProposalIndex`, `Hash`)

interface: api.events.polymeshCommittee.Proposed.is
summary: A motion (given hash) has been proposed (by given account) with a threshold (given MemberCount). Parameters: caller DID, proposal index, proposal hash.

Rejected(`IdentityId`, `Hash`, `MemberCount`, `MemberCount`, `MemberCount`)

interface: api.events.polymeshCommittee.Rejected.is
summary: A motion was rejected by the required threshold with the following tally (yes votes, no votes and total seats given respectively as MemberCount). Parameters: caller DID, proposal hash, yay vote count, nay vote count, total seats.

ReleaseCoordinatorUpdated(`IdentityId`, `Option<IdentityId>`)

interface: api.events.polymeshCommittee.ReleaseCoordinatorUpdated.is
summary: Release coordinator has been updated. Parameters: caller DID, DID of the release coordinator.

Voted(`IdentityId`, `ProposalIndex`, `Hash`, `bool`, `MemberCount`, `MemberCount`, `MemberCount`)

interface: api.events.polymeshCommittee.Voted.is
summary: A motion (given hash) has been voted on by given account, leaving a tally (yes votes, no votes and total seats given respectively as MemberCount). caller DID, Proposal index, Proposal hash, current vote, yay vote count, nay vote count, total seats.

VoteRetracted(`IdentityId`, `ProposalIndex`, `Hash`, `bool`)

interface: api.events.polymeshCommittee.VoteRetracted.is
summary: A vote on a motion (given hash) has been retracted. caller DID, ProposalIndex, Proposal hash, vote that was retracted

VoteThresholdUpdated(`IdentityId`, `u32`, `u32`)

interface: api.events.polymeshCommittee.VoteThresholdUpdated.is
summary: Voting threshold has been updated Parameters: caller DID, numerator, denominator

portfolio

MovedBetweenPortfolios(`IdentityId`, `PortfolioId`, `PortfolioId`, `Ticker`, `Balance`, `Option<Memo>`)

interface: api.events.portfolio.MovedBetweenPortfolios.is
summary: A token amount has been moved from one portfolio to another.

Parameters
- origin DID
- source portfolio
- destination portfolio
- asset ticker
- asset balance that was moved

PortfolioCreated(`IdentityId`, `PortfolioNumber`, `PortfolioName`)

interface: api.events.portfolio.PortfolioCreated.is
summary: The portfolio has been successfully created.

Parameters
- origin DID
- portfolio number
- portfolio name

PortfolioCustodianChanged(`IdentityId`, `PortfolioId`, `IdentityId`)

interface: api.events.portfolio.PortfolioCustodianChanged.is
summary: Custody of a portfolio has been given to a different identity

Parameters
- origin DID
- portfolio id
- portfolio custodian did

PortfolioDeleted(`IdentityId`, `PortfolioNumber`)

interface: api.events.portfolio.PortfolioDeleted.is
summary: The portfolio has been successfully removed.

Parameters
- origin DID
- portfolio number

PortfolioRenamed(`IdentityId`, `PortfolioNumber`, `PortfolioName`)

interface: api.events.portfolio.PortfolioRenamed.is
summary: The portfolio identified with num has been renamed to name.

Parameters
- origin DID
- portfolio number
- portfolio name

UserPortfolios(`IdentityId`, `Vec<(PortfolioNumber,PortfolioName)>`)

interface: api.events.portfolio.UserPortfolios.is
summary: All non-default portfolio numbers and names of a DID.

Parameters
- origin DID
- vector of number-name pairs

protocolFee

CoefficientSet(`IdentityId`, `PosRatio`)

interface: api.events.protocolFee.CoefficientSet.is
summary: The fee coefficient.

FeeCharged(`AccountId`, `Balance`)

interface: api.events.protocolFee.FeeCharged.is
summary: Fee charged.

FeeSet(`IdentityId`, `Balance`)

interface: api.events.protocolFee.FeeSet.is
summary: The protocol fee of an operation.

relayer

AcceptedPayingKey(`EventDid`, `AccountId`, `AccountId`)

interface: api.events.relayer.AcceptedPayingKey.is
summary: Accepted paying key.

(Caller DID, User Key, Paying Key)

AuthorizedPayingKey(`EventDid`, `AccountId`, `AccountId`, `Balance`, `u64`)

interface: api.events.relayer.AuthorizedPayingKey.is
summary: Authorization given for paying_key to user_key.

(Caller DID, User Key, Paying Key, Initial POLYX limit, Auth ID)

RemovedPayingKey(`EventDid`, `AccountId`, `AccountId`)

interface: api.events.relayer.RemovedPayingKey.is
summary: Removed paying key.

(Caller DID, User Key, Paying Key)

UpdatedPolyxLimit(`EventDid`, `AccountId`, `AccountId`, `Balance`, `Balance`)

interface: api.events.relayer.UpdatedPolyxLimit.is
summary: Updated polyx limit.

(Caller DID, User Key, Paying Key, POLYX limit, old remaining POLYX)

rewards

ItnRewardClaimed(`AccountId`, `Balance`)

interface: api.events.rewards.ItnRewardClaimed.is
summary: Itn reward was claimed.

scheduler

Canceled(`BlockNumber`, `u32`)

interface: api.events.scheduler.Canceled.is
summary: Canceled some task. [when, index]

Dispatched(`TaskAddress`, `Option<Bytes>`, `DispatchResult`)

interface: api.events.scheduler.Dispatched.is
summary: Dispatched some task. [task, id, result]

Scheduled(`BlockNumber`, `u32`)

interface: api.events.scheduler.Scheduled.is
summary: Scheduled some task. [when, index]

session

NewSession(`SessionIndex`)

interface: api.events.session.NewSession.is
summary: New session has happened. Note that the argument is the [session_index], not the block number as the type might suggest.

settlement

AffirmationWithdrawn(`IdentityId`, `PortfolioId`, `InstructionId`)

interface: api.events.settlement.AffirmationWithdrawn.is
summary: An affirmation has been withdrawn (did, portfolio, instruction_id)

InstructionAffirmed(`IdentityId`, `PortfolioId`, `InstructionId`)

interface: api.events.settlement.InstructionAffirmed.is
summary: An instruction has been affirmed (did, portfolio, instruction_id)

InstructionCreated(`IdentityId`, `VenueId`, `InstructionId`, `SettlementType`, `Option<Moment>`, `Option<Moment>`, `Vec<Leg>`)

interface: api.events.settlement.InstructionCreated.is
summary: A new instruction has been created (did, venue_id, instruction_id, settlement_type, trade_date, value_date, legs)

InstructionExecuted(`IdentityId`, `InstructionId`)

interface: api.events.settlement.InstructionExecuted.is
summary: Instruction executed successfully(did, instruction_id)

InstructionFailed(`IdentityId`, `InstructionId`)

interface: api.events.settlement.InstructionFailed.is
summary: Instruction failed execution (did, instruction_id)

InstructionRejected(`IdentityId`, `InstructionId`)

interface: api.events.settlement.InstructionRejected.is
summary: An instruction has been rejected (did, instruction_id)

InstructionRescheduled(`IdentityId`, `InstructionId`)

interface: api.events.settlement.InstructionRescheduled.is
summary: Instruction is rescheduled. (caller DID, instruction_id)

LegFailedExecution(`IdentityId`, `InstructionId`, `LegId`)

interface: api.events.settlement.LegFailedExecution.is
summary: Execution of a leg failed (did, instruction_id, leg_id)

ReceiptClaimed(`IdentityId`, `InstructionId`, `LegId`, `u64`, `AccountId`, `ReceiptMetadata`)

interface: api.events.settlement.ReceiptClaimed.is
summary: A receipt has been claimed (did, instruction_id, leg_id, receipt_uid, signer, receipt metadata)

ReceiptUnclaimed(`IdentityId`, `InstructionId`, `LegId`, `u64`, `AccountId`)

interface: api.events.settlement.ReceiptUnclaimed.is
summary: A receipt has been unclaimed (did, instruction_id, leg_id, receipt_uid, signer)

ReceiptValidityChanged(`IdentityId`, `AccountId`, `u64`, `bool`)

interface: api.events.settlement.ReceiptValidityChanged.is
summary: A receipt has been invalidated (did, signer, receipt_uid, validity)

SchedulingFailed(`DispatchError`)

interface: api.events.settlement.SchedulingFailed.is
summary: Scheduling of instruction fails.

VenueCreated(`IdentityId`, `VenueId`, `VenueDetails`, `VenueType`)

interface: api.events.settlement.VenueCreated.is
summary: A new venue has been created (did, venue_id, details, type)

VenueDetailsUpdated(`IdentityId`, `VenueId`, `VenueDetails`)

interface: api.events.settlement.VenueDetailsUpdated.is
summary: An existing venue's details has been updated (did, venue_id, details)

VenueFiltering(`IdentityId`, `Ticker`, `bool`)

interface: api.events.settlement.VenueFiltering.is
summary: Venue filtering has been enabled or disabled for a ticker (did, ticker, filtering_enabled)

VenuesAllowed(`IdentityId`, `Ticker`, `Vec<VenueId>`)

interface: api.events.settlement.VenuesAllowed.is
summary: Venues added to allow list (did, ticker, vec<venue_id>)

VenuesBlocked(`IdentityId`, `Ticker`, `Vec<VenueId>`)

interface: api.events.settlement.VenuesBlocked.is
summary: Venues added to block list (did, ticker, vec<venue_id>)

VenueTypeUpdated(`IdentityId`, `VenueId`, `VenueType`)

interface: api.events.settlement.VenueTypeUpdated.is
summary: An existing venue's type has been updated (did, venue_id, type)

VenueUnauthorized(`IdentityId`, `Ticker`, `VenueId`)

interface: api.events.settlement.VenueUnauthorized.is
summary: Venue not part of the token's allow list (did, Ticker, venue_id)

staking

Bonded(`IdentityId`, `AccountId`, `Balance`)

interface: api.events.staking.Bonded.is
summary: An account has bonded this amount. [did, stash, amount]

NOTE: This event is only emitted when funds are bonded via a dispatchable. Notably, it will not be emitted for staking rewards when they are added to stake.

CommissionCapUpdated(`IdentityId`, `Perbill`, `Perbill`)

interface: api.events.staking.CommissionCapUpdated.is
summary: When commission cap get updated. (old value, new value)

EraPayout(`EraIndex`, `Balance`, `Balance`)

interface: api.events.staking.EraPayout.is
summary: The era payout has been set; the first balance is the validator-payout; the second is the remainder from the maximum amount of reward. [era_index, validator_payout, remainder]

InvalidatedNominators(`IdentityId`, `AccountId`, `Vec<AccountId>`)

interface: api.events.staking.InvalidatedNominators.is
summary: Remove the nominators from the valid nominators when there CDD expired. Caller, Stash accountId of nominators

MinimumBondThresholdUpdated(`Option<IdentityId>`, `Balance`)

interface: api.events.staking.MinimumBondThresholdUpdated.is
summary: Min bond threshold was updated (new value).

Nominated(`IdentityId`, `AccountId`, `Vec<AccountId>`)

interface: api.events.staking.Nominated.is
summary: User has updated their nominations

OldSlashingReportDiscarded(`SessionIndex`)

interface: api.events.staking.OldSlashingReportDiscarded.is
summary: An old slashing report from a prior era was discarded because it could not be processed. [session_index]

PermissionedIdentityAdded(`IdentityId`, `IdentityId`)

interface: api.events.staking.PermissionedIdentityAdded.is
summary: An DID has issued a candidacy. See the transaction for who. GC identity , Validator's identity.

PermissionedIdentityRemoved(`IdentityId`, `IdentityId`)

interface: api.events.staking.PermissionedIdentityRemoved.is
summary: The given member was removed. See the transaction for who. GC identity , Validator's identity.

Reward(`IdentityId`, `AccountId`, `Balance`)

interface: api.events.staking.Reward.is
summary: The staker has been rewarded by this amount. [stash_identity, stash, amount]

RewardPaymentSchedulingInterrupted(`AccountId`, `EraIndex`, `DispatchError`)

interface: api.events.staking.RewardPaymentSchedulingInterrupted.is
summary: When scheduling of reward payments get interrupted.

Slash(`AccountId`, `Balance`)

interface: api.events.staking.Slash.is
summary: One validator (and its nominators) has been slashed by the given amount. [validator, amount]

SlashingAllowedForChanged(`SlashingSwitch`)

interface: api.events.staking.SlashingAllowedForChanged.is
summary: Update for whom balance get slashed.

SolutionStored(`ElectionCompute`)

interface: api.events.staking.SolutionStored.is
summary: A new solution for the upcoming election has been stored. [compute]

StakingElection(`ElectionCompute`)

interface: api.events.staking.StakingElection.is
summary: A new set of stakers was elected with the given [compute].

Unbonded(`IdentityId`, `AccountId`, `Balance`)

interface: api.events.staking.Unbonded.is
summary: An account has unbonded this amount. [did, stash, amount]

Withdrawn(`AccountId`, `Balance`)

interface: api.events.staking.Withdrawn.is
summary: An account has called withdraw_unbonded and removed unbonding chunks worth Balance from the unlocking queue. [stash, amount]

statistics

ExemptionsAdded(`IdentityId`, `Ticker`, `TransferManager`, `Vec<ScopeId>`)

interface: api.events.statistics.ExemptionsAdded.is
summary: ScopeIds were added to the exemption list.

ExemptionsRemoved(`IdentityId`, `Ticker`, `TransferManager`, `Vec<ScopeId>`)

interface: api.events.statistics.ExemptionsRemoved.is
summary: ScopeIds were removed from the exemption list.

TransferManagerAdded(`IdentityId`, `Ticker`, `TransferManager`)

interface: api.events.statistics.TransferManagerAdded.is
summary: A new transfer manager was added.

TransferManagerRemoved(`IdentityId`, `Ticker`, `TransferManager`)

interface: api.events.statistics.TransferManagerRemoved.is
summary: An existing transfer manager was removed.

sto

FundraiserClosed(`IdentityId`, `FundraiserId`)

interface: api.events.sto.FundraiserClosed.is
summary: A fundraiser has been stopped. (Agent DID, fundraiser id)

FundraiserCreated(`IdentityId`, `FundraiserId`, `FundraiserName`, `Fundraiser`)

interface: api.events.sto.FundraiserCreated.is
summary: A new fundraiser has been created. (Agent DID, fundraiser id, fundraiser name, fundraiser details)

FundraiserFrozen(`IdentityId`, `FundraiserId`)

interface: api.events.sto.FundraiserFrozen.is
summary: A fundraiser has been frozen. (Agent DID, fundraiser id)

FundraiserUnfrozen(`IdentityId`, `FundraiserId`)

interface: api.events.sto.FundraiserUnfrozen.is
summary: A fundraiser has been unfrozen. (Agent DID, fundraiser id)

FundraiserWindowModified(`EventDid`, `FundraiserId`, `Moment`, `Option<Moment>`, `Moment`, `Option<Moment>`)

interface: api.events.sto.FundraiserWindowModified.is
summary: A fundraiser window has been modified. (Agent DID, fundraiser id, old_start, old_end, new_start, new_end)

Invested(`IdentityId`, `FundraiserId`, `Ticker`, `Ticker`, `Balance`, `Balance`)

interface: api.events.sto.Invested.is
summary: An investor invested in the fundraiser. (Investor, fundraiser_id, offering token, raise token, offering_token_amount, raise_token_amount)

sudo

KeyChanged(`AccountId`)

interface: api.events.sudo.KeyChanged.is
summary: The [sudoer] just switched identity; the old key is supplied.

Sudid(`DispatchResult`)

interface: api.events.sudo.Sudid.is
summary: A sudo just took place. [result]

SudoAsDone(`DispatchResult`)

interface: api.events.sudo.SudoAsDone.is
summary: A sudo just took place. [result]

system

CodeUpdated()

interface: api.events.system.CodeUpdated.is
summary: :code was updated.

ExtrinsicFailed(`DispatchError`, `DispatchInfo`)

interface: api.events.system.ExtrinsicFailed.is
summary: An extrinsic failed. [error, info]

ExtrinsicSuccess(`DispatchInfo`)

interface: api.events.system.ExtrinsicSuccess.is
summary: An extrinsic completed successfully. [info]

KilledAccount(`AccountId`)

interface: api.events.system.KilledAccount.is
summary: An [account] was reaped.

NewAccount(`AccountId`)

interface: api.events.system.NewAccount.is
summary: A new [account] was created.

technicalCommittee

Approved(`IdentityId`, `Hash`, `MemberCount`, `MemberCount`, `MemberCount`)

interface: api.events.technicalCommittee.Approved.is
summary: A motion was approved by the required threshold with the following tally (yes votes, no votes and total seats given respectively as MemberCount). Parameters: caller DID, proposal hash, yay vote count, nay vote count, total seats.

Executed(`IdentityId`, `Hash`, `DispatchResult`)

interface: api.events.technicalCommittee.Executed.is
summary: A motion was executed; DispatchResult is Ok(()) if returned without error. Parameters: caller DID, proposal hash, result of proposal dispatch.

ExpiresAfterUpdated(`IdentityId`, `MaybeBlock`)

interface: api.events.technicalCommittee.ExpiresAfterUpdated.is
summary: Proposal expiry time has been updated. Parameters: caller DID, new expiry time (if any).

FinalVotes(`IdentityId`, `ProposalIndex`, `Hash`, `Vec<IdentityId>`, `Vec<IdentityId>`)

interface: api.events.technicalCommittee.FinalVotes.is
summary: Final votes on a motion (given hash) caller DID, ProposalIndex, Proposal hash, yes voters, no voter

Proposed(`IdentityId`, `ProposalIndex`, `Hash`)

interface: api.events.technicalCommittee.Proposed.is
summary: A motion (given hash) has been proposed (by given account) with a threshold (given MemberCount). Parameters: caller DID, proposal index, proposal hash.

Rejected(`IdentityId`, `Hash`, `MemberCount`, `MemberCount`, `MemberCount`)

interface: api.events.technicalCommittee.Rejected.is
summary: A motion was rejected by the required threshold with the following tally (yes votes, no votes and total seats given respectively as MemberCount). Parameters: caller DID, proposal hash, yay vote count, nay vote count, total seats.

ReleaseCoordinatorUpdated(`IdentityId`, `Option<IdentityId>`)

interface: api.events.technicalCommittee.ReleaseCoordinatorUpdated.is
summary: Release coordinator has been updated. Parameters: caller DID, DID of the release coordinator.

Voted(`IdentityId`, `ProposalIndex`, `Hash`, `bool`, `MemberCount`, `MemberCount`, `MemberCount`)

interface: api.events.technicalCommittee.Voted.is
summary: A motion (given hash) has been voted on by given account, leaving a tally (yes votes, no votes and total seats given respectively as MemberCount). caller DID, Proposal index, Proposal hash, current vote, yay vote count, nay vote count, total seats.

VoteRetracted(`IdentityId`, `ProposalIndex`, `Hash`, `bool`)

interface: api.events.technicalCommittee.VoteRetracted.is
summary: A vote on a motion (given hash) has been retracted. caller DID, ProposalIndex, Proposal hash, vote that was retracted

VoteThresholdUpdated(`IdentityId`, `u32`, `u32`)

interface: api.events.technicalCommittee.VoteThresholdUpdated.is
summary: Voting threshold has been updated Parameters: caller DID, numerator, denominator

technicalCommitteeMembership

ActiveLimitChanged(`IdentityId`, `MemberCount`, `MemberCount`)

interface: api.events.technicalCommitteeMembership.ActiveLimitChanged.is
summary: The limit of how many active members there can be concurrently was changed.

Dummy(`PhantomData`)

interface: api.events.technicalCommitteeMembership.Dummy.is
summary: Phantom member, never used.

MemberAdded(`IdentityId`, `IdentityId`)

interface: api.events.technicalCommitteeMembership.MemberAdded.is
summary: The given member was added; see the transaction for who. caller DID, New member DID.

MemberRemoved(`IdentityId`, `IdentityId`)

interface: api.events.technicalCommitteeMembership.MemberRemoved.is
summary: The given member was removed; see the transaction for who. caller DID, member DID that get removed.

MemberRevoked(`IdentityId`, `IdentityId`)

interface: api.events.technicalCommitteeMembership.MemberRevoked.is
summary: The given member has been revoked at specific time-stamp. caller DID, member DID that get revoked.

MembersReset(`IdentityId`, `Vec<IdentityId>`)

interface: api.events.technicalCommitteeMembership.MembersReset.is
summary: The membership was reset; see the transaction for who the new set is. caller DID, List of new members.

MembersSwapped(`IdentityId`, `IdentityId`, `IdentityId`)

interface: api.events.technicalCommitteeMembership.MembersSwapped.is
summary: Two members were swapped; see the transaction for who. caller DID, Removed DID, New add DID.

testUtils

CddStatus(`Option<IdentityId>`, `AccountId`, `bool`)

interface: api.events.testUtils.CddStatus.is
summary: Shows the DID associated to the AccountId, and a flag indicates if that DID has a valid CDD claim. (Target DID, Target Account, a valid CDD claim exists)

DidStatus(`IdentityId`, `AccountId`)

interface: api.events.testUtils.DidStatus.is
summary: Emits the IdentityId and the AccountId of the caller. (Caller DID, Caller account)

MockInvestorUIDCreated(`IdentityId`, `InvestorUid`)

interface: api.events.testUtils.MockInvestorUIDCreated.is
summary: A new mocked InvestorUid has been created for the given Identity. (Target DID, New InvestorUid)

treasury

TreasuryDisbursement(`IdentityId`, `IdentityId`, `Balance`)

interface: api.events.treasury.TreasuryDisbursement.is
summary: Disbursement to a target Identity. (target identity, amount)

TreasuryReimbursement(`IdentityId`, `Balance`)

interface: api.events.treasury.TreasuryReimbursement.is
summary: Treasury reimbursement.

upgradeCommittee

Approved(`IdentityId`, `Hash`, `MemberCount`, `MemberCount`, `MemberCount`)

interface: api.events.upgradeCommittee.Approved.is
summary: A motion was approved by the required threshold with the following tally (yes votes, no votes and total seats given respectively as MemberCount). Parameters: caller DID, proposal hash, yay vote count, nay vote count, total seats.

Executed(`IdentityId`, `Hash`, `DispatchResult`)

interface: api.events.upgradeCommittee.Executed.is
summary: A motion was executed; DispatchResult is Ok(()) if returned without error. Parameters: caller DID, proposal hash, result of proposal dispatch.

ExpiresAfterUpdated(`IdentityId`, `MaybeBlock`)

interface: api.events.upgradeCommittee.ExpiresAfterUpdated.is
summary: Proposal expiry time has been updated. Parameters: caller DID, new expiry time (if any).

FinalVotes(`IdentityId`, `ProposalIndex`, `Hash`, `Vec<IdentityId>`, `Vec<IdentityId>`)

interface: api.events.upgradeCommittee.FinalVotes.is
summary: Final votes on a motion (given hash) caller DID, ProposalIndex, Proposal hash, yes voters, no voter

Proposed(`IdentityId`, `ProposalIndex`, `Hash`)

interface: api.events.upgradeCommittee.Proposed.is
summary: A motion (given hash) has been proposed (by given account) with a threshold (given MemberCount). Parameters: caller DID, proposal index, proposal hash.

Rejected(`IdentityId`, `Hash`, `MemberCount`, `MemberCount`, `MemberCount`)

interface: api.events.upgradeCommittee.Rejected.is
summary: A motion was rejected by the required threshold with the following tally (yes votes, no votes and total seats given respectively as MemberCount). Parameters: caller DID, proposal hash, yay vote count, nay vote count, total seats.

ReleaseCoordinatorUpdated(`IdentityId`, `Option<IdentityId>`)

interface: api.events.upgradeCommittee.ReleaseCoordinatorUpdated.is
summary: Release coordinator has been updated. Parameters: caller DID, DID of the release coordinator.

Voted(`IdentityId`, `ProposalIndex`, `Hash`, `bool`, `MemberCount`, `MemberCount`, `MemberCount`)

interface: api.events.upgradeCommittee.Voted.is
summary: A motion (given hash) has been voted on by given account, leaving a tally (yes votes, no votes and total seats given respectively as MemberCount). caller DID, Proposal index, Proposal hash, current vote, yay vote count, nay vote count, total seats.

VoteRetracted(`IdentityId`, `ProposalIndex`, `Hash`, `bool`)

interface: api.events.upgradeCommittee.VoteRetracted.is
summary: A vote on a motion (given hash) has been retracted. caller DID, ProposalIndex, Proposal hash, vote that was retracted

VoteThresholdUpdated(`IdentityId`, `u32`, `u32`)

interface: api.events.upgradeCommittee.VoteThresholdUpdated.is
summary: Voting threshold has been updated Parameters: caller DID, numerator, denominator

upgradeCommitteeMembership

ActiveLimitChanged(`IdentityId`, `MemberCount`, `MemberCount`)

interface: api.events.upgradeCommitteeMembership.ActiveLimitChanged.is
summary: The limit of how many active members there can be concurrently was changed.

Dummy(`PhantomData`)

interface: api.events.upgradeCommitteeMembership.Dummy.is
summary: Phantom member, never used.

MemberAdded(`IdentityId`, `IdentityId`)

interface: api.events.upgradeCommitteeMembership.MemberAdded.is
summary: The given member was added; see the transaction for who. caller DID, New member DID.

MemberRemoved(`IdentityId`, `IdentityId`)

interface: api.events.upgradeCommitteeMembership.MemberRemoved.is
summary: The given member was removed; see the transaction for who. caller DID, member DID that get removed.

MemberRevoked(`IdentityId`, `IdentityId`)

interface: api.events.upgradeCommitteeMembership.MemberRevoked.is
summary: The given member has been revoked at specific time-stamp. caller DID, member DID that get revoked.

MembersReset(`IdentityId`, `Vec<IdentityId>`)

interface: api.events.upgradeCommitteeMembership.MembersReset.is
summary: The membership was reset; see the transaction for who the new set is. caller DID, List of new members.

MembersSwapped(`IdentityId`, `IdentityId`, `IdentityId`)

interface: api.events.upgradeCommitteeMembership.MembersSwapped.is
summary: Two members were swapped; see the transaction for who. caller DID, Removed DID, New add DID.

utility

BatchCompleted(`EventCounts`)

interface: api.events.utility.BatchCompleted.is
summary: Batch of dispatches completed fully with no error. Includes a vector of event counts for each dispatch.

BatchInterrupted(`EventCounts`, `ErrorAt`)

interface: api.events.utility.BatchInterrupted.is
summary: Batch of dispatches did not complete fully. Includes a vector of event counts for each dispatch and the index of the first failing dispatch as well as the error.

BatchOptimisticFailed(`EventCounts`, `Vec<ErrorAt>`)

interface: api.events.utility.BatchOptimisticFailed.is
summary: Batch of dispatches did not complete fully. Includes a vector of event counts for each call and a vector of any failed dispatches with their indices and associated error.

title: Errors

This page lists the errors that can be encountered in the different modules.

(NOTE: These were generated from a static/snapshot view of a recent Substrate master node. Some items may not be available in older nodes, or in any customized implementations.)

asset

AlreadyArchived

interface: api.errors.asset.AlreadyArchived.is
summary: When extension already archived.

AlreadyFrozen

interface: api.errors.asset.AlreadyFrozen.is
summary: The token is already frozen.

AlreadyUnArchived

interface: api.errors.asset.AlreadyUnArchived.is
summary: When extension already un-archived.

AssetAlreadyCreated

interface: api.errors.asset.AssetAlreadyCreated.is
summary: The token has already been created.

AssetAlreadyDivisible

interface: api.errors.asset.AssetAlreadyDivisible.is
summary: The token is already divisible.

BalanceOverflow

interface: api.errors.asset.BalanceOverflow.is
summary: An overflow while calculating the balance.

ExtensionAlreadyPresent

interface: api.errors.asset.ExtensionAlreadyPresent.is
summary: When extension is already added.

FundingRoundNameMaxLengthExceeded

interface: api.errors.asset.FundingRoundNameMaxLengthExceeded.is
summary: Maximum length of the funding round name has been exceeded.

IncompatibleExtensionVersion

interface: api.errors.asset.IncompatibleExtensionVersion.is
summary: Given smart extension is not compatible with the asset.

InsufficientBalance

interface: api.errors.asset.InsufficientBalance.is
summary: The sender balance is not sufficient.

InvalidAssetIdentifier

interface: api.errors.asset.InvalidAssetIdentifier.is
summary: Some AssetIdentifier was invalid.

InvalidCustomAssetTypeId

interface: api.errors.asset.InvalidCustomAssetTypeId.is
summary: Invalid CustomAssetTypeId.

InvalidEthereumSignature

interface: api.errors.asset.InvalidEthereumSignature.is
summary: An invalid Ethereum EcdsaSignature.

InvalidGranularity

interface: api.errors.asset.InvalidGranularity.is
summary: An invalid granularity.

InvalidTransfer

interface: api.errors.asset.InvalidTransfer.is
summary: Transfer validation check failed.

InvestorUniquenessClaimNotAllowed

interface: api.errors.asset.InvestorUniquenessClaimNotAllowed.is
summary: Investor Uniqueness claims are not allowed for this asset.

MaximumTMExtensionLimitReached

interface: api.errors.asset.MaximumTMExtensionLimitReached.is
summary: Number of Transfer Manager extensions attached to an asset is equal to MaxNumberOfTMExtensionForAsset.

MaxLengthOfAssetNameExceeded

interface: api.errors.asset.MaxLengthOfAssetNameExceeded.is
summary: Maximum length of asset name has been exceeded.

NoSuchAsset

interface: api.errors.asset.NoSuchAsset.is
summary: No such token.

NoSuchClassicTicker

interface: api.errors.asset.NoSuchClassicTicker.is
summary: The given ticker is not a classic one.

NoSuchDoc

interface: api.errors.asset.NoSuchDoc.is
summary: The given Document does not exist.

NotAnOwner

interface: api.errors.asset.NotAnOwner.is
summary: Not an owner of the token on Ethereum.

NotFrozen

interface: api.errors.asset.NotFrozen.is
summary: The asset must be frozen.

SenderSameAsReceiver

interface: api.errors.asset.SenderSameAsReceiver.is
summary: Transfers to self are not allowed

TickerAlreadyRegistered

interface: api.errors.asset.TickerAlreadyRegistered.is
summary: The ticker is already registered to someone else.

TickerNotAscii

interface: api.errors.asset.TickerNotAscii.is
summary: The ticker has non-ascii-encoded parts.

TickerRegistrationExpired

interface: api.errors.asset.TickerRegistrationExpired.is
summary: Registration of ticker has expired.

TickerTooLong

interface: api.errors.asset.TickerTooLong.is
summary: The ticker length is over the limit.

TotalSupplyAboveLimit

interface: api.errors.asset.TotalSupplyAboveLimit.is
summary: The total supply is above the limit.

TotalSupplyOverflow

interface: api.errors.asset.TotalSupplyOverflow.is
summary: An overflow while calculating the total supply.

Unauthorized

interface: api.errors.asset.Unauthorized.is
summary: The user is not authorized.

authorship

GenesisUncle

interface: api.errors.authorship.GenesisUncle.is
summary: The uncle is genesis.

InvalidUncleParent

interface: api.errors.authorship.InvalidUncleParent.is
summary: The uncle parent not in the chain.

OldUncle

interface: api.errors.authorship.OldUncle.is
summary: The uncle isn't recent enough to be included.

TooHighUncle

interface: api.errors.authorship.TooHighUncle.is
summary: The uncle is too high in chain.

TooManyUncles

interface: api.errors.authorship.TooManyUncles.is
summary: Too many uncles.

UncleAlreadyIncluded

interface: api.errors.authorship.UncleAlreadyIncluded.is
summary: The uncle is already included.

UnclesAlreadySet

interface: api.errors.authorship.UnclesAlreadySet.is
summary: Uncles already set in the block.

balances

ExistentialDeposit

interface: api.errors.balances.ExistentialDeposit.is
summary: Value too low to create account due to existential deposit

InsufficientBalance

interface: api.errors.balances.InsufficientBalance.is
summary: Balance too low to send value

LiquidityRestrictions

interface: api.errors.balances.LiquidityRestrictions.is
summary: Account liquidity restrictions prevent withdrawal

Overflow

interface: api.errors.balances.Overflow.is
summary: Got an overflow after adding

ReceiverCddMissing

interface: api.errors.balances.ReceiverCddMissing.is
summary: Receiver does not have a valid CDD

base

CounterOverflow

interface: api.errors.base.CounterOverflow.is
summary: The sequence counter for something overflowed.

When this happens depends on e.g., the capacity of the identifier type. For example, we might have pub struct PipId(u32);, with u32::MAX capacity. In practice, these errors will never happen but no code path should result in a panic, so these corner cases need to be covered with an error variant.

TooLong

interface: api.errors.base.TooLong.is
summary: Exceeded a generic length limit. The limit could be for any sort of lists of things, including a string.

bridge

BadAdmin

interface: api.errors.bridge.BadAdmin.is
summary: The origin is not the admin address.

BadCaller

interface: api.errors.bridge.BadCaller.is
summary: The origin is not the controller or the admin address.

BridgeLimitReached

interface: api.errors.bridge.BridgeLimitReached.is
summary: The identity's minted total has reached the bridge limit.

ControllerNotSet

interface: api.errors.bridge.ControllerNotSet.is
summary: The bridge controller address is not set.

DivisionByZero

interface: api.errors.bridge.DivisionByZero.is
summary: The block interval duration is zero. Cannot divide.

Frozen

interface: api.errors.bridge.Frozen.is
summary: The bridge is already frozen.

FrozenTx

interface: api.errors.bridge.FrozenTx.is
summary: The transaction is frozen.

NotFrozen

interface: api.errors.bridge.NotFrozen.is
summary: The bridge is not frozen.

NoValidCdd

interface: api.errors.bridge.NoValidCdd.is
summary: The recipient DID has no valid CDD.

Overflow

interface: api.errors.bridge.Overflow.is
summary: The identity's minted total has overflowed.

ProposalAlreadyHandled

interface: api.errors.bridge.ProposalAlreadyHandled.is
summary: The bridge transaction proposal has already been handled and the funds minted.

TimelockedTx

interface: api.errors.bridge.TimelockedTx.is
summary: The transaction is timelocked.

Unauthorized

interface: api.errors.bridge.Unauthorized.is
summary: Unauthorized to perform an operation.

capitalDistribution

AlreadyExists

interface: api.errors.capitalDistribution.AlreadyExists.is
summary: A distribution already exists for this CA.

AlreadyReclaimed

interface: api.errors.capitalDistribution.AlreadyReclaimed.is
summary: DID who created the distribution already did reclaim.

BalancePerShareProductOverflowed

interface: api.errors.capitalDistribution.BalancePerShareProductOverflowed.is
summary: Multiplication of the balance with the per share payout amount overflowed.

CannotClaimAfterExpiry

interface: api.errors.capitalDistribution.CannotClaimAfterExpiry.is
summary: Distribution's expiry has passed. DID cannot claim anymore and has forfeited the benefits.

CannotClaimBeforeStart

interface: api.errors.capitalDistribution.CannotClaimBeforeStart.is
summary: Distribution allotment cannot be claimed as the current time is before start-of-payment.

CANotBenefit

interface: api.errors.capitalDistribution.CANotBenefit.is
summary: A capital distribution was made for a non-benefit CA.

DistributingAsset

interface: api.errors.capitalDistribution.DistributingAsset.is
summary: Currency that is distributed is the same as the CA's ticker. Calling agent is attempting a form of stock split, which is not what the extrinsic is for.

DistributionStarted

interface: api.errors.capitalDistribution.DistributionStarted.is
summary: A distribution has been activated, as payment_at <= now holds.

ExpiryBeforePayment

interface: api.errors.capitalDistribution.ExpiryBeforePayment.is
summary: A distributions provided expiry date was strictly before its payment date. In other words, everything to distribute would immediately be forfeited.

HolderAlreadyPaid

interface: api.errors.capitalDistribution.HolderAlreadyPaid.is
summary: The token holder has already been paid their benefit.

InsufficientRemainingAmount

interface: api.errors.capitalDistribution.InsufficientRemainingAmount.is
summary: A distribution has insufficient remaining amount of currency to distribute.

NoSuchDistribution

interface: api.errors.capitalDistribution.NoSuchDistribution.is
summary: A capital distribution doesn't exist for this CA.

NotDistributionCreator

interface: api.errors.capitalDistribution.NotDistributionCreator.is
summary: DID is not the one who created the distribution.

NotExpired

interface: api.errors.capitalDistribution.NotExpired.is
summary: Distribution had not expired yet, or there's no expiry date.

cddServiceProviders

ActiveMembersLimitExceeded

interface: api.errors.cddServiceProviders.ActiveMembersLimitExceeded.is
summary: The limit for the number of concurrent active members for this group has been exceeded.

ActiveMembersLimitOverflow

interface: api.errors.cddServiceProviders.ActiveMembersLimitOverflow.is
summary: Active member limit was greater than maximum committee members limit.

DuplicateMember

interface: api.errors.cddServiceProviders.DuplicateMember.is
summary: Group member was added already.

LastMemberCannotQuit

interface: api.errors.cddServiceProviders.LastMemberCannotQuit.is
summary: Last member of the committee can not quit.

MissingCurrentIdentity

interface: api.errors.cddServiceProviders.MissingCurrentIdentity.is
summary: Missing current DID

NoSuchMember

interface: api.errors.cddServiceProviders.NoSuchMember.is
summary: Can't remove a member that doesn't exist.

OnlyPrimaryKeyAllowed

interface: api.errors.cddServiceProviders.OnlyPrimaryKeyAllowed.is
summary: Only primary key of the identity is allowed.

checkpoint

FailedToComputeNextCheckpoint

interface: api.errors.checkpoint.FailedToComputeNextCheckpoint.is
summary: Failed to compute the next checkpoint. The schedule does not have any upcoming checkpoints.

NoSuchSchedule

interface: api.errors.checkpoint.NoSuchSchedule.is
summary: A checkpoint schedule does not exist for the asset.

ScheduleDurationTooShort

interface: api.errors.checkpoint.ScheduleDurationTooShort.is
summary: The duration of a schedule period is too short.

ScheduleNotRemovable

interface: api.errors.checkpoint.ScheduleNotRemovable.is
summary: A checkpoint schedule is not removable as ref_count(schedule_id) > 0.

SchedulesTooComplex

interface: api.errors.checkpoint.SchedulesTooComplex.is
summary: The set of schedules taken together are too complex. For example, they are too many, or they occurs too frequently.

committeeMembership

ActiveMembersLimitExceeded

interface: api.errors.committeeMembership.ActiveMembersLimitExceeded.is
summary: The limit for the number of concurrent active members for this group has been exceeded.

ActiveMembersLimitOverflow

interface: api.errors.committeeMembership.ActiveMembersLimitOverflow.is
summary: Active member limit was greater than maximum committee members limit.

DuplicateMember

interface: api.errors.committeeMembership.DuplicateMember.is
summary: Group member was added already.

LastMemberCannotQuit

interface: api.errors.committeeMembership.LastMemberCannotQuit.is
summary: Last member of the committee can not quit.

MissingCurrentIdentity

interface: api.errors.committeeMembership.MissingCurrentIdentity.is
summary: Missing current DID

NoSuchMember

interface: api.errors.committeeMembership.NoSuchMember.is
summary: Can't remove a member that doesn't exist.

OnlyPrimaryKeyAllowed

interface: api.errors.committeeMembership.OnlyPrimaryKeyAllowed.is
summary: Only primary key of the identity is allowed.

complianceManager

ComplianceRequirementTooComplex

interface: api.errors.complianceManager.ComplianceRequirementTooComplex.is
summary: The worst case scenario of the compliance requirement is too complex

DidNotExist

interface: api.errors.complianceManager.DidNotExist.is
summary: Did not exist

DuplicateComplianceRequirements

interface: api.errors.complianceManager.DuplicateComplianceRequirements.is
summary: There are duplicate compliance requirements.

IncorrectOperationOnTrustedIssuer

interface: api.errors.complianceManager.IncorrectOperationOnTrustedIssuer.is
summary: Issuer exist but trying to add it again

InvalidComplianceRequirementId

interface: api.errors.complianceManager.InvalidComplianceRequirementId.is
summary: Compliance requirement id doesn't exist

Unauthorized

interface: api.errors.complianceManager.Unauthorized.is
summary: User is not authorized.

corporateAction

AuthNotCAATransfer

interface: api.errors.corporateAction.AuthNotCAATransfer.is
summary: The authorization type is not to transfer the CAA to another DID.

DeclDateAfterRecordDate

interface: api.errors.corporateAction.DeclDateAfterRecordDate.is
summary: A CA's declaration date was strictly after its record date.

DeclDateInFuture

interface: api.errors.corporateAction.DeclDateInFuture.is
summary: A CA's declaration date occurs in the future.

DetailsTooLong

interface: api.errors.corporateAction.DetailsTooLong.is
summary: The details of a CA exceeded the max allowed length.

DuplicateDidTax

interface: api.errors.corporateAction.DuplicateDidTax.is
summary: A withholding tax override for a given DID was specified more than once. The chain refused to make a choice, and hence there was an error.

NoRecordDate

interface: api.errors.corporateAction.NoRecordDate.is
summary: The CA did not have a record date.

NoSuchCA

interface: api.errors.corporateAction.NoSuchCA.is
summary: A CA with the given CAId did not exist.

NoSuchCheckpointId

interface: api.errors.corporateAction.NoSuchCheckpointId.is
summary: On CA creation, a checkpoint ID was provided which doesn't exist.

NotTargetedByCA

interface: api.errors.corporateAction.NotTargetedByCA.is
summary: CA does not target the DID.

RecordDateAfterStart

interface: api.errors.corporateAction.RecordDateAfterStart.is
summary: A CA's record date was strictly after the "start" time, where "start" is context dependent. For example, it could be the start of a ballot, or the start-of-payment in capital distribution.

TooManyDidTaxes

interface: api.errors.corporateAction.TooManyDidTaxes.is
summary: Too many withholding tax overrides were specified.

TooManyTargetIds

interface: api.errors.corporateAction.TooManyTargetIds.is
summary: Too many identities in TargetIdentities were specified.

corporateBallot

AlreadyExists

interface: api.errors.corporateBallot.AlreadyExists.is
summary: A corporate ballot already exists for this CA.

CANotNotice

interface: api.errors.corporateBallot.CANotNotice.is
summary: A corporate ballot was made for a non IssuerNotice CA.

InsufficientVotes

interface: api.errors.corporateBallot.InsufficientVotes.is
summary: Voting power used by a DID on a motion exceeds that which is available to them.

NoSuchBallot

interface: api.errors.corporateBallot.NoSuchBallot.is
summary: A corporate ballot doesn't exist for this CA.

NoSuchRCVFallback

interface: api.errors.corporateBallot.NoSuchRCVFallback.is
summary: The RCV fallback of some choice does not exist.

NowAfterEnd

interface: api.errors.corporateBallot.NowAfterEnd.is
summary: A corporate ballot's end time was strictly before the current time.

NumberOfChoicesOverflow

interface: api.errors.corporateBallot.NumberOfChoicesOverflow.is
summary: If some motion in a corporate ballot has more choices than would fit in u16.

RCVNotAllowed

interface: api.errors.corporateBallot.RCVNotAllowed.is
summary: RCV is not allowed for this ballot.

RCVSelfCycle

interface: api.errors.corporateBallot.RCVSelfCycle.is
summary: The RCV fallback points to the origin choice.

StartAfterEnd

interface: api.errors.corporateBallot.StartAfterEnd.is
summary: A corporate ballot's start time was strictly after the ballot's end.

VotingAlreadyEnded

interface: api.errors.corporateBallot.VotingAlreadyEnded.is
summary: Voting ended already.

VotingAlreadyStarted

interface: api.errors.corporateBallot.VotingAlreadyStarted.is
summary: Voting started already. Amending a ballot is no longer possible.

VotingNotStarted

interface: api.errors.corporateBallot.VotingNotStarted.is
summary: Voting hasn't started yet.

WrongVoteCount

interface: api.errors.corporateBallot.WrongVoteCount.is
summary: Provided list of balances does not match the total number of choices.

externalAgents

AlreadyAnAgent

interface: api.errors.externalAgents.AlreadyAnAgent.is
summary: The provided agent is already an agent for the Ticker.

NoSuchAG

interface: api.errors.externalAgents.NoSuchAG.is
summary: An AG with the given AGId did not exist for the Ticker.

NotAnAgent

interface: api.errors.externalAgents.NotAnAgent.is
summary: The provided agent is not an agent for the Ticker.

RemovingLastFullAgent

interface: api.errors.externalAgents.RemovingLastFullAgent.is
summary: This agent is the last full one, and it's being removed, making the asset orphaned.

SecondaryKeyNotAuthorizedForAsset

interface: api.errors.externalAgents.SecondaryKeyNotAuthorizedForAsset.is
summary: The caller's secondary key does not have the required asset permission.

UnauthorizedAgent

interface: api.errors.externalAgents.UnauthorizedAgent.is
summary: The agent is not authorized to call the current extrinsic.

grandpa

ChangePending

interface: api.errors.grandpa.ChangePending.is
summary: Attempt to signal GRANDPA change with one already pending.

DuplicateOffenceReport

interface: api.errors.grandpa.DuplicateOffenceReport.is
summary: A given equivocation report is valid but already previously reported.

InvalidEquivocationProof

interface: api.errors.grandpa.InvalidEquivocationProof.is
summary: An equivocation proof provided as part of an equivocation report is invalid.

InvalidKeyOwnershipProof

interface: api.errors.grandpa.InvalidKeyOwnershipProof.is
summary: A key ownership proof provided as part of an equivocation report is invalid.

PauseFailed

interface: api.errors.grandpa.PauseFailed.is
summary: Attempt to signal GRANDPA pause when the authority set isn't live (either paused or already pending pause).

ResumeFailed

interface: api.errors.grandpa.ResumeFailed.is
summary: Attempt to signal GRANDPA resume when the authority set isn't paused (either live or already pending resume).

TooSoon

interface: api.errors.grandpa.TooSoon.is
summary: Cannot signal forced change so soon after last.

identity

AccountKeyIsBeingUsed

interface: api.errors.identity.AccountKeyIsBeingUsed.is
summary: The account key is being used, it can't be unlinked.

AlreadyLinked

interface: api.errors.identity.AlreadyLinked.is
summary: One secondary or primary key can only belong to one DID

AuthorizationExpired

interface: api.errors.identity.AuthorizationExpired.is
summary: The offchain authorization has expired.

AuthorizationHasBeenRevoked

interface: api.errors.identity.AuthorizationHasBeenRevoked.is
summary: Authorization has been explicitly revoked.

AuthorizationsNotForSameDids

interface: api.errors.identity.AuthorizationsNotForSameDids.is
summary: Authorizations are not for the same DID.

CannotDecodeSignerAccountId

interface: api.errors.identity.CannotDecodeSignerAccountId.is
summary: Cannot convert a T::AccountId to AnySignature::Signer::AccountId.

CDDIdNotUniqueForIdentity

interface: api.errors.identity.CDDIdNotUniqueForIdentity.is
summary: CDDId should be unique & same within all cdd claims possessed by a DID.

ClaimAndProofVersionsDoNotMatch

interface: api.errors.identity.ClaimAndProofVersionsDoNotMatch.is
summary: Claim and Proof versions are different.

ClaimVariantNotAllowed

interface: api.errors.identity.ClaimVariantNotAllowed.is
summary: Try to add a claim variant using un-designated extrinsic.

ConfidentialScopeClaimNotAllowed

interface: api.errors.identity.ConfidentialScopeClaimNotAllowed.is
summary: Confidential Scope claims can be added by an Identity to it-self.

CurrentIdentityCannotBeForwarded

interface: api.errors.identity.CurrentIdentityCannotBeForwarded.is
summary: Current identity cannot be forwarded, it is not a secondary key of target identity.

CustomScopeTooLong

interface: api.errors.identity.CustomScopeTooLong.is
summary: A custom scope is too long. It can at most be 32 characters long.

DidAlreadyExists

interface: api.errors.identity.DidAlreadyExists.is
summary: The DID already exists.

DidDoesNotExist

interface: api.errors.identity.DidDoesNotExist.is
summary: The DID does not exist.

DidMustAlreadyExist

interface: api.errors.identity.DidMustAlreadyExist.is
summary: The DID must already exist.

FailedToChargeFee

interface: api.errors.identity.FailedToChargeFee.is
summary: Couldn't charge fee for the transaction.

InvalidAccountKey

interface: api.errors.identity.InvalidAccountKey.is
summary: Account Id cannot be extracted from signer

InvalidAuthorizationFromCddProvider

interface: api.errors.identity.InvalidAuthorizationFromCddProvider.is
summary: An invalid authorization from the CDD provider.

InvalidAuthorizationFromOwner

interface: api.errors.identity.InvalidAuthorizationFromOwner.is
summary: An invalid authorization from the owner.

InvalidAuthorizationSignature

interface: api.errors.identity.InvalidAuthorizationSignature.is
summary: An invalid authorization signature.

InvalidCDDId

interface: api.errors.identity.InvalidCDDId.is
summary: Non systematic CDD providers can not create default cdd_id claims.

InvalidScopeClaim

interface: api.errors.identity.InvalidScopeClaim.is
summary: Addition of a new scope claim gets invalidated.

KeyNotAllowed

interface: api.errors.identity.KeyNotAllowed.is
summary: This key is not allowed to execute a given operation.

MissingCurrentIdentity

interface: api.errors.identity.MissingCurrentIdentity.is
summary: Missing current identity on the transaction

MultiSigHasBalance

interface: api.errors.identity.MultiSigHasBalance.is
summary: Multisig can not be unlinked from an identity while it still holds POLYX

NotASigner

interface: api.errors.identity.NotASigner.is
summary: Signer is not a secondary key of the provided identity

NotCddProviderAttestation

interface: api.errors.identity.NotCddProviderAttestation.is
summary: Attestation was not by a CDD service provider.

NotPrimaryKey

interface: api.errors.identity.NotPrimaryKey.is
summary: Only the primary key is allowed to revoke an Identity Signatory off-chain authorization.

SecondaryKeysContainPrimaryKey

interface: api.errors.identity.SecondaryKeysContainPrimaryKey.is
summary: The secondary keys contain the primary key.

TargetHasNoCdd

interface: api.errors.identity.TargetHasNoCdd.is
summary: The target DID has no valid CDD.

TargetHasNonZeroBalanceAtScopeId

interface: api.errors.identity.TargetHasNonZeroBalanceAtScopeId.is
summary: Try to delete the IU claim even when the user has non zero balance at given scopeId.

Unauthorized

interface: api.errors.identity.Unauthorized.is
summary: Signatory is not pre authorized by the identity

UnAuthorizedCddProvider

interface: api.errors.identity.UnAuthorizedCddProvider.is
summary: Only CDD service providers are allowed.

imOnline

DuplicatedHeartbeat

interface: api.errors.imOnline.DuplicatedHeartbeat.is
summary: Duplicated heartbeat.

InvalidKey

interface: api.errors.imOnline.InvalidKey.is
summary: Non existent public key.

multiSig

AlreadyASigner

interface: api.errors.multiSig.AlreadyASigner.is
summary: Already a signer.

AlreadyVoted

interface: api.errors.multiSig.AlreadyVoted.is
summary: Already voted.

CddMissing

interface: api.errors.multiSig.CddMissing.is
summary: The multisig is not attached to a CDD'd identity.

ChangeNotAllowed

interface: api.errors.multiSig.ChangeNotAllowed.is
summary: Changing multisig parameters not allowed since multisig is a primary key.

DecodingError

interface: api.errors.multiSig.DecodingError.is
summary: Multisig address.

FailedToChargeFee

interface: api.errors.multiSig.FailedToChargeFee.is
summary: Couldn't charge fee for the transaction.

FailedToSchedule

interface: api.errors.multiSig.FailedToSchedule.is
summary: Scheduling of a proposal fails

IdentityNotCreator

interface: api.errors.multiSig.IdentityNotCreator.is
summary: Identity provided is not the multisig's creator.

MissingCurrentIdentity

interface: api.errors.multiSig.MissingCurrentIdentity.is
summary: Current DID is missing

MultisigMissingIdentity

interface: api.errors.multiSig.MultisigMissingIdentity.is
summary: Multisig is not attached to an identity

NonceOverflow

interface: api.errors.multiSig.NonceOverflow.is
summary: A nonce overflow.

NoSigners

interface: api.errors.multiSig.NoSigners.is
summary: No signers.

NoSuchMultisig

interface: api.errors.multiSig.NoSuchMultisig.is
summary: No such multisig.

NotASigner

interface: api.errors.multiSig.NotASigner.is
summary: Not a signer.

NotEnoughSigners

interface: api.errors.multiSig.NotEnoughSigners.is
summary: Not enough signers.

NotPrimaryKey

interface: api.errors.multiSig.NotPrimaryKey.is
summary: The function can only be called by the primary key of the did

ProposalAlreadyExecuted

interface: api.errors.multiSig.ProposalAlreadyExecuted.is
summary: Proposal was executed earlier

ProposalAlreadyRejected

interface: api.errors.multiSig.ProposalAlreadyRejected.is
summary: Proposal was rejected earlier

ProposalExpired

interface: api.errors.multiSig.ProposalExpired.is
summary: Proposal has expired

ProposalMissing

interface: api.errors.multiSig.ProposalMissing.is
summary: The proposal does not exist.

RequiredSignaturesOutOfBounds

interface: api.errors.multiSig.RequiredSignaturesOutOfBounds.is
summary: Too few or too many required signatures.

SignerAlreadyLinked

interface: api.errors.multiSig.SignerAlreadyLinked.is
summary: Signer is an account key that is already associated with a multisig.

TooManySigners

interface: api.errors.multiSig.TooManySigners.is
summary: More signers than required.

permissions

UnauthorizedCaller

interface: api.errors.permissions.UnauthorizedCaller.is
summary: The caller is not authorized to call the current extrinsic.

pips

CannotSkipPip

interface: api.errors.pips.CannotSkipPip.is
summary: When enacting snapshot results, an unskippable PIP was skipped.

IncorrectDeposit

interface: api.errors.pips.IncorrectDeposit.is
summary: Proposer specifies an incorrect deposit

IncorrectProposalState

interface: api.errors.pips.IncorrectProposalState.is
summary: Proposal is not in the correct state

InsufficientDeposit

interface: api.errors.pips.InsufficientDeposit.is
summary: Proposer can't afford to lock minimum deposit

InvalidFutureBlockNumber

interface: api.errors.pips.InvalidFutureBlockNumber.is
summary: When a block number is less than current block number.

MissingCurrentIdentity

interface: api.errors.pips.MissingCurrentIdentity.is
summary: Missing current DID

NoSuchProposal

interface: api.errors.pips.NoSuchProposal.is
summary: The proposal does not exist.

NotACommitteeMember

interface: api.errors.pips.NotACommitteeMember.is
summary: Not part of governance committee.

NotByCommittee

interface: api.errors.pips.NotByCommittee.is
summary: The given dispatchable call is not valid for this proposal. The proposal must be by community, but isn't.

NotFromCommunity

interface: api.errors.pips.NotFromCommunity.is
summary: The given dispatchable call is not valid for this proposal. The proposal must be from the community, but isn't.

NumberOfVotesExceeded

interface: api.errors.pips.NumberOfVotesExceeded.is
summary: When number of votes overflows.

ProposalNotInScheduledState

interface: api.errors.pips.ProposalNotInScheduledState.is
summary: A proposal that is not in a scheduled state cannot be executed.

RescheduleNotByReleaseCoordinator

interface: api.errors.pips.RescheduleNotByReleaseCoordinator.is
summary: Only the GC release coordinator is allowed to reschedule proposal execution.

ScheduledProposalDoesntExist

interface: api.errors.pips.ScheduledProposalDoesntExist.is
summary: Execution of a scheduled proposal failed because it is missing.

SnapshotIdMismatch

interface: api.errors.pips.SnapshotIdMismatch.is
summary: Tried to enact result for PIP with id different from that at the position in the queue.

SnapshotResultTooLarge

interface: api.errors.pips.SnapshotResultTooLarge.is
summary: Tried to enact results for the snapshot queue overflowing its length.

StakeAmountOfVotesExceeded

interface: api.errors.pips.StakeAmountOfVotesExceeded.is
summary: When stake amount of a vote overflows.

TooManyActivePips

interface: api.errors.pips.TooManyActivePips.is
summary: The current number of active (pending | scheduled) PIPs exceed the maximum and the proposal is not by a committee.

polymeshCommittee

DuplicateProposal

interface: api.errors.polymeshCommittee.DuplicateProposal.is
summary: Duplicate proposal.

DuplicateVote

interface: api.errors.polymeshCommittee.DuplicateVote.is
summary: Duplicate votes are not allowed.

FirstVoteReject

interface: api.errors.polymeshCommittee.FirstVoteReject.is
summary: First vote on a proposal creates it, so it must be an approval. All proposals are motions to execute something as "GC majority". To reject e.g., a PIP, a motion to reject should be approved.

InvalidProportion

interface: api.errors.polymeshCommittee.InvalidProportion.is
summary: Proportion must be a rational number.

MismatchedVotingIndex

interface: api.errors.polymeshCommittee.MismatchedVotingIndex.is
summary: Mismatched voting index.

NoSuchProposal

interface: api.errors.polymeshCommittee.NoSuchProposal.is
summary: No such proposal.

NotAMember

interface: api.errors.polymeshCommittee.NotAMember.is
summary: A DID isn't part of the committee. The DID may either be a caller or some other context.

ProposalExpired

interface: api.errors.polymeshCommittee.ProposalExpired.is
summary: Proposal exists, but it has expired.

ProposalsLimitReached

interface: api.errors.polymeshCommittee.ProposalsLimitReached.is
summary: Maximum number of proposals has been reached.

portfolio

DestinationIsSamePortfolio

interface: api.errors.portfolio.DestinationIsSamePortfolio.is
summary: The source and destination portfolios should be different.

DifferentIdentityPortfolios

interface: api.errors.portfolio.DifferentIdentityPortfolios.is
summary: The portfolios belong to different identities

InsufficientPortfolioBalance

interface: api.errors.portfolio.InsufficientPortfolioBalance.is
summary: Insufficient balance for a transaction.

InsufficientTokensLocked

interface: api.errors.portfolio.InsufficientTokensLocked.is
summary: Can not unlock more tokens than what are locked

PortfolioDoesNotExist

interface: api.errors.portfolio.PortfolioDoesNotExist.is
summary: The portfolio doesn't exist.

PortfolioNameAlreadyInUse

interface: api.errors.portfolio.PortfolioNameAlreadyInUse.is
summary: The portfolio couldn't be renamed because the chosen name is already in use.

PortfolioNotEmpty

interface: api.errors.portfolio.PortfolioNotEmpty.is
summary: The portfolio still has some asset balance left

SecondaryKeyNotAuthorizedForPortfolio

interface: api.errors.portfolio.SecondaryKeyNotAuthorizedForPortfolio.is
summary: The secondary key is not authorized to access the portfolio(s).

UnauthorizedCustodian

interface: api.errors.portfolio.UnauthorizedCustodian.is
summary: The porfolio's custody is with someone other than the caller.

protocolFee

InsufficientAccountBalance

interface: api.errors.protocolFee.InsufficientAccountBalance.is
summary: Insufficient account balance to pay the fee.

InsufficientSubsidyBalance

interface: api.errors.protocolFee.InsufficientSubsidyBalance.is
summary: Insufficient subsidy balance to pay the fee.

UnHandledImbalances

interface: api.errors.protocolFee.UnHandledImbalances.is
summary: Not able to handled the imbalances

relayer

NoPayingKey

interface: api.errors.relayer.NoPayingKey.is
summary: The user_key doesn't have a paying_key.

NotAuthorizedForPayingKey

interface: api.errors.relayer.NotAuthorizedForPayingKey.is
summary: The signer is not authorized for paying_key.

NotAuthorizedForUserKey

interface: api.errors.relayer.NotAuthorizedForUserKey.is
summary: The signer is not authorized for user_key.

NotPayingKey

interface: api.errors.relayer.NotPayingKey.is
summary: The user_key has a different paying_key.

Overflow

interface: api.errors.relayer.Overflow.is
summary: The remaining POLYX for user_key overflowed.

PayingKeyCddMissing

interface: api.errors.relayer.PayingKeyCddMissing.is
summary: The user_key is not attached to a CDD'd identity.

UserKeyCddMissing

interface: api.errors.relayer.UserKeyCddMissing.is
summary: The user_key is not attached to a CDD'd identity.

rewards

InvalidSignature

interface: api.errors.rewards.InvalidSignature.is
summary: Provided signature was invalid.

ItnRewardAlreadyClaimed

interface: api.errors.rewards.ItnRewardAlreadyClaimed.is
summary: Itn reward was already claimed.

UnableToCovertBalance

interface: api.errors.rewards.UnableToCovertBalance.is
summary: Balance can not be converted to a primitive.

UnknownItnAddress

interface: api.errors.rewards.UnknownItnAddress.is
summary: Address was not found in the list of Itn addresses.

scheduler

FailedToSchedule

interface: api.errors.scheduler.FailedToSchedule.is
summary: Failed to schedule a call

NotFound

interface: api.errors.scheduler.NotFound.is
summary: Cannot find the scheduled call.

RescheduleNoChange

interface: api.errors.scheduler.RescheduleNoChange.is
summary: Reschedule failed because it does not change scheduled time.

TargetBlockNumberInPast

interface: api.errors.scheduler.TargetBlockNumberInPast.is
summary: Given target block number is in the past.

session

DuplicatedKey

interface: api.errors.session.DuplicatedKey.is
summary: Registered duplicate key.

InvalidProof

interface: api.errors.session.InvalidProof.is
summary: Invalid ownership proof.

NoAccount

interface: api.errors.session.NoAccount.is
summary: Key setting account is not live, so it's impossible to associate keys.

NoAssociatedValidatorId

interface: api.errors.session.NoAssociatedValidatorId.is
summary: No associated validator ID for account.

NoKeys

interface: api.errors.session.NoKeys.is
summary: No keys are associated with this account.

settlement

FailedToLockTokens

interface: api.errors.settlement.FailedToLockTokens.is
summary: While affirming the transfer, system failed to lock the assets involved.

FailedToSchedule

interface: api.errors.settlement.FailedToSchedule.is
summary: Scheduling of an instruction fails.

InstructionDatesInvalid

interface: api.errors.settlement.InstructionDatesInvalid.is
summary: Instruction has invalid dates

InstructionFailed

interface: api.errors.settlement.InstructionFailed.is
summary: Instruction failed to execute.

InstructionHasTooManyLegs

interface: api.errors.settlement.InstructionHasTooManyLegs.is
summary: Maximum legs that can be in a single instruction.

InstructionNotAffirmed

interface: api.errors.settlement.InstructionNotAffirmed.is
summary: Instruction has not been affirmed.

InstructionNotFailed

interface: api.errors.settlement.InstructionNotFailed.is
summary: Provided instruction is not failing execution.

InstructionNotPending

interface: api.errors.settlement.InstructionNotPending.is
summary: Provided instruction is not pending execution.

InstructionSettleBlockPassed

interface: api.errors.settlement.InstructionSettleBlockPassed.is
summary: Instruction's target settle block reached.

InvalidSignature

interface: api.errors.settlement.InvalidSignature.is
summary: Offchain signature is invalid.

InvalidVenue

interface: api.errors.settlement.InvalidVenue.is
summary: Venue does not exist.

LegCountTooSmall

interface: api.errors.settlement.LegCountTooSmall.is
summary: Legs count should matches with the total number of legs in which given portfolio act as from_portfolio.

LegNotPending

interface: api.errors.settlement.LegNotPending.is
summary: Provided leg is not pending execution.

NoPendingAffirm

interface: api.errors.settlement.NoPendingAffirm.is
summary: No pending affirmation for the provided instruction.

NoPortfolioProvided

interface: api.errors.settlement.NoPortfolioProvided.is
summary: Portfolio based actions require at least one portfolio to be provided as input.

PortfolioMismatch

interface: api.errors.settlement.PortfolioMismatch.is
summary: Portfolio in receipt does not match with portfolios provided by the user.

ReceiptAlreadyClaimed

interface: api.errors.settlement.ReceiptAlreadyClaimed.is
summary: Receipt already used.

ReceiptNotClaimed

interface: api.errors.settlement.ReceiptNotClaimed.is
summary: Receipt not used yet.

SameSenderReceiver

interface: api.errors.settlement.SameSenderReceiver.is
summary: Sender and receiver are the same.

SettleOnPastBlock

interface: api.errors.settlement.SettleOnPastBlock.is
summary: The provided settlement block number is in the past and cannot be used by the scheduler.

Unauthorized

interface: api.errors.settlement.Unauthorized.is
summary: Sender does not have required permissions.

UnauthorizedSigner

interface: api.errors.settlement.UnauthorizedSigner.is
summary: Signer is not authorized by the venue.

UnauthorizedVenue

interface: api.errors.settlement.UnauthorizedVenue.is
summary: Venue does not have required permissions.

UnexpectedAffirmationStatus

interface: api.errors.settlement.UnexpectedAffirmationStatus.is
summary: The current instruction affirmation status does not support the requested action.

UnknownInstruction

interface: api.errors.settlement.UnknownInstruction.is
summary: Instruction status is unknown

staking

AlreadyBonded

interface: api.errors.staking.AlreadyBonded.is
summary: Stash is already bonded.

AlreadyClaimed

interface: api.errors.staking.AlreadyClaimed.is
summary: Rewards for this era have already been claimed for this validator.

AlreadyExists

interface: api.errors.staking.AlreadyExists.is
summary: Permissioned validator already exists.

AlreadyPaired

interface: api.errors.staking.AlreadyPaired.is
summary: Controller is already paired.

BadState

interface: api.errors.staking.BadState.is
summary: Internal state has become somehow corrupted and the operation cannot continue.

BadTarget

interface: api.errors.staking.BadTarget.is
summary: A nomination target was supplied that was blocked or otherwise not a validator.

BondTooSmall

interface: api.errors.staking.BondTooSmall.is
summary: When the amount to be bonded is less than MinimumBond

CallNotAllowed

interface: api.errors.staking.CallNotAllowed.is
summary: The call is not allowed at the given time due to restrictions of election period.

EmptyTargets

interface: api.errors.staking.EmptyTargets.is
summary: Targets cannot be empty.

FundedTarget

interface: api.errors.staking.FundedTarget.is
summary: Attempting to target a stash that still has funds.

HitIntendedValidatorCount

interface: api.errors.staking.HitIntendedValidatorCount.is
summary: Running validator count hit the intended count.

IncorrectSlashingSpans

interface: api.errors.staking.IncorrectSlashingSpans.is
summary: Incorrect number of slashing spans provided.

InsufficientValue

interface: api.errors.staking.InsufficientValue.is
summary: Can not bond with value less than minimum balance.

IntendedCountIsExceedingConsensusLimit

interface: api.errors.staking.IntendedCountIsExceedingConsensusLimit.is
summary: When the intended number of validators to run is >= 2/3 of validator_count.

InvalidEraToReward

interface: api.errors.staking.InvalidEraToReward.is
summary: Invalid era to reward.

InvalidSlashIndex

interface: api.errors.staking.InvalidSlashIndex.is
summary: Slash record index out of bounds.

InvalidValidatorCommission

interface: api.errors.staking.InvalidValidatorCommission.is
summary: Validator prefs are not in valid range.

InvalidValidatorIdentity

interface: api.errors.staking.InvalidValidatorIdentity.is
summary: Given potential validator identity is invalid.

NoChange

interface: api.errors.staking.NoChange.is
summary: Updates with same value.

NoMoreChunks

interface: api.errors.staking.NoMoreChunks.is
summary: Can not schedule more unlock chunks.

NotController

interface: api.errors.staking.NotController.is
summary: Not a controller account.

NotExists

interface: api.errors.staking.NotExists.is
summary: Permissioned validator not exists.

NotSortedAndUnique

interface: api.errors.staking.NotSortedAndUnique.is
summary: Items are not sorted and unique.

NotStash

interface: api.errors.staking.NotStash.is
summary: Not a stash account.

NoUnlockChunk

interface: api.errors.staking.NoUnlockChunk.is
summary: Can not rebond without unlocking chunks.

OffchainElectionBogusCompact

interface: api.errors.staking.OffchainElectionBogusCompact.is
summary: Error while building the assignment type from the compact. This can happen if an index is invalid, or if the weights overflow.

OffchainElectionBogusEdge

interface: api.errors.staking.OffchainElectionBogusEdge.is
summary: The submitted result has unknown edges that are not among the presented winners.

OffchainElectionBogusElectionSize

interface: api.errors.staking.OffchainElectionBogusElectionSize.is
summary: The election size is invalid.

OffchainElectionBogusNomination

interface: api.errors.staking.OffchainElectionBogusNomination.is
summary: One of the submitted nominators has an edge to which they have not voted on chain.

OffchainElectionBogusNominator

interface: api.errors.staking.OffchainElectionBogusNominator.is
summary: One of the submitted nominators is not an active nominator on chain.

OffchainElectionBogusScore

interface: api.errors.staking.OffchainElectionBogusScore.is
summary: The claimed score does not match with the one computed from the data.

OffchainElectionBogusSelfVote

interface: api.errors.staking.OffchainElectionBogusSelfVote.is
summary: A self vote must only be originated from a validator to ONLY themselves.

OffchainElectionBogusWinner

interface: api.errors.staking.OffchainElectionBogusWinner.is
summary: One of the submitted winners is not an active candidate on chain (index is out of range in snapshot).

OffchainElectionBogusWinnerCount

interface: api.errors.staking.OffchainElectionBogusWinnerCount.is
summary: Incorrect number of winners were presented.

OffchainElectionEarlySubmission

interface: api.errors.staking.OffchainElectionEarlySubmission.is
summary: The submitted result is received out of the open window.

OffchainElectionSlashedNomination

interface: api.errors.staking.OffchainElectionSlashedNomination.is
summary: One of the submitted nominators has an edge which is submitted before the last non-zero slash of the target.

OffchainElectionWeakSubmission

interface: api.errors.staking.OffchainElectionWeakSubmission.is
summary: The submitted result is not as good as the one stored on chain.

SnapshotUnavailable

interface: api.errors.staking.SnapshotUnavailable.is
summary: The snapshot data of the current window is missing.

StashIdentityDoesNotExist

interface: api.errors.staking.StashIdentityDoesNotExist.is
summary: Validator or nominator stash identity does not exist.

StashIdentityNotCDDed

interface: api.errors.staking.StashIdentityNotCDDed.is
summary: Nominator stash was not CDDed.

StashIdentityNotPermissioned

interface: api.errors.staking.StashIdentityNotPermissioned.is
summary: Validator stash identity was not permissioned.

TooManyTargets

interface: api.errors.staking.TooManyTargets.is
summary: Too many nomination targets supplied.

statistics

DuplicateTransferManager

interface: api.errors.statistics.DuplicateTransferManager.is
summary: The transfer manager already exists

InvalidTransfer

interface: api.errors.statistics.InvalidTransfer.is
summary: Transfer not allowed

TransferManagerMissing

interface: api.errors.statistics.TransferManagerMissing.is
summary: Transfer manager is not enabled

TransferManagersLimitReached

interface: api.errors.statistics.TransferManagersLimitReached.is
summary: The limit of transfer managers allowed for an asset has been reached

sto

FundraiserClosed

interface: api.errors.sto.FundraiserClosed.is
summary: Fundraiser has been closed/stopped already.

FundraiserExpired

interface: api.errors.sto.FundraiserExpired.is
summary: Interacting with a fundraiser past the end Moment.

FundraiserNotFound

interface: api.errors.sto.FundraiserNotFound.is
summary: Fundraiser not found.

FundraiserNotLive

interface: api.errors.sto.FundraiserNotLive.is
summary: Fundraiser is either frozen or stopped.

InsufficientTokensRemaining

interface: api.errors.sto.InsufficientTokensRemaining.is
summary: Not enough tokens left for sale.

InvalidOfferingWindow

interface: api.errors.sto.InvalidOfferingWindow.is
summary: Window (start time, end time) has invalid parameters, e.g start time is after end time.

InvalidPriceTiers

interface: api.errors.sto.InvalidPriceTiers.is
summary: An individual price tier was invalid or a set of price tiers was invalid.

InvalidVenue

interface: api.errors.sto.InvalidVenue.is
summary: An invalid venue provided.

InvestmentAmountTooLow

interface: api.errors.sto.InvestmentAmountTooLow.is
summary: Investment amount is lower than minimum investment amount.

MaxPriceExceeded

interface: api.errors.sto.MaxPriceExceeded.is
summary: Price of the investment exceeded the max price.

Overflow

interface: api.errors.sto.Overflow.is
summary: An arithmetic operation overflowed.

Unauthorized

interface: api.errors.sto.Unauthorized.is
summary: Sender does not have required permissions.

sudo

RequireSudo

interface: api.errors.sudo.RequireSudo.is
summary: Sender must be the Sudo account

system

FailedToExtractRuntimeVersion

interface: api.errors.system.FailedToExtractRuntimeVersion.is
summary: Failed to extract the runtime version from the new runtime.

Either calling Core_version or decoding RuntimeVersion failed.

InvalidSpecName

interface: api.errors.system.InvalidSpecName.is
summary: The name of specification does not match between the current runtime and the new runtime.

NonDefaultComposite

interface: api.errors.system.NonDefaultComposite.is
summary: Suicide called when the account has non-default composite data.

NonZeroRefCount

interface: api.errors.system.NonZeroRefCount.is
summary: There is a non-zero reference count preventing the account from being purged.

SpecVersionNeedsToIncrease

interface: api.errors.system.SpecVersionNeedsToIncrease.is
summary: The specification version is not allowed to decrease between the current runtime and the new runtime.

technicalCommittee

DuplicateProposal

interface: api.errors.technicalCommittee.DuplicateProposal.is
summary: Duplicate proposal.

DuplicateVote

interface: api.errors.technicalCommittee.DuplicateVote.is
summary: Duplicate votes are not allowed.

FirstVoteReject

interface: api.errors.technicalCommittee.FirstVoteReject.is
summary: First vote on a proposal creates it, so it must be an approval. All proposals are motions to execute something as "GC majority". To reject e.g., a PIP, a motion to reject should be approved.

InvalidProportion

interface: api.errors.technicalCommittee.InvalidProportion.is
summary: Proportion must be a rational number.

MismatchedVotingIndex

interface: api.errors.technicalCommittee.MismatchedVotingIndex.is
summary: Mismatched voting index.

NoSuchProposal

interface: api.errors.technicalCommittee.NoSuchProposal.is
summary: No such proposal.

NotAMember

interface: api.errors.technicalCommittee.NotAMember.is
summary: A DID isn't part of the committee. The DID may either be a caller or some other context.

ProposalExpired

interface: api.errors.technicalCommittee.ProposalExpired.is
summary: Proposal exists, but it has expired.

ProposalsLimitReached

interface: api.errors.technicalCommittee.ProposalsLimitReached.is
summary: Maximum number of proposals has been reached.

technicalCommitteeMembership

ActiveMembersLimitExceeded

interface: api.errors.technicalCommitteeMembership.ActiveMembersLimitExceeded.is
summary: The limit for the number of concurrent active members for this group has been exceeded.

ActiveMembersLimitOverflow

interface: api.errors.technicalCommitteeMembership.ActiveMembersLimitOverflow.is
summary: Active member limit was greater than maximum committee members limit.

DuplicateMember

interface: api.errors.technicalCommitteeMembership.DuplicateMember.is
summary: Group member was added already.

LastMemberCannotQuit

interface: api.errors.technicalCommitteeMembership.LastMemberCannotQuit.is
summary: Last member of the committee can not quit.

MissingCurrentIdentity

interface: api.errors.technicalCommitteeMembership.MissingCurrentIdentity.is
summary: Missing current DID

NoSuchMember

interface: api.errors.technicalCommitteeMembership.NoSuchMember.is
summary: Can't remove a member that doesn't exist.

OnlyPrimaryKeyAllowed

interface: api.errors.technicalCommitteeMembership.OnlyPrimaryKeyAllowed.is
summary: Only primary key of the identity is allowed.

treasury

InsufficientBalance

interface: api.errors.treasury.InsufficientBalance.is
summary: Proposer's balance is too low.

upgradeCommittee

DuplicateProposal

interface: api.errors.upgradeCommittee.DuplicateProposal.is
summary: Duplicate proposal.

DuplicateVote

interface: api.errors.upgradeCommittee.DuplicateVote.is
summary: Duplicate votes are not allowed.

FirstVoteReject

interface: api.errors.upgradeCommittee.FirstVoteReject.is
summary: First vote on a proposal creates it, so it must be an approval. All proposals are motions to execute something as "GC majority". To reject e.g., a PIP, a motion to reject should be approved.

InvalidProportion

interface: api.errors.upgradeCommittee.InvalidProportion.is
summary: Proportion must be a rational number.

MismatchedVotingIndex

interface: api.errors.upgradeCommittee.MismatchedVotingIndex.is
summary: Mismatched voting index.

NoSuchProposal

interface: api.errors.upgradeCommittee.NoSuchProposal.is
summary: No such proposal.

NotAMember

interface: api.errors.upgradeCommittee.NotAMember.is
summary: A DID isn't part of the committee. The DID may either be a caller or some other context.

ProposalExpired

interface: api.errors.upgradeCommittee.ProposalExpired.is
summary: Proposal exists, but it has expired.

ProposalsLimitReached

interface: api.errors.upgradeCommittee.ProposalsLimitReached.is
summary: Maximum number of proposals has been reached.

upgradeCommitteeMembership

ActiveMembersLimitExceeded

interface: api.errors.upgradeCommitteeMembership.ActiveMembersLimitExceeded.is
summary: The limit for the number of concurrent active members for this group has been exceeded.

ActiveMembersLimitOverflow

interface: api.errors.upgradeCommitteeMembership.ActiveMembersLimitOverflow.is
summary: Active member limit was greater than maximum committee members limit.

DuplicateMember

interface: api.errors.upgradeCommitteeMembership.DuplicateMember.is
summary: Group member was added already.

LastMemberCannotQuit

interface: api.errors.upgradeCommitteeMembership.LastMemberCannotQuit.is
summary: Last member of the committee can not quit.

MissingCurrentIdentity

interface: api.errors.upgradeCommitteeMembership.MissingCurrentIdentity.is
summary: Missing current DID

NoSuchMember

interface: api.errors.upgradeCommitteeMembership.NoSuchMember.is
summary: Can't remove a member that doesn't exist.

OnlyPrimaryKeyAllowed

interface: api.errors.upgradeCommitteeMembership.OnlyPrimaryKeyAllowed.is
summary: Only primary key of the identity is allowed.

utility

InvalidNonce

interface: api.errors.utility.InvalidNonce.is
summary: Provided nonce was invalid If the provided nonce < current nonce, the call was already executed If the provided nonce > current nonce, the call(s) before the current failed to execute

InvalidSignature

interface: api.errors.utility.InvalidSignature.is
summary: Offchain signature is invalid

TargetCddMissing

interface: api.errors.utility.TargetCddMissing.is
summary: Target does not have a valid CDD

title: JSON-RPC

The following sections contain RPC methods that are Remote Calls available by default and allow you to interact with the actual node, query, and submit.

author
babe
beefy
chain
childstate
contracts
dev
engine
eth
eth/net
eth/web3
grandpa
mmr
offchain
payment
rpc
state
syncstate
system

author

hasKey(publicKey: `Bytes`, keyType: `Text`): `bool`

interface: api.rpc.author.hasKey
jsonrpc: author_hasKey
summary: Returns true if the keystore has private keys for the given public key and key type.

hasSessionKeys(sessionKeys: `Bytes`): `bool`

interface: api.rpc.author.hasSessionKeys
jsonrpc: author_hasSessionKeys
summary: Returns true if the keystore has private keys for the given session public keys.

insertKey(keyType: `Text`, suri: `Text`, publicKey: `Bytes`): `Bytes`

interface: api.rpc.author.insertKey
jsonrpc: author_insertKey
summary: Insert a key into the keystore.

pendingExtrinsics(): `Vec<Extrinsic>`

interface: api.rpc.author.pendingExtrinsics
jsonrpc: author_pendingExtrinsics
summary: Returns all pending extrinsics, potentially grouped by sender

removeExtrinsic(bytesOrHash: `Vec<ExtrinsicOrHash>`): `Vec<Hash>`

interface: api.rpc.author.removeExtrinsic
jsonrpc: author_removeExtrinsic
summary: Remove given extrinsic from the pool and temporarily ban it to prevent reimporting

rotateKeys(): `Bytes`

interface: api.rpc.author.rotateKeys
jsonrpc: author_rotateKeys
summary: Generate new session keys and returns the corresponding public keys

submitAndWatchExtrinsic(extrinsic: `Extrinsic`): `ExtrinsicStatus`

interface: api.rpc.author.submitAndWatchExtrinsic
jsonrpc: author_submitAndWatchExtrinsic
summary: Submit and subscribe to watch an extrinsic until unsubscribed

submitExtrinsic(extrinsic: `Extrinsic`): `Hash`

interface: api.rpc.author.submitExtrinsic
jsonrpc: author_submitExtrinsic
summary: Submit a fully formatted extrinsic for block inclusion

babe

epochAuthorship(): `HashMap<AuthorityId, EpochAuthorship>`

interface: api.rpc.babe.epochAuthorship
jsonrpc: babe_epochAuthorship
summary: Returns data about which slots (primary or secondary) can be claimed in the current epoch with the keys in the keystore

beefy

getFinalizedHead(): `H256`

interface: api.rpc.beefy.getFinalizedHead
jsonrpc: beefy_getFinalizedHead
summary: Returns hash of the latest BEEFY finalized block as seen by this client.

subscribeJustifications(): `BeefySignedCommitment`

interface: api.rpc.beefy.subscribeJustifications
jsonrpc: beefy_subscribeJustifications
summary: Returns the block most recently finalized by BEEFY, alongside side its justification.

chain

getBlock(hash?: `BlockHash`): `SignedBlock`

interface: api.rpc.chain.getBlock
jsonrpc: chain_getBlock
summary: Get header and body of a relay chain block

getBlockHash(blockNumber?: `BlockNumber`): `BlockHash`

interface: api.rpc.chain.getBlockHash
jsonrpc: chain_getBlockHash
summary: Get the block hash for a specific block

getFinalizedHead(): `BlockHash`

interface: api.rpc.chain.getFinalizedHead
jsonrpc: chain_getFinalizedHead
summary: Get hash of the last finalized block in the canon chain

getHeader(hash?: `BlockHash`): `Header`

interface: api.rpc.chain.getHeader
jsonrpc: chain_getHeader
summary: Retrieves the header for a specific block

subscribeAllHeads(): `Header`

interface: api.rpc.chain.subscribeAllHeads
jsonrpc: chain_subscribeAllHeads
summary: Retrieves the newest header via subscription

subscribeFinalizedHeads(): `Header`

interface: api.rpc.chain.subscribeFinalizedHeads
jsonrpc: chain_subscribeFinalizedHeads
summary: Retrieves the best finalized header via subscription

subscribeNewHeads(): `Header`

interface: api.rpc.chain.subscribeNewHeads
jsonrpc: chain_subscribeNewHeads
summary: Retrieves the best header via subscription

childstate

getKeys(childKey: `PrefixedStorageKey`, prefix: `StorageKey`, at?: `Hash`): `Vec<StorageKey>`

interface: api.rpc.childstate.getKeys
jsonrpc: childstate_getKeys
summary: Returns the keys with prefix from a child storage, leave empty to get all the keys

getKeysPaged(childKey: `PrefixedStorageKey`, prefix: `StorageKey`, count: `u32`, startKey?: `StorageKey`, at?: `Hash`): `Vec<StorageKey>`

interface: api.rpc.childstate.getKeysPaged
jsonrpc: childstate_getKeysPaged
summary: Returns the keys with prefix from a child storage with pagination support

getStorage(childKey: `PrefixedStorageKey`, key: `StorageKey`, at?: `Hash`): `Option<StorageData>`

interface: api.rpc.childstate.getStorage
jsonrpc: childstate_getStorage
summary: Returns a child storage entry at a specific block state

getStorageEntries(childKey: `PrefixedStorageKey`, keys: `Vec<StorageKey>`, at?: `Hash`): `Vec<Option<StorageData>>`

interface: api.rpc.childstate.getStorageEntries
jsonrpc: childstate_getStorageEntries
summary: Returns child storage entries for multiple keys at a specific block state

getStorageHash(childKey: `PrefixedStorageKey`, key: `StorageKey`, at?: `Hash`): `Option<Hash>`

interface: api.rpc.childstate.getStorageHash
jsonrpc: childstate_getStorageHash
summary: Returns the hash of a child storage entry at a block state

getStorageSize(childKey: `PrefixedStorageKey`, key: `StorageKey`, at?: `Hash`): `Option<u64>`

interface: api.rpc.childstate.getStorageSize
jsonrpc: childstate_getStorageSize
summary: Returns the size of a child storage entry at a block state

contracts

call(callRequest: `ContractCallRequest`, at?: `BlockHash`): `ContractExecResult`

interface: api.rpc.contracts.call
jsonrpc: contracts_call
summary: Executes a call to a contract

getStorage(address: `AccountId`, key: `H256`, at?: `BlockHash`): `Option<Bytes>`

interface: api.rpc.contracts.getStorage
jsonrpc: contracts_getStorage
summary: Returns the value under a specified storage key in a contract

instantiate(request: `InstantiateRequest`, at?: `BlockHash`): `ContractInstantiateResult`

interface: api.rpc.contracts.instantiate
jsonrpc: contracts_instantiate
summary: Instantiate a new contract

rentProjection(address: `AccountId`, at?: `BlockHash`): `Option<BlockNumber>`

interface: api.rpc.contracts.rentProjection
jsonrpc: contracts_rentProjection
summary: Returns the projected time a given contract will be able to sustain paying its rent

uploadCode(uploadRequest: `CodeUploadRequest`, at?: `BlockHash`): `CodeUploadResult`

interface: api.rpc.contracts.uploadCode
jsonrpc: contracts_upload_code
summary: Upload new code without instantiating a contract from it

dev

getBlockStats(at: `Hash`): `Option<BlockStats>`

interface: api.rpc.dev.getBlockStats
jsonrpc: dev_getBlockStats
summary: Reexecute the specified block_hash and gather statistics while doing so

engine

createBlock(createEmpty: `bool`, finalize: `bool`, parentHash?: `BlockHash`): `CreatedBlock`

interface: api.rpc.engine.createBlock
jsonrpc: engine_createBlock
summary: Instructs the manual-seal authorship task to create a new block

finalizeBlock(hash: `BlockHash`, justification?: `Justification`): `bool`

interface: api.rpc.engine.finalizeBlock
jsonrpc: engine_finalizeBlock
summary: Instructs the manual-seal authorship task to finalize a block

eth

accounts(): `Vec<H160>`

interface: api.rpc.eth.accounts
jsonrpc: eth_accounts
summary: Returns accounts list.

blockNumber(): `U256`

interface: api.rpc.eth.blockNumber
jsonrpc: eth_blockNumber
summary: Returns the blockNumber

call(request: `EthCallRequest`, number?: `BlockNumber`): `Bytes`

interface: api.rpc.eth.call
jsonrpc: eth_call
summary: Call contract, returning the output data.

chainId(): `U64`

interface: api.rpc.eth.chainId
jsonrpc: eth_chainId
summary: Returns the chain ID used for transaction signing at the current best block. None is returned if not available.

coinbase(): `H160`

interface: api.rpc.eth.coinbase
jsonrpc: eth_coinbase
summary: Returns block author.

estimateGas(request: `EthCallRequest`, number?: `BlockNumber`): `U256`

interface: api.rpc.eth.estimateGas
jsonrpc: eth_estimateGas
summary: Estimate gas needed for execution of given contract.

gasPrice(): `U256`

interface: api.rpc.eth.gasPrice
jsonrpc: eth_gasPrice
summary: Returns current gas price.

getBalance(address: `H160`, number?: `BlockNumber`): `U256`

interface: api.rpc.eth.getBalance
jsonrpc: eth_getBalance
summary: Returns balance of the given account.

getBlockByHash(hash: `H256`, full: `bool`): `Option<EthRichBlock>`

interface: api.rpc.eth.getBlockByHash
jsonrpc: eth_getBlockByHash
summary: Returns block with given hash.

getBlockByNumber(block: `BlockNumber`, full: `bool`): `Option<EthRichBlock>`

interface: api.rpc.eth.getBlockByNumber
jsonrpc: eth_getBlockByNumber
summary: Returns block with given number.

getBlockTransactionCountByHash(hash: `H256`): `U256`

interface: api.rpc.eth.getBlockTransactionCountByHash
jsonrpc: eth_getBlockTransactionCountByHash
summary: Returns the number of transactions in a block with given hash.

getBlockTransactionCountByNumber(block: `BlockNumber`): `U256`

interface: api.rpc.eth.getBlockTransactionCountByNumber
jsonrpc: eth_getBlockTransactionCountByNumber
summary: Returns the number of transactions in a block with given block number.

getCode(address: `H160`, number?: `BlockNumber`): `Bytes`

interface: api.rpc.eth.getCode
jsonrpc: eth_getCode
summary: Returns the code at given address at given time (block number).

getFilterChanges(index: `U256`): `EthFilterChanges`

interface: api.rpc.eth.getFilterChanges
jsonrpc: eth_getFilterChanges
summary: Returns filter changes since last poll.

getFilterLogs(index: `U256`): `Vec<EthLog>`

interface: api.rpc.eth.getFilterLogs
jsonrpc: eth_getFilterLogs
summary: Returns all logs matching given filter (in a range 'from' - 'to').

getLogs(filter: `EthFilter`): `Vec<EthLog>`

interface: api.rpc.eth.getLogs
jsonrpc: eth_getLogs
summary: Returns logs matching given filter object.

getProof(address: `H160`, storageKeys: `Vec<H256>`, number: `BlockNumber`): `EthAccount`

interface: api.rpc.eth.getProof
jsonrpc: eth_getProof
summary: Returns proof for account and storage.

getStorageAt(address: `H160`, index: `U256`, number?: `BlockNumber`): `H256`

interface: api.rpc.eth.getStorageAt
jsonrpc: eth_getStorageAt
summary: Returns content of the storage at given address.

getTransactionByBlockHashAndIndex(hash: `H256`, index: `U256`): `EthTransaction`

interface: api.rpc.eth.getTransactionByBlockHashAndIndex
jsonrpc: eth_getTransactionByBlockHashAndIndex
summary: Returns transaction at given block hash and index.

getTransactionByBlockNumberAndIndex(number: `BlockNumber`, index: `U256`): `EthTransaction`

interface: api.rpc.eth.getTransactionByBlockNumberAndIndex
jsonrpc: eth_getTransactionByBlockNumberAndIndex
summary: Returns transaction by given block number and index.

getTransactionByHash(hash: `H256`): `EthTransaction`

interface: api.rpc.eth.getTransactionByHash
jsonrpc: eth_getTransactionByHash
summary: Get transaction by its hash.

getTransactionCount(hash: `H256`, number?: `BlockNumber`): `U256`

interface: api.rpc.eth.getTransactionCount
jsonrpc: eth_getTransactionCount
summary: Returns the number of transactions sent from given address at given time (block number).

getTransactionReceipt(hash: `H256`): `EthReceipt`

interface: api.rpc.eth.getTransactionReceipt
jsonrpc: eth_getTransactionReceipt
summary: Returns transaction receipt by transaction hash.

getUncleByBlockHashAndIndex(hash: `H256`, index: `U256`): `EthRichBlock`

interface: api.rpc.eth.getUncleByBlockHashAndIndex
jsonrpc: eth_getUncleByBlockHashAndIndex
summary: Returns an uncles at given block and index.

getUncleByBlockNumberAndIndex(number: `BlockNumber`, index: `U256`): `EthRichBlock`

interface: api.rpc.eth.getUncleByBlockNumberAndIndex
jsonrpc: eth_getUncleByBlockNumberAndIndex
summary: Returns an uncles at given block and index.

getUncleCountByBlockHash(hash: `H256`): `U256`

interface: api.rpc.eth.getUncleCountByBlockHash
jsonrpc: eth_getUncleCountByBlockHash
summary: Returns the number of uncles in a block with given hash.

getUncleCountByBlockNumber(number: `BlockNumber`): `U256`

interface: api.rpc.eth.getUncleCountByBlockNumber
jsonrpc: eth_getUncleCountByBlockNumber
summary: Returns the number of uncles in a block with given block number.

getWork(): `EthWork`

interface: api.rpc.eth.getWork
jsonrpc: eth_getWork
summary: Returns the hash of the current block, the seedHash, and the boundary condition to be met.

hashrate(): `U256`

interface: api.rpc.eth.hashrate
jsonrpc: eth_hashrate
summary: Returns the number of hashes per second that the node is mining with.

mining(): `bool`

interface: api.rpc.eth.mining
jsonrpc: eth_mining
summary: Returns true if client is actively mining new blocks.

newBlockFilter(): `U256`

interface: api.rpc.eth.newBlockFilter
jsonrpc: eth_newBlockFilter
summary: Returns id of new block filter.

newFilter(filter: `EthFilter`): `U256`

interface: api.rpc.eth.newFilter
jsonrpc: eth_newFilter
summary: Returns id of new filter.

newPendingTransactionFilter(): `U256`

interface: api.rpc.eth.newPendingTransactionFilter
jsonrpc: eth_newPendingTransactionFilter
summary: Returns id of new block filter.

protocolVersion(): `u64`

interface: api.rpc.eth.protocolVersion
jsonrpc: eth_protocolVersion
summary: Returns protocol version encoded as a string (quotes are necessary).

sendRawTransaction(bytes: `Bytes`): `H256`

interface: api.rpc.eth.sendRawTransaction
jsonrpc: eth_sendRawTransaction
summary: Sends signed transaction, returning its hash.

sendTransaction(tx: `EthTransactionRequest`): `H256`

interface: api.rpc.eth.sendTransaction
jsonrpc: eth_sendTransaction
summary: Sends transaction; will block waiting for signer to return the transaction hash

submitHashrate(index: `U256`, hash: `H256`): `bool`

interface: api.rpc.eth.submitHashrate
jsonrpc: eth_submitHashrate
summary: Used for submitting mining hashrate.

submitWork(nonce: `H64`, headerHash: `H256`, mixDigest: `H256`): `bool`

interface: api.rpc.eth.submitWork
jsonrpc: eth_submitWork
summary: Used for submitting a proof-of-work solution.

subscribe(kind: `EthSubKind`, params?: `EthSubParams`): `Null`

interface: api.rpc.eth.subscribe
jsonrpc: eth_subscribe
summary: Subscribe to Eth subscription.

syncing(): `EthSyncStatus`

interface: api.rpc.eth.syncing
jsonrpc: eth_syncing
summary: Returns an object with data about the sync status or false.

uninstallFilter(index: `U256`): `bool`

interface: api.rpc.eth.uninstallFilter
jsonrpc: eth_uninstallFilter
summary: Uninstalls filter.

eth/net

listening(): `bool`

interface: api.rpc.net.listening
jsonrpc: net_listening
summary: Returns true if client is actively listening for network connections. Otherwise false.

peerCount(): `String`

interface: api.rpc.net.peerCount
jsonrpc: net_peerCount
summary: Returns number of peers connected to node.

version(): `String`

interface: api.rpc.net.version
jsonrpc: net_version
summary: Returns protocol version.

eth/web3

clientVersion(): `String`

interface: api.rpc.web3.clientVersion
jsonrpc: web3_clientVersion
summary: Returns current client version.

sha3(data: `Bytes`): `H256`

interface: api.rpc.web3.sha3
jsonrpc: web3_sha3
summary: Returns sha3 of the given data

grandpa

proveFinality(blockNumber: `BlockNumber`): `Option<EncodedFinalityProofs>`

interface: api.rpc.grandpa.proveFinality
jsonrpc: grandpa_proveFinality
summary: Prove finality for the given block number, returning the Justification for the last block in the set.

roundState(): `ReportedRoundStates`

interface: api.rpc.grandpa.roundState
jsonrpc: grandpa_roundState
summary: Returns the state of the current best round state as well as the ongoing background rounds

subscribeJustifications(): `JustificationNotification`

interface: api.rpc.grandpa.subscribeJustifications
jsonrpc: grandpa_subscribeJustifications
summary: Subscribes to grandpa justifications

mmr

generateBatchProof(leafIndices: `Vec<u64>`, at?: `BlockHash`): `MmrLeafProof`

interface: api.rpc.mmr.generateBatchProof
jsonrpc: mmr_generateBatchProof
summary: Generate MMR proof for the given leaf indices.

generateProof(leafIndex: `u64`, at?: `BlockHash`): `MmrLeafBatchProof`

interface: api.rpc.mmr.generateProof
jsonrpc: mmr_generateProof
summary: Generate MMR proof for given leaf index.

offchain

localStorageGet(kind: `StorageKind`, key: `Bytes`): `Option<Bytes>`

interface: api.rpc.offchain.localStorageGet
jsonrpc: offchain_localStorageGet
summary: Get offchain local storage under given key and prefix

localStorageSet(kind: `StorageKind`, key: `Bytes`, value: `Bytes`): `Null`

interface: api.rpc.offchain.localStorageSet
jsonrpc: offchain_localStorageSet
summary: Set offchain local storage under given key and prefix

payment

queryFeeDetails(extrinsic: `Bytes`, at?: `BlockHash`): `FeeDetails`

interface: api.rpc.payment.queryFeeDetails
jsonrpc: payment_queryFeeDetails
summary: Query the detailed fee of a given encoded extrinsic

queryInfo(extrinsic: `Bytes`, at?: `BlockHash`): `RuntimeDispatchInfo`

interface: api.rpc.payment.queryInfo
jsonrpc: payment_queryInfo
summary: Retrieves the fee information for an encoded extrinsic

rpc

methods(): `RpcMethods`

interface: api.rpc.rpc.methods
jsonrpc: rpc_methods
summary: Retrieves the list of RPC methods that are exposed by the node

state

call(method: `Text`, data: `Bytes`, at?: `BlockHash`): `Bytes`

interface: api.rpc.state.call
jsonrpc: state_call
summary: Perform a call to a builtin on the chain

getChildKeys(childStorageKey: `StorageKey`, childDefinition: `StorageKey`, childType: `u32`, key: `StorageKey`, at?: `BlockHash`): `Vec<StorageKey>`

interface: api.rpc.state.getChildKeys
jsonrpc: state_getChildKeys
summary: Retrieves the keys with prefix of a specific child storage

getChildReadProof(childStorageKey: `PrefixedStorageKey`, keys: `Vec<StorageKey>`, at?: `BlockHash`): `ReadProof`

interface: api.rpc.state.getChildReadProof
jsonrpc: state_getChildReadProof
summary: Returns proof of storage for child key entries at a specific block state.

getChildStorage(childStorageKey: `StorageKey`, childDefinition: `StorageKey`, childType: `u32`, key: `StorageKey`, at?: `BlockHash`): `StorageData`

interface: api.rpc.state.getChildStorage
jsonrpc: state_getChildStorage
summary: Retrieves the child storage for a key

getChildStorageHash(childStorageKey: `StorageKey`, childDefinition: `StorageKey`, childType: `u32`, key: `StorageKey`, at?: `BlockHash`): `Hash`

interface: api.rpc.state.getChildStorageHash
jsonrpc: state_getChildStorageHash
summary: Retrieves the child storage hash

getChildStorageSize(childStorageKey: `StorageKey`, childDefinition: `StorageKey`, childType: `u32`, key: `StorageKey`, at?: `BlockHash`): `u64`

interface: api.rpc.state.getChildStorageSize
jsonrpc: state_getChildStorageSize
summary: Retrieves the child storage size

getKeys(key: `StorageKey`, at?: `BlockHash`): `Vec<StorageKey>`

interface: api.rpc.state.getKeys
jsonrpc: state_getKeys
summary: Retrieves the keys with a certain prefix

getKeysPaged(key: `StorageKey`, count: `u32`, startKey?: `StorageKey`, at?: `BlockHash`): `Vec<StorageKey>`

interface: api.rpc.state.getKeysPaged
jsonrpc: state_getKeysPaged
summary: Returns the keys with prefix with pagination support.

getMetadata(at?: `BlockHash`): `Metadata`

interface: api.rpc.state.getMetadata
jsonrpc: state_getMetadata
summary: Returns the runtime metadata

getPairs(prefix: `StorageKey`, at?: `BlockHash`): `Vec<KeyValue>`

interface: api.rpc.state.getPairs
jsonrpc: state_getPairs
summary: Returns the keys with prefix, leave empty to get all the keys (deprecated: Use getKeysPaged)

getReadProof(keys: `Vec<StorageKey>`, at?: `BlockHash`): `ReadProof`

interface: api.rpc.state.getReadProof
jsonrpc: state_getReadProof
summary: Returns proof of storage entries at a specific block state

getRuntimeVersion(at?: `BlockHash`): `RuntimeVersion`

interface: api.rpc.state.getRuntimeVersion
jsonrpc: state_getRuntimeVersion
summary: Get the runtime version

getStorage(key: `StorageKey`, at?: `BlockHash`): `StorageData`

interface: api.rpc.state.getStorage
jsonrpc: state_getStorage
summary: Retrieves the storage for a key

getStorageHash(key: `StorageKey`, at?: `BlockHash`): `Hash`

interface: api.rpc.state.getStorageHash
jsonrpc: state_getStorageHash
summary: Retrieves the storage hash

getStorageSize(key: `StorageKey`, at?: `BlockHash`): `u64`

interface: api.rpc.state.getStorageSize
jsonrpc: state_getStorageSize
summary: Retrieves the storage size

queryStorage(keys: `Vec<StorageKey>`, fromBlock: `Hash`, toBlock?: `BlockHash`): `Vec<StorageChangeSet>`

interface: api.rpc.state.queryStorage
jsonrpc: state_queryStorage
summary: Query historical storage entries (by key) starting from a start block

queryStorageAt(keys: `Vec<StorageKey>`, at?: `BlockHash`): `Vec<StorageChangeSet>`

interface: api.rpc.state.queryStorageAt
jsonrpc: state_queryStorageAt
summary: Query storage entries (by key) starting at block hash given as the second parameter

subscribeRuntimeVersion(): `RuntimeVersion`

interface: api.rpc.state.subscribeRuntimeVersion
jsonrpc: state_subscribeRuntimeVersion
summary: Retrieves the runtime version via subscription

subscribeStorage(keys?: `Vec<StorageKey>`): `StorageChangeSet`

interface: api.rpc.state.subscribeStorage
jsonrpc: state_subscribeStorage
summary: Subscribes to storage changes for the provided keys

traceBlock(block: `Hash`, targets: `Option<Text>`, storageKeys: `Option<Text>`, methods: `Option<Text>`): `TraceBlockResponse`

interface: api.rpc.state.traceBlock
jsonrpc: state_traceBlock
summary: Provides a way to trace the re-execution of a single block

trieMigrationStatus(at?: `BlockHash`): `MigrationStatusResult`

interface: api.rpc.state.trieMigrationStatus
jsonrpc: state_trieMigrationStatus
summary: Check current migration state

syncstate

genSyncSpec(raw: `bool`): `Json`

interface: api.rpc.syncstate.genSyncSpec
jsonrpc: sync_state_genSyncSpec
summary: Returns the json-serialized chainspec running the node, with a sync state.

system

accountNextIndex(accountId: `AccountId`): `Index`

interface: api.rpc.system.accountNextIndex
jsonrpc: system_accountNextIndex
summary: Retrieves the next accountIndex as available on the node

addLogFilter(directives: `Text`): `Null`

interface: api.rpc.system.addLogFilter
jsonrpc: system_addLogFilter
summary: Adds the supplied directives to the current log filter

addReservedPeer(peer: `Text`): `Text`

interface: api.rpc.system.addReservedPeer
jsonrpc: system_addReservedPeer
summary: Adds a reserved peer

chain(): `Text`

interface: api.rpc.system.chain
jsonrpc: system_chain
summary: Retrieves the chain

chainType(): `ChainType`

interface: api.rpc.system.chainType
jsonrpc: system_chainType
summary: Retrieves the chain type

dryRun(extrinsic: `Bytes`, at?: `BlockHash`): `ApplyExtrinsicResult`

interface: api.rpc.system.dryRun
jsonrpc: system_dryRun
summary: Dry run an extrinsic at a given block

health(): `Health`

interface: api.rpc.system.health
jsonrpc: system_health
summary: Return health status of the node

localListenAddresses(): `Vec<Text>`

interface: api.rpc.system.localListenAddresses
jsonrpc: system_localListenAddresses
summary: The addresses include a trailing /p2p/ with the local PeerId, and are thus suitable to be passed to addReservedPeer or as a bootnode address for example

localPeerId(): `Text`

interface: api.rpc.system.localPeerId
jsonrpc: system_localPeerId
summary: Returns the base58-encoded PeerId of the node

name(): `Text`

interface: api.rpc.system.name
jsonrpc: system_name
summary: Retrieves the node name

networkState(): `NetworkState`

interface: api.rpc.system.networkState
jsonrpc: system_networkState
summary: Returns current state of the network

nodeRoles(): `Vec<NodeRole>`

interface: api.rpc.system.nodeRoles
jsonrpc: system_nodeRoles
summary: Returns the roles the node is running as

peers(): `Vec<PeerInfo>`

interface: api.rpc.system.peers
jsonrpc: system_peers
summary: Returns the currently connected peers

properties(): `ChainProperties`

interface: api.rpc.system.properties
jsonrpc: system_properties
summary: Get a custom set of properties as a JSON object, defined in the chain spec

removeReservedPeer(peerId: `Text`): `Text`

interface: api.rpc.system.removeReservedPeer
jsonrpc: system_removeReservedPeer
summary: Remove a reserved peer

reservedPeers(): `Vec<Text>`

interface: api.rpc.system.reservedPeers
jsonrpc: system_reservedPeers
summary: Returns the list of reserved peers

resetLogFilter(): `Null`

interface: api.rpc.system.resetLogFilter
jsonrpc: system_resetLogFilter
summary: Resets the log filter to Substrate defaults

syncState(): `SyncState`

interface: api.rpc.system.syncState
jsonrpc: system_syncState
summary: Returns the state of the syncing of the node

version(): `Text`

interface: api.rpc.system.version
jsonrpc: system_version
summary: Retrieves the version of the node

interface: api.query.asset.aggregateBalance
summary: Store aggregate balance of those identities that has the same ScopeId. (Ticker, ScopeId) => Balance.

assetDocuments(`Ticker, DocumentId`): `Document`

interface: api.query.asset.assetDocuments
summary: Documents attached to an Asset (ticker, doc_id) -> document

assetDocumentsIdSequence(`Ticker`): `DocumentId`

interface: api.query.asset.assetDocumentsIdSequence
summary: Per-ticker document ID counter. (ticker) -> doc_id

assetNames(`Ticker`): `AssetName`

interface: api.query.asset.assetNames
summary: Asset name of the token corresponding to the token ticker. (ticker) -> AssetName

assetOwnershipRelations(`IdentityId, Ticker`): `AssetOwnershipRelation`

interface: api.query.asset.assetOwnershipRelations
summary: Tickers and token owned by a user (user, ticker) -> AssetOwnership

balanceOf(`Ticker, IdentityId`): `Balance`

interface: api.query.asset.balanceOf
summary: The total asset ticker balance per identity. (ticker, DID) -> Balance

balanceOfAtScope(`ScopeId, IdentityId`): `Balance`

interface: api.query.asset.balanceOfAtScope
summary: Balances get stored on the basis of the ScopeId. Right now it is only helpful for the UI purposes but in future it can be used to do miracles on-chain. (ScopeId, IdentityId) => Balance.

classicTickers(`Ticker`): `Option<ClassicTickerRegistration>`

interface: api.query.asset.classicTickers
summary: Ticker registration details on Polymath Classic / Ethereum.

customTypeIdSequence(): `CustomAssetTypeId`

interface: api.query.asset.customTypeIdSequence
summary: The next AssetType::Custom ID in the sequence.

Numbers in the sequence start from 1 rather than 0.

customTypes(`CustomAssetTypeId`): `Bytes`

interface: api.query.asset.customTypes
summary: Maps custom asset type ids to the registered string contents.

customTypesInverse(`Bytes`): `CustomAssetTypeId`

interface: api.query.asset.customTypesInverse
summary: Inverse map of CustomTypes, from registered string contents to custom asset type ids.

disableInvestorUniqueness(`Ticker`): `bool`

interface: api.query.asset.disableInvestorUniqueness
summary: Decides whether investor uniqueness requirement is enforced for this asset. false means that it is enforced.

Ticker => bool.

frozen(`Ticker`): `bool`

interface: api.query.asset.frozen
summary: The set of frozen assets implemented as a membership map. ticker -> bool

fundingRound(`Ticker`): `FundingRoundName`

interface: api.query.asset.fundingRound
summary: The name of the current funding round. ticker -> funding round

identifiers(`Ticker`): `Vec<AssetIdentifier>`

interface: api.query.asset.identifiers
summary: A map of a ticker name and asset identifiers.

issuedInFundingRound(`(Ticker,FundingRoundName)`): `Balance`

interface: api.query.asset.issuedInFundingRound
summary: The total balances of tokens issued in all recorded funding rounds. (ticker, funding round) -> balance

scopeIdOf(`Ticker, IdentityId`): `ScopeId`

interface: api.query.asset.scopeIdOf
summary: Tracks the ScopeId of the identity for a given ticker. (Ticker, IdentityId) => ScopeId.

storageVersion(): `Version`

interface: api.query.asset.storageVersion
summary: Storage version.

tickerConfig(): `TickerRegistrationConfig`

interface: api.query.asset.tickerConfig
summary: Ticker registration config. (ticker) -> TickerRegistrationConfig

tickers(`Ticker`): `TickerRegistration`

interface: api.query.asset.tickers
summary: Ticker registration details. (ticker) -> TickerRegistration

tokens(`Ticker`): `SecurityToken`

interface: api.query.asset.tokens
summary: Details of the token corresponding to the token ticker. (ticker) -> SecurityToken details [returns SecurityToken struct]

authorship

author(): `Option<AccountId>`

interface: api.query.authorship.author
summary: Author of current block.

didSetUncles(): `bool`

interface: api.query.authorship.didSetUncles
summary: Whether uncles were already set in this block.

uncles(): `Vec<UncleEntryItem>`

interface: api.query.authorship.uncles
summary: Uncles

babe

authorities(): `Vec<(AuthorityId,BabeAuthorityWeight)>`

interface: api.query.babe.authorities
summary: Current epoch authorities.

authorVrfRandomness(): `MaybeRandomness`

interface: api.query.babe.authorVrfRandomness
summary: Temporary value (cleared at block finalization) that includes the VRF output generated at this block. This field should always be populated during block processing unless secondary plain slots are enabled (which don't contain a VRF output).

currentSlot(): `Slot`

interface: api.query.babe.currentSlot
summary: Current slot number.

epochIndex(): `u64`

interface: api.query.babe.epochIndex
summary: Current epoch index.

genesisSlot(): `Slot`

interface: api.query.babe.genesisSlot
summary: The slot at which the first epoch actually started. This is 0 until the first block of the chain.

initialized(): `Option<MaybeRandomness>`

interface: api.query.babe.initialized
summary: Temporary value (cleared at block finalization) which is Some if per-block initialization has already been called for current block.

lateness(): `BlockNumber`

interface: api.query.babe.lateness
summary: How late the current block is compared to its parent.

This entry is populated as part of block execution and is cleaned up on block finalization. Querying this storage entry outside of block execution context should always yield zero.

nextAuthorities(): `Vec<(AuthorityId,BabeAuthorityWeight)>`

interface: api.query.babe.nextAuthorities
summary: Next epoch authorities.

nextEpochConfig(): `Option<NextConfigDescriptor>`

interface: api.query.babe.nextEpochConfig
summary: Next epoch configuration, if changed.

nextRandomness(): `Randomness`

interface: api.query.babe.nextRandomness
summary: Next epoch randomness.

randomness(): `Randomness`

interface: api.query.babe.randomness
summary: The epoch randomness for the current epoch.

Security

This MUST NOT be used for gambling, as it can be influenced by a malicious validator in the short term. It MAY be used in many cryptographic protocols, however, so long as one remembers that this (like everything else on-chain) it is public. For example, it can be used where a number is needed that cannot have been chosen by an adversary, for purposes such as public-coin zero-knowledge proofs.

segmentIndex(): `u32`

interface: api.query.babe.segmentIndex
summary: Randomness under construction.

We make a tradeoff between storage accesses and list length. We store the under-construction randomness in segments of up to UNDER_CONSTRUCTION_SEGMENT_LENGTH.

Once a segment reaches this length, we begin the next one. We reset all segments and return to 0 at the beginning of every epoch.

underConstruction(`u32`): `Vec<Randomness>`

interface: api.query.babe.underConstruction
summary: TWOX-NOTE: SegmentIndex is an increasing integer, so this is okay.

balances

locks(`AccountId`): `Vec<BalanceLock>`

interface: api.query.balances.locks
summary: Any liquidity locks on some account balances. NOTE: Should only be accessed when setting, changing and freeing a lock.

totalIssuance(): `Balance`

interface: api.query.balances.totalIssuance
summary: The total units issued in the system.

bridge

admin(): `AccountId`

interface: api.query.bridge.admin
summary: The admin key.

bridgeLimit(): `(Balance,BlockNumber)`

interface: api.query.bridge.bridgeLimit
summary: The maximum number of bridged POLYX per identity within a set interval of blocks. Fields: POLYX amount and the block interval duration.

bridgeLimitExempted(`IdentityId`): `bool`

interface: api.query.bridge.bridgeLimitExempted
summary: Identities not constrained by the bridge limit.

bridgeTxDetails(`AccountId, u32`): `BridgeTxDetail`

interface: api.query.bridge.bridgeTxDetails
summary: Details of bridge transactions identified with pairs of the recipient account and the bridge transaction nonce.

controller(): `AccountId`

interface: api.query.bridge.controller
summary: The multisig account of the bridge controller. The genesis signers accept their authorizations and are able to get their proposals delivered. The bridge creator transfers some POLY to their identity.

freezeAdmins(`AccountId`): `bool`

interface: api.query.bridge.freezeAdmins
summary: Freeze bridge admins. These accounts can only freeze the bridge.

frozen(): `bool`

interface: api.query.bridge.frozen
summary: Whether or not the bridge operation is frozen.

polyxBridged(`IdentityId`): `(Balance,BlockNumber)`

interface: api.query.bridge.polyxBridged
summary: Amount of POLYX bridged by the identity in last block interval. Fields: the bridged amount and the last interval number.

storageVersion(): `Version`

interface: api.query.bridge.storageVersion
summary: Storage version.

timelock(): `BlockNumber`

interface: api.query.bridge.timelock
summary: The bridge transaction timelock period, in blocks, since the acceptance of the transaction proposal during which the admin key can freeze the transaction.

capitalDistribution

distributions(`CAId`): `Option<Distribution>`

interface: api.query.capitalDistribution.distributions
summary: All capital distributions, tied to their respective corporate actions (CAs).

(CAId) => Distribution

holderPaid(`(CAId,IdentityId)`): `bool`

interface: api.query.capitalDistribution.holderPaid
summary: Has an asset holder been paid yet?

(CAId, DID) -> Was DID paid in the CAId?

storageVersion(): `Version`

interface: api.query.capitalDistribution.storageVersion
summary: Storage version.

cddServiceProviders

activeMembers(): `Vec<IdentityId>`

interface: api.query.cddServiceProviders.activeMembers
summary: The current "active" membership, stored as an ordered Vec.

activeMembersLimit(): `u32`

interface: api.query.cddServiceProviders.activeMembersLimit
summary: Limit of how many "active" members there can be.

inactiveMembers(): `Vec<InactiveMember>`

interface: api.query.cddServiceProviders.inactiveMembers
summary: The current "inactive" membership, stored as an ordered Vec.

checkpoint

balance(`(Ticker,CheckpointId), IdentityId`): `Balance`

interface: api.query.checkpoint.balance
summary: Balance of a DID at a checkpoint.

(ticker, did, checkpoint ID) -> Balance of a DID at a checkpoint

balanceUpdates(`Ticker, IdentityId`): `Vec<CheckpointId>`

interface: api.query.checkpoint.balanceUpdates
summary: Checkpoints where a DID's balance was updated. (ticker, did) -> [checkpoint ID where user balance changed]

checkpointIdSequence(`Ticker`): `CheckpointId`

interface: api.query.checkpoint.checkpointIdSequence
summary: Checkpoints ID generator sequence. ID of first checkpoint is 1 instead of 0.

(ticker) -> no. of checkpoints

scheduleIdSequence(`Ticker`): `ScheduleId`

interface: api.query.checkpoint.scheduleIdSequence
summary: Checkpoint schedule ID sequence for tickers.

(ticker) -> schedule ID

schedulePoints(`Ticker, ScheduleId`): `Vec<CheckpointId>`

interface: api.query.checkpoint.schedulePoints
summary: All the checkpoints a given schedule originated.

(ticker, schedule ID) -> [checkpoint ID]

scheduleRefCount(`Ticker, ScheduleId`): `u32`

interface: api.query.checkpoint.scheduleRefCount
summary: How many "strong" references are there to a given ScheduleId?

The presence of a "strong" reference, in the sense of Rc<T>, entails that the referenced schedule cannot be removed. Thus, as long as strong_ref_count(schedule_id) > 0, remove_schedule(schedule_id) will error.

(ticker, schedule ID) -> strong ref count

schedules(`Ticker`): `Vec<StoredSchedule>`

interface: api.query.checkpoint.schedules
summary: Checkpoint schedules for tickers.

(ticker) -> [schedule]

schedulesMaxComplexity(): `u64`

interface: api.query.checkpoint.schedulesMaxComplexity
summary: The maximum complexity allowed for an arbitrary ticker's schedule set (i.e. Schedules storage item below).

storageVersion(): `Version`

interface: api.query.checkpoint.storageVersion
summary: Storage version.

timestamps(`Ticker, CheckpointId`): `Moment`

interface: api.query.checkpoint.timestamps
summary: Checkpoint timestamps.

Every schedule-originated checkpoint maps its ID to its due time. Every checkpoint manually created maps its ID to the time of recording.

(ticker) -> (checkpoint ID) -> checkpoint timestamp

totalSupply(`Ticker, CheckpointId`): `Balance`

interface: api.query.checkpoint.totalSupply
summary: Total supply of the token at the checkpoint.

(ticker, checkpointId) -> total supply at given checkpoint

committeeMembership

activeMembers(): `Vec<IdentityId>`

interface: api.query.committeeMembership.activeMembers
summary: The current "active" membership, stored as an ordered Vec.

activeMembersLimit(): `u32`

interface: api.query.committeeMembership.activeMembersLimit
summary: Limit of how many "active" members there can be.

inactiveMembers(): `Vec<InactiveMember>`

interface: api.query.committeeMembership.inactiveMembers
summary: The current "inactive" membership, stored as an ordered Vec.

complianceManager

assetCompliances(`Ticker`): `AssetCompliance`

interface: api.query.complianceManager.assetCompliances
summary: Asset compliance for a ticker (Ticker -> AssetCompliance)

storageVersion(): `Version`

interface: api.query.complianceManager.storageVersion
summary: Storage version.

trustedClaimIssuer(`Ticker`): `Vec<TrustedIssuer>`

interface: api.query.complianceManager.trustedClaimIssuer
summary: List of trusted claim issuer Ticker -> Issuer Identity

corporateAction

cADocLink(`CAId`): `Vec<DocumentId>`

interface: api.query.corporateAction.cADocLink
summary: Associations from CAs to Documents via their IDs. (CAId => [DocumentId])

The CorporateActions map stores Ticker => LocalId => The CA, so we can infer Ticker => CAId. Therefore, we don't need a double map.

cAIdSequence(`Ticker`): `LocalCAId`

interface: api.query.corporateAction.cAIdSequence
summary: The next per-Ticker CA ID in the sequence. The full ID is defined as a combination of Ticker and a number in this sequence.

corporateActions(`Ticker, LocalCAId`): `Option<CorporateAction>`

interface: api.query.corporateAction.corporateActions
summary: All recorded CAs thus far. Only generic information is stored here. Specific CAKinds, e.g., benefits and corporate ballots, may use additional on-chain storage.

(ticker => local ID => the corporate action)

defaultTargetIdentities(`Ticker`): `TargetIdentities`

interface: api.query.corporateAction.defaultTargetIdentities
summary: The identities targeted by default for CAs for this ticker, either to be excluded or included.

(ticker => target identities)

defaultWithholdingTax(`Ticker`): `Tax`

interface: api.query.corporateAction.defaultWithholdingTax
summary: The default amount of tax to withhold ("withholding tax", WT) for this ticker when distributing dividends.

To understand withholding tax, e.g., let's assume that you hold ACME shares. ACME now decides to distribute 100 SEK to Alice. Alice lives in Sweden, so Skatteverket (the Swedish tax authority) wants 30% of that. Then those 100 * 30% are withheld from Alice, and ACME will send them to Skatteverket.

(ticker => % to withhold)

details(`CAId`): `CADetails`

interface: api.query.corporateAction.details
summary: Associates details in free-form text with a CA by its ID. (CAId => CADetails)

didWithholdingTax(`Ticker`): `Vec<(IdentityId,Tax)>`

interface: api.query.corporateAction.didWithholdingTax
summary: The amount of tax to withhold ("withholding tax", WT) for a certain ticker x DID. If an entry exists for a certain DID, it overrides the default in DefaultWithholdingTax.

(ticker => [(did, % to withhold)]

maxDetailsLength(): `u32`

interface: api.query.corporateAction.maxDetailsLength
summary: Determines the maximum number of bytes that the free-form details of a CA can store.

Note that this is not the number of chars or the number of graphemes. While this may be unnatural in terms of human understanding of a text's length, it more closely reflects actual storage costs ('a' is cheaper to store than an emoji).

storageVersion(): `Version`

interface: api.query.corporateAction.storageVersion
summary: Storage version.

corporateBallot

metas(`CAId`): `Option<BallotMeta>`

interface: api.query.corporateBallot.metas
summary: Metadata of a corporate ballot.

(CAId) => BallotMeta

motionNumChoices(`CAId`): `Vec<u16>`

interface: api.query.corporateBallot.motionNumChoices
summary: Stores how many choices there are in each motion.

At all times, the invariant holds that motion_choices[idx] is equal to metas.unwrap().motions[idx].choices.len(). That is, this is just a cache, used to avoid fetching all the motions with their associated texts.

u16 choices should be more than enough to fit real use cases.

(CAId) => Number of choices in each motion.

rCV(`CAId`): `bool`

interface: api.query.corporateBallot.rCV
summary: Is ranked choice voting (RCV) enabled for this ballot? For an understanding of how RCV is handled, see note on BallotVote's fallback field.

(CAId) => bool

results(`CAId`): `Vec<Balance>`

interface: api.query.corporateBallot.results
summary: Stores the total vote tally on each choice.

RCV is not accounted for, as there are too many wants to interpret the graph, and because it would not be efficient.

(CAId) => [current vote weights]

timeRanges(`CAId`): `Option<BallotTimeRange>`

interface: api.query.corporateBallot.timeRanges
summary: Time details of a corporate ballot associated with a CA. The timestamps denote when voting starts and stops.

(CAId) => BallotTimeRange

votes(`CAId, IdentityId`): `Vec<BallotVote>`

interface: api.query.corporateBallot.votes
summary: Stores each DID's votes in a given ballot. See the documentation of BallotVote for notes on semantics.

(CAId) => (DID) => [vote weight]

User must enter 0 vote weight if they don't want to vote for a choice.

externalAgents

agentOf(`IdentityId, Ticker`): `()`

interface: api.query.externalAgents.agentOf
summary: Maps an agent (IdentityId) to all all Tickers they belong to, if any.

aGIdSequence(`Ticker`): `AGId`

interface: api.query.externalAgents.aGIdSequence
summary: The next per-Ticker AG ID in the sequence.

The full ID is defined as a combination of Ticker and a number in this sequence, which starts from 1, rather than 0.

groupOfAgent(`Ticker, IdentityId`): `Option<AgentGroup>`

interface: api.query.externalAgents.groupOfAgent
summary: Maps agents (IdentityId) for a Ticker to what AG they belong to, if any.

groupPermissions(`Ticker, AGId`): `Option<ExtrinsicPermissions>`

interface: api.query.externalAgents.groupPermissions
summary: For custom AGs of a Ticker, maps to what permissions an agent in that AG would have.

numFullAgents(`Ticker`): `u32`

interface: api.query.externalAgents.numFullAgents
summary: Maps a Ticker to the number of Full agents for it.

grandpa

currentSetId(): `SetId`

interface: api.query.grandpa.currentSetId
summary: The number of changes (both in terms of keys and underlying economic responsibilities) in the "set" of Grandpa validators from genesis.

nextForced(): `Option<BlockNumber>`

interface: api.query.grandpa.nextForced
summary: next block number where we can force a change.

pendingChange(): `Option<StoredPendingChange>`

interface: api.query.grandpa.pendingChange
summary: Pending change: (signaled at, scheduled change).

setIdSession(`SetId`): `Option<SessionIndex>`

interface: api.query.grandpa.setIdSession
summary: A mapping from grandpa set ID to the index of the most recent session for which its members were responsible.

TWOX-NOTE: SetId is not under user control.

stalled(): `Option<(BlockNumber,BlockNumber)>`

interface: api.query.grandpa.stalled
summary: true if we are currently stalled.

state(): `StoredState`

interface: api.query.grandpa.state
summary: State of the current authority set.

identity

accountKeyRefCount(`AccountId`): `u64`

interface: api.query.identity.accountKeyRefCount
summary: How many "strong" references to the account key.

Strong references will block a key from leaving it's identity.

Pallets using "strong" references to account keys:
- Relayer: For user_key and paying_key

authorizations(`Signatory, u64`): `Option<Authorization>`

interface: api.query.identity.authorizations
summary: All authorizations that an identity/key has

authorizationsGiven(`IdentityId, u64`): `Signatory`

interface: api.query.identity.authorizationsGiven
summary: All authorizations that an identity has given. (Authorizer, auth_id -> authorized)

cddAuthForMasterKeyRotation(): `bool`

interface: api.query.identity.cddAuthForMasterKeyRotation
summary: Obsoleted storage variable superceded by CddAuthForPrimaryKeyRotation. It is kept here for the purpose of storage migration.

cddAuthForPrimaryKeyRotation(): `bool`

interface: api.query.identity.cddAuthForPrimaryKeyRotation
summary: A config flag that, if set, instructs an authorization from a CDD provider in order to change the primary key of an identity.

claims(`Claim1stKey, Claim2ndKey`): `IdentityClaim`

interface: api.query.identity.claims
summary: (Target ID, claim type) (issuer,scope) -> Associated claims

currentDid(): `Option<IdentityId>`

interface: api.query.identity.currentDid
summary: It stores the current identity for current transaction.

currentPayer(): `Option<AccountId>`

interface: api.query.identity.currentPayer
summary: It stores the current gas fee payer for the current transaction

didRecords(`IdentityId`): `DidRecord`

interface: api.query.identity.didRecords
summary: DID -> identity info

isDidFrozen(`IdentityId`): `bool`

interface: api.query.identity.isDidFrozen
summary: DID -> bool that indicates if secondary keys are frozen.

keyToIdentityIds(`AccountId`): `IdentityId`

interface: api.query.identity.keyToIdentityIds

multiPurposeNonce(): `u64`

interface: api.query.identity.multiPurposeNonce
summary: Nonce to ensure unique actions. starts from 1.

offChainAuthorizationNonce(`IdentityId`): `AuthorizationNonce`

interface: api.query.identity.offChainAuthorizationNonce
summary: Authorization nonce per Identity. Initially is 0.

storageVersion(): `Version`

interface: api.query.identity.storageVersion
summary: Storage version.

imOnline

authoredBlocks(`SessionIndex, ValidatorId`): `u32`

interface: api.query.imOnline.authoredBlocks
summary: For each session index, we keep a mapping of ValidatorId<T> to the number of blocks authored by the given authority.

heartbeatAfter(): `BlockNumber`

interface: api.query.imOnline.heartbeatAfter
summary: The block number after which it's ok to send heartbeats in current session.

At the beginning of each session we set this to a value that should fall roughly in the middle of the session duration. The idea is to first wait for the validators to produce a block in the current session, so that the heartbeat later on will not be necessary.

keys(): `Vec<AuthorityId>`

interface: api.query.imOnline.keys
summary: The current set of keys that may issue a heartbeat.

receivedHeartbeats(`SessionIndex, AuthIndex`): `Option<Bytes>`

interface: api.query.imOnline.receivedHeartbeats
summary: For each session index, we keep a mapping of AuthIndex to offchain::OpaqueNetworkState.

indices

accounts(`AccountIndex`): `Option<(AccountId,BalanceOf,bool)>`

interface: api.query.indices.accounts
summary: The lookup from index to account.

multiSig

keyToMultiSig(`AccountId`): `AccountId`

interface: api.query.multiSig.keyToMultiSig
summary: Maps a multisig signer key to a multisig address.

multiSigNonce(): `u64`

interface: api.query.multiSig.multiSigNonce
summary: Nonce to ensure unique MultiSig addresses are generated; starts from 1.

multiSigSigners(`AccountId, Signatory`): `Signatory`

interface: api.query.multiSig.multiSigSigners
summary: Signers of a multisig. (multisig, signer) => signer.

multiSigSignsRequired(`AccountId`): `u64`

interface: api.query.multiSig.multiSigSignsRequired
summary: Confirmations required before processing a multisig tx.

multiSigToIdentity(`AccountId`): `IdentityId`

interface: api.query.multiSig.multiSigToIdentity
summary: Maps a multisig account to its identity.

multiSigTxDone(`AccountId`): `u64`

interface: api.query.multiSig.multiSigTxDone
summary: Number of transactions proposed in a multisig. Used as tx id; starts from 0.

numberOfSigners(`AccountId`): `u64`

interface: api.query.multiSig.numberOfSigners
summary: Number of approved/accepted signers of a multisig.

proposalDetail(`(AccountId,u64)`): `ProposalDetails`

interface: api.query.multiSig.proposalDetail
summary: Details of a multisig proposal

proposalIds(`AccountId, Proposal`): `Option<u64>`

interface: api.query.multiSig.proposalIds
summary: A mapping of proposals to their IDs.

proposals(`(AccountId,u64)`): `Option<Proposal>`

interface: api.query.multiSig.proposals
summary: Proposals presented for voting to a multisig (multisig, proposal id) => Option<T::Proposal>.

transactionVersion(): `u32`

interface: api.query.multiSig.transactionVersion
summary: The last transaction version, used for on_runtime_upgrade.

votes(`(AccountId,Signatory,u64)`): `bool`

interface: api.query.multiSig.votes
summary: Individual multisig signer votes. (multi sig, signer, proposal) => vote.

offences

concurrentReportsIndex(`Kind, OpaqueTimeSlot`): `Vec<ReportIdOf>`

interface: api.query.offences.concurrentReportsIndex
summary: A vector of reports of the same kind that happened at the same time slot.

deferredOffences(): `Vec<DeferredOffenceOf>`

interface: api.query.offences.deferredOffences
summary: Deferred reports that have been rejected by the offence handler and need to be submitted at a later time.

reports(`ReportIdOf`): `Option<OffenceDetails>`

interface: api.query.offences.reports
summary: The primary structure that holds all offence records keyed by report identifiers.

reportsByKindIndex(`Kind`): `Bytes`

interface: api.query.offences.reportsByKindIndex
summary: Enumerates all reports of a kind along with the time they happened.

All reports are sorted by the time of offence.

Note that the actual type of this mapping is Vec<u8>, this is because values of different types are not supported at the moment so we are doing the manual serialization.

pips

activePipCount(): `u32`

interface: api.query.pips.activePipCount
summary: Total count of current pending or scheduled PIPs.

activePipLimit(): `u32`

interface: api.query.pips.activePipLimit
summary: The maximum allowed number for ActivePipCount. Once reached, new PIPs cannot be proposed by community members.

committeePips(): `Vec<PipId>`

interface: api.query.pips.committeePips
summary: All existing PIPs where the proposer is a committee. This list is a cache of all ids in Proposals with Proposer::Committee(_).

defaultEnactmentPeriod(): `BlockNumber`

interface: api.query.pips.defaultEnactmentPeriod
summary: Default enactment period that will be use after a proposal is accepted by GC.

deposits(`PipId, AccountId`): `DepositInfo`

interface: api.query.pips.deposits
summary: Those who have locked a deposit. proposal (id, proposer) -> deposit

liveQueue(): `Vec<SnapshottedPip>`

interface: api.query.pips.liveQueue
summary: A live priority queue (lowest priority at index 0) of pending PIPs up to the active limit. Priority is defined by the weight in the SnapshottedPip.

Unlike SnapshotQueue, this queue is live, getting updated with each vote cast. The snapshot is therefore essentially a point-in-time clone of this queue.

maxPipSkipCount(): `SkippedCount`

interface: api.query.pips.maxPipSkipCount
summary: Maximum times a PIP can be skipped before triggering CannotSkipPip in enact_snapshot_results.

minimumProposalDeposit(): `Balance`

interface: api.query.pips.minimumProposalDeposit
summary: The minimum amount to be used as a deposit for community PIP creation.

pendingPipExpiry(): `MaybeBlock`

interface: api.query.pips.pendingPipExpiry
summary: How many blocks will it take, after a Pending PIP expires, assuming it has not transitioned to another ProposalState?

pipIdSequence(): `PipId`

interface: api.query.pips.pipIdSequence
summary: Proposals so far. id can be used to keep track of PIPs off-chain.

pipSkipCount(`PipId`): `SkippedCount`

interface: api.query.pips.pipSkipCount
summary: The number of times a certain PIP has been skipped. Once a (configurable) threshhold is exceeded, a PIP cannot be skipped again.

pipToSchedule(`PipId`): `Option<BlockNumber>`

interface: api.query.pips.pipToSchedule
summary: Maps PIPs to the block at which they will be executed, if any.

proposalMetadata(`PipId`): `Option<PipsMetadata>`

interface: api.query.pips.proposalMetadata
summary: The metadata of the active proposals.

proposalResult(`PipId`): `VotingResult`

interface: api.query.pips.proposalResult
summary: PolymeshVotes on a given proposal, if it is ongoing. proposal id -> vote count

proposals(`PipId`): `Option<Pip>`

interface: api.query.pips.proposals
summary: Actual proposal for a given id, if it's current. proposal id -> proposal

proposalVotes(`PipId, AccountId`): `Option<Vote>`

interface: api.query.pips.proposalVotes
summary: Votes per Proposal and account. Used to avoid double vote issue. (proposal id, account) -> Vote

pruneHistoricalPips(): `bool`

interface: api.query.pips.pruneHistoricalPips
summary: Determines whether historical PIP data is persisted or removed

snapshotIdSequence(): `SnapshotId`

interface: api.query.pips.snapshotIdSequence
summary: Snapshots so far. id can be used to keep track of snapshots off-chain.

snapshotMeta(): `Option<SnapshotMetadata>`

interface: api.query.pips.snapshotMeta
summary: The metadata of the snapshot, if there is one.

snapshotQueue(): `Vec<SnapshottedPip>`

interface: api.query.pips.snapshotQueue
summary: The priority queue (lowest priority at index 0) of PIPs at the point of snapshotting. Priority is defined by the weight in the SnapshottedPip.

A queued PIP can be skipped. Doing so bumps the pip_skip_count. Once a (configurable) threshhold is exceeded, a PIP cannot be skipped again.

storageVersion(): `Version`

interface: api.query.pips.storageVersion

polymeshCommittee

expiresAfter(): `MaybeBlock`

interface: api.query.polymeshCommittee.expiresAfter
summary: Time after which a proposal will expire.

members(): `Vec<IdentityId>`

interface: api.query.polymeshCommittee.members
summary: The current members of the committee.

proposalCount(): `u32`

interface: api.query.polymeshCommittee.proposalCount
summary: Proposals so far.

proposalOf(`Hash`): `Option<Call>`

interface: api.query.polymeshCommittee.proposalOf
summary: Actual proposal for a given hash.

proposals(): `Vec<Hash>`

interface: api.query.polymeshCommittee.proposals
summary: The hashes of the active proposals.

releaseCoordinator(): `Option<IdentityId>`

interface: api.query.polymeshCommittee.releaseCoordinator
summary: Release coordinator.

storageVersion(): `Version`

interface: api.query.polymeshCommittee.storageVersion
summary: Storage version.

voteThreshold(): `(u32,u32)`

interface: api.query.polymeshCommittee.voteThreshold
summary: Vote threshold for an approval.

voting(`Hash`): `Option<PolymeshVotes>`

interface: api.query.polymeshCommittee.voting
summary: PolymeshVotes on a given proposal, if it is ongoing.

portfolio

nameToNumber(`IdentityId, PortfolioName`): `PortfolioNumber`

interface: api.query.portfolio.nameToNumber
summary: Inverse map of Portfolios used to ensure bijectivitiy, and uniqueness of names in Portfolios.

nextPortfolioNumber(`IdentityId`): `PortfolioNumber`

interface: api.query.portfolio.nextPortfolioNumber
summary: The next portfolio sequence number of an identity.

portfolioAssetBalances(`PortfolioId, Ticker`): `Balance`

interface: api.query.portfolio.portfolioAssetBalances
summary: The asset balances of portfolios.

portfolioAssetCount(`PortfolioId`): `u64`

interface: api.query.portfolio.portfolioAssetCount
summary: How many assets with non-zero balance this portfolio contains.

portfolioCustodian(`PortfolioId`): `Option<IdentityId>`

interface: api.query.portfolio.portfolioCustodian
summary: The custodian of a particular portfolio. None implies that the identity owner is the custodian.

portfolioLockedAssets(`PortfolioId, Ticker`): `Balance`

interface: api.query.portfolio.portfolioLockedAssets
summary: Amount of assets locked in a portfolio. These assets show up in portfolio balance but can not be transferred away.

portfolios(`IdentityId, PortfolioNumber`): `PortfolioName`

interface: api.query.portfolio.portfolios
summary: The set of existing portfolios with their names. If a certain pair of a DID and portfolio number maps to None then such a portfolio doesn't exist. Conversely, if a pair maps to Some(name) then such a portfolio exists and is called name.

portfoliosInCustody(`IdentityId, PortfolioId`): `bool`

interface: api.query.portfolio.portfoliosInCustody
summary: Tracks all the portfolios in custody of a particular identity. Only used by the UIs. When true is stored as the value for a given (did, pid), it means that pid is in custody of did. false values are never explicitly stored in the map, and are instead inferred by the absence of a key.

storageVersion(): `Version`

interface: api.query.portfolio.storageVersion
summary: Storage version.

protocolFee

baseFees(`ProtocolOp`): `Balance`

interface: api.query.protocolFee.baseFees
summary: The mapping of operation names to the base fees of those operations.

coefficient(): `PosRatio`

interface: api.query.protocolFee.coefficient
summary: The fee coefficient as a positive rational (numerator, denominator).

randomnessCollectiveFlip

randomMaterial(): `Vec<Hash>`

interface: api.query.randomnessCollectiveFlip.randomMaterial
summary: Series of block headers from the last 81 blocks that acts as random seed material. This is arranged as a ring buffer with block_number % 81 being the index into the Vec of the oldest hash.

relayer

subsidies(`AccountId`): `Option<Subsidy>`

interface: api.query.relayer.subsidies
summary: The subsidy for a user_key if they are being subsidised, as a map user_key => Subsidy.

A key can only have one subsidy at a time. To change subsidisers a key needs to call remove_paying_key to remove the current subsidy, before they can accept a new subsidiser.

rewards

itnRewards(`AccountId`): `Option<ItnRewardStatus>`

interface: api.query.rewards.itnRewards
summary: Map of (Itn Address AccountId) -> (Reward ItnRewardStatus).

scheduler

agenda(`BlockNumber`): `Vec<Option<Scheduled>>`

interface: api.query.scheduler.agenda
summary: Items to be executed, indexed by the block number that they should be executed on.

lookup(`Bytes`): `Option<TaskAddress>`

interface: api.query.scheduler.lookup
summary: Lookup from identity to the block number and index of the task.

storageVersion(): `Releases`

interface: api.query.scheduler.storageVersion
summary: Storage version of the pallet.

New networks start with last version.

session

currentIndex(): `SessionIndex`

interface: api.query.session.currentIndex
summary: Current index of the session.

disabledValidators(): `Vec<u32>`

interface: api.query.session.disabledValidators
summary: Indices of disabled validators.

The set is cleared when on_session_ending returns a new set of identities.

keyOwner(`(KeyTypeId,Bytes)`): `Option<ValidatorId>`

interface: api.query.session.keyOwner
summary: The owner of a key. The key is the KeyTypeId + the encoded key.

nextKeys(`ValidatorId`): `Option<Keys>`

interface: api.query.session.nextKeys
summary: The next session keys for a validator.

queuedChanged(): `bool`

interface: api.query.session.queuedChanged
summary: True if the underlying economic identities or weighting behind the validators has changed in the queued validator set.

queuedKeys(): `Vec<(ValidatorId,Keys)>`

interface: api.query.session.queuedKeys
summary: The queued keys for the next session. When the next session begins, these keys will be used to determine the validator's session keys.

validators(): `Vec<ValidatorId>`

interface: api.query.session.validators
summary: The current set of validators.

settlement

affirmsReceived(`InstructionId, PortfolioId`): `AffirmationStatus`

interface: api.query.settlement.affirmsReceived
summary: Tracks affirmations received for an instruction. (instruction_id, counter_party) -> AffirmationStatus

details(`VenueId`): `VenueDetails`

interface: api.query.settlement.details
summary: Free-form text about a venue. venue_id -> VenueDetails Only needed for the UI.

instructionAffirmsPending(`InstructionId`): `u64`

interface: api.query.settlement.instructionAffirmsPending
summary: Number of affirmations pending before instruction is executed. instruction_id -> affirm_pending

instructionCounter(): `InstructionId`

interface: api.query.settlement.instructionCounter
summary: Number of instructions in the system (It's one more than the actual number)

instructionDetails(`InstructionId`): `Instruction`

interface: api.query.settlement.instructionDetails
summary: Details about an instruction. instruction_id -> instruction_details

instructionLegs(`InstructionId, LegId`): `Leg`

interface: api.query.settlement.instructionLegs
summary: Legs under an instruction. (instruction_id, leg_id) -> Leg

instructionLegStatus(`InstructionId, LegId`): `LegStatus`

interface: api.query.settlement.instructionLegStatus
summary: Status of a leg under an instruction. (instruction_id, leg_id) -> LegStatus

receiptsUsed(`AccountId, u64`): `bool`

interface: api.query.settlement.receiptsUsed
summary: Tracks redemption of receipts. (signer, receipt_uid) -> receipt_used

storageVersion(): `Version`

interface: api.query.settlement.storageVersion
summary: Storage version.

userAffirmations(`PortfolioId, InstructionId`): `AffirmationStatus`

interface: api.query.settlement.userAffirmations
summary: Helps a user track their pending instructions and affirmations (only needed for UI). (counter_party, instruction_id) -> AffirmationStatus

userVenues(`IdentityId`): `Vec<VenueId>`

interface: api.query.settlement.userVenues
summary: Array of venues created by an identity. Only needed for the UI. IdentityId -> Vec<venue_id>

venueAllowList(`Ticker, VenueId`): `bool`

interface: api.query.settlement.venueAllowList
summary: Venues that are allowed to create instructions involving a particular ticker. Only used if filtering is enabled. (ticker, venue_id) -> allowed

venueCounter(): `VenueId`

interface: api.query.settlement.venueCounter
summary: Number of venues in the system (It's one more than the actual number)

venueFiltering(`Ticker`): `bool`

interface: api.query.settlement.venueFiltering
summary: Tracks if a token has enabled filtering venues that can create instructions involving their token. Ticker -> filtering_enabled

venueInfo(`VenueId`): `Option<Venue>`

interface: api.query.settlement.venueInfo
summary: Info about a venue. venue_id -> venue

venueInstructions(`VenueId, InstructionId`): `()`

interface: api.query.settlement.venueInstructions
summary: Instructions under a venue. Only needed for the UI.

venue_id -> instruction_id -> ()

venueSigners(`VenueId, AccountId`): `bool`

interface: api.query.settlement.venueSigners
summary: Signers allowed by the venue. (venue_id, signer) -> bool

staking

activeEra(): `Option<ActiveEraInfo>`

interface: api.query.staking.activeEra
summary: The active era information, it holds index and start.

The active era is the era being currently rewarded. Validator set of this era must be equal to [SessionInterface::validators].

bonded(`AccountId`): `Option<AccountId>`

interface: api.query.staking.bonded
summary: Map from all locked "stash" accounts to the controller account.

bondedEras(): `Vec<(EraIndex,SessionIndex)>`

interface: api.query.staking.bondedEras
summary: A mapping from still-bonded eras to the first session index of that era.

Must contains information for eras for the range: [active_era - bounding_duration; active_era]

canceledSlashPayout(): `BalanceOf`

interface: api.query.staking.canceledSlashPayout
summary: The amount of currency given to reporters of a slash event which was canceled by extraordinary circumstances (e.g. governance).

currentEra(): `Option<EraIndex>`

interface: api.query.staking.currentEra
summary: The current era index.

This is the latest planned era, depending on how the Session pallet queues the validator set, it might be active or not.

earliestUnappliedSlash(): `Option<EraIndex>`

interface: api.query.staking.earliestUnappliedSlash
summary: The earliest era for which we have a pending, unapplied slash.

eraElectionStatus(): `ElectionStatus`

interface: api.query.staking.eraElectionStatus
summary: Flag to control the execution of the offchain election. When Open(_), we accept solutions to be submitted.

erasRewardPoints(`EraIndex`): `EraRewardPoints`

interface: api.query.staking.erasRewardPoints
summary: Rewards for the last HISTORY_DEPTH eras. If reward hasn't been set or has been removed then 0 reward is returned.

erasStakers(`EraIndex, AccountId`): `Exposure`

interface: api.query.staking.erasStakers
summary: Exposure of validator at era.

This is keyed first by the era index to allow bulk deletion and then the stash account.

Is it removed after HISTORY_DEPTH eras. If stakers hasn't been set or has been removed then empty exposure is returned.

erasStakersClipped(`EraIndex, AccountId`): `Exposure`

interface: api.query.staking.erasStakersClipped
summary: Clipped Exposure of validator at era.

This is similar to [ErasStakers] but number of nominators exposed is reduced to the T::MaxNominatorRewardedPerValidator biggest stakers. (Note: the field total and own of the exposure remains unchanged). This is used to limit the i/o cost for the nominator payout.

This is keyed fist by the era index to allow bulk deletion and then the stash account.

Is it removed after HISTORY_DEPTH eras. If stakers hasn't been set or has been removed then empty exposure is returned.

erasStartSessionIndex(`EraIndex`): `Option<SessionIndex>`

interface: api.query.staking.erasStartSessionIndex
summary: The session index at which the era start for the last HISTORY_DEPTH eras.

Note: This tracks the starting session (i.e. session index when era start being active) for the eras in [CurrentEra - HISTORY_DEPTH, CurrentEra].

erasTotalStake(`EraIndex`): `BalanceOf`

interface: api.query.staking.erasTotalStake
summary: The total amount staked for the last HISTORY_DEPTH eras. If total hasn't been set or has been removed then 0 stake is returned.

erasValidatorPrefs(`EraIndex, AccountId`): `ValidatorPrefs`

interface: api.query.staking.erasValidatorPrefs
summary: Similar to ErasStakers, this holds the preferences of validators.

This is keyed first by the era index to allow bulk deletion and then the stash account.

Is it removed after HISTORY_DEPTH eras.

erasValidatorReward(`EraIndex`): `Option<BalanceOf>`

interface: api.query.staking.erasValidatorReward
summary: The total validator era payout for the last HISTORY_DEPTH eras.

Eras that haven't finished yet or has been removed doesn't have reward.

forceEra(): `Forcing`

interface: api.query.staking.forceEra
summary: Mode of era forcing.

historyDepth(): `u32`

interface: api.query.staking.historyDepth
summary: Number of eras to keep in history.

Information is kept for eras in [current_era - history_depth; current_era].

Must be more than the number of eras delayed by session otherwise. I.e. active era must always be in history. I.e. active_era > current_era - history_depth must be guaranteed.

invulnerables(): `Vec<AccountId>`

interface: api.query.staking.invulnerables
summary: Any validators that may never be slashed or forcibly kicked. It's a Vec since they're easy to initialize and the performance hit is minimal (we expect no more than four invulnerables) and restricted to testnets.

isCurrentSessionFinal(): `bool`

interface: api.query.staking.isCurrentSessionFinal
summary: True if the current planned session is final. Note that this does not take era forcing into account.

ledger(`AccountId`): `Option<StakingLedger>`

interface: api.query.staking.ledger
summary: Map from all (unlocked) "controller" accounts to the info regarding the staking.

minimumBondThreshold(): `BalanceOf`

interface: api.query.staking.minimumBondThreshold
summary: The minimum amount with which a validator can bond.

minimumValidatorCount(): `u32`

interface: api.query.staking.minimumValidatorCount
summary: Minimum number of staking participants before emergency conditions are imposed.

nominators(`AccountId`): `Option<Nominations>`

interface: api.query.staking.nominators
summary: The map from nominator stash key to the set of stash keys of all validators to nominate.

nominatorSlashInEra(`EraIndex, AccountId`): `Option<BalanceOf>`

interface: api.query.staking.nominatorSlashInEra
summary: All slashing events on nominators, mapped by era to the highest slash value of the era.

payee(`AccountId`): `RewardDestination`

interface: api.query.staking.payee
summary: Where the reward payment should be made. Keyed by stash.

permissionedIdentity(`IdentityId`): `Option<PermissionedIdentityPrefs>`

interface: api.query.staking.permissionedIdentity
summary: Entities that are allowed to run operator/validator nodes.

queuedElected(): `Option<ElectionResult>`

interface: api.query.staking.queuedElected
summary: The next validator set. At the end of an era, if this is available (potentially from the result of an offchain worker), it is immediately used. Otherwise, the on-chain election is executed.

queuedScore(): `Option<ElectionScore>`

interface: api.query.staking.queuedScore
summary: The score of the current [QueuedElected].

slashingAllowedFor(): `SlashingSwitch`

interface: api.query.staking.slashingAllowedFor

slashingSpans(`AccountId`): `Option<SlashingSpans>`

interface: api.query.staking.slashingSpans
summary: Slashing spans for stash accounts.

slashRewardFraction(): `Perbill`

interface: api.query.staking.slashRewardFraction
summary: The percentage of the slash that is distributed to reporters.

The rest of the slashed value is handled by the Slash.

snapshotNominators(): `Option<Vec<AccountId>>`

interface: api.query.staking.snapshotNominators
summary: Snapshot of nominators at the beginning of the current election window. This should only have a value when [EraElectionStatus] == ElectionStatus::Open(_).

snapshotValidators(): `Option<Vec<AccountId>>`

interface: api.query.staking.snapshotValidators
summary: Snapshot of validators at the beginning of the current election window. This should only have a value when [EraElectionStatus] == ElectionStatus::Open(_).

spanSlash(`(AccountId,SpanIndex)`): `SpanRecord`

interface: api.query.staking.spanSlash
summary: Records information about the maximum slash of a stash within a slashing span, as well as how much reward has been paid out.

storageVersion(): `Releases`

interface: api.query.staking.storageVersion
summary: True if network has been upgraded to this version. Storage version of the pallet.

This is set to v6.0.1 for new networks.

unappliedSlashes(`EraIndex`): `Vec<UnappliedSlash>`

interface: api.query.staking.unappliedSlashes
summary: All unapplied slashes that are queued for later.

validatorCommissionCap(): `Perbill`

interface: api.query.staking.validatorCommissionCap
summary: Every validator has commission that should be in the range [0, Cap].

validatorCount(): `u32`

interface: api.query.staking.validatorCount
summary: The ideal number of staking participants.

validators(`AccountId`): `ValidatorPrefs`

interface: api.query.staking.validators
summary: The map from (wannabe) validator stash key to the preferences of that validator.

validatorSlashInEra(`EraIndex, AccountId`): `Option<(Perbill,BalanceOf)>`

interface: api.query.staking.validatorSlashInEra
summary: All slashing events on validators, mapped by era to the highest slash proportion and slash value of the era.

statistics

activeTransferManagers(`Ticker`): `Vec<TransferManager>`

interface: api.query.statistics.activeTransferManagers
summary: Transfer managers currently enabled for an Asset.

exemptEntities(`(Ticker,TransferManager), ScopeId`): `bool`

interface: api.query.statistics.exemptEntities
summary: Entities exempt from transfer managers. Exemptions requirements are based on TMS. TMs may require just the sender, just the receiver, both or either to be exempted. CTM requires sender to be exempted while PTM requires receiver to be exempted.

investorCountPerAsset(`Ticker`): `Counter`

interface: api.query.statistics.investorCountPerAsset
summary: Number of current investors in an asset.

sto

fundraiserCount(`Ticker`): `FundraiserId`

interface: api.query.sto.fundraiserCount
summary: Total fundraisers created for a token.

fundraiserNames(`Ticker, FundraiserId`): `FundraiserName`

interface: api.query.sto.fundraiserNames
summary: Name for the Fundraiser. Only used offchain. (ticker, fundraiser_id) -> Fundraiser name

fundraisers(`Ticker, FundraiserId`): `Option<Fundraiser>`

interface: api.query.sto.fundraisers
summary: All fundraisers that are currently running. (ticker, fundraiser_id) -> Fundraiser

substrate

These are well-known keys that are always available to the runtime implementation of any Substrate-based network.

changesTrieConfig(): `u32`

interface: api.query.substrate.changesTrieConfig
summary: Changes trie configuration is stored under this key.

childStorageKeyPrefix(): `u32`

interface: api.query.substrate.childStorageKeyPrefix
summary: Prefix of child storage keys.

code(): `Bytes`

interface: api.query.substrate.code
summary: Wasm code of the runtime.

extrinsicIndex(): `u32`

interface: api.query.substrate.extrinsicIndex
summary: Current extrinsic index (u32) is stored under this key.

heapPages(): `u64`

interface: api.query.substrate.heapPages
summary: Number of wasm linear memory pages required for execution of the runtime.

sudo

key(): `AccountId`

interface: api.query.sudo.key
summary: The AccountId of the sudo key.

system

account(`AccountId`): `AccountInfo`

interface: api.query.system.account
summary: The full account information for a particular account ID.

allExtrinsicsLen(): `Option<u32>`

interface: api.query.system.allExtrinsicsLen
summary: Total length (in bytes) for all extrinsics put together, for the current block.

blockHash(`BlockNumber`): `Hash`

interface: api.query.system.blockHash
summary: Map of block numbers to block hashes.

blockWeight(): `ConsumedWeight`

interface: api.query.system.blockWeight
summary: The current weight for the block.

digest(): `DigestOf`

interface: api.query.system.digest
summary: Digest of the current block, also part of the block header.

eventCount(): `EventIndex`

interface: api.query.system.eventCount
summary: The number of events in the Events<T> list.

events(): `Vec<EventRecord>`

interface: api.query.system.events
summary: Events deposited for the current block.

eventTopics(`Hash`): `Vec<(BlockNumber,EventIndex)>`

interface: api.query.system.eventTopics
summary: Mapping between a topic (represented by T::Hash) and a vector of indexes of events in the <Events<T>> list.

All topic vectors have deterministic storage locations depending on the topic. This allows light-clients to leverage the changes trie storage tracking mechanism and in case of changes fetch the list of events of interest.

The value has the type (T::BlockNumber, EventIndex) because if we used only just the EventIndex then in case if the topic has the same contents on the next block no notification will be triggered thus the event might be lost.

executionPhase(): `Option<Phase>`

interface: api.query.system.executionPhase
summary: The execution phase of the block.

extrinsicCount(): `Option<u32>`

interface: api.query.system.extrinsicCount
summary: Total extrinsics count for the current block.

extrinsicData(`u32`): `Bytes`

interface: api.query.system.extrinsicData
summary: Extrinsics data for the current block (maps an extrinsic's index to its data).

lastRuntimeUpgrade(): `Option<LastRuntimeUpgradeInfo>`

interface: api.query.system.lastRuntimeUpgrade
summary: Stores the spec_version and spec_name of when the last runtime upgrade happened.

number(): `BlockNumber`

interface: api.query.system.number
summary: The current block number being processed. Set by execute_block.

parentHash(): `Hash`

interface: api.query.system.parentHash
summary: Hash of the previous block.

upgradedToDualRefCount(): `bool`

interface: api.query.system.upgradedToDualRefCount
summary: True if we have upgraded so that AccountInfo contains two types of RefCount. False (default) if not.

upgradedToU32RefCount(): `bool`

interface: api.query.system.upgradedToU32RefCount
summary: True if we have upgraded so that type RefCount is u32. False (default) if not.