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.)

assets

approveTransfer(id: Compact<u32>, delegate: MultiAddress, amount: Compact<u128>)

  • interface: api.tx.assets.approveTransfer

  • summary: Approve an amount of asset for transfer by a delegated third-party account.

    Origin must be Signed.

    Ensures that ApprovalDeposit worth of Currency is reserved from signing account for the purpose of holding the approval. If some non-zero amount of assets is already approved from signing account to delegate, then it is topped up or unreserved to meet the right value.

    NOTE: The signing account does not need to own amount of assets at the point of making this call.

    • id: The identifier of the asset.

    • delegate: The account to delegate permission to transfer asset.

    • amount: The amount of asset that may be transferred by delegate. If there is already an approval in place, then this acts additively.

    Emits ApprovedTransfer on success.

    Weight: O(1)

burn(id: Compact<u32>, who: MultiAddress, amount: Compact<u128>)

  • interface: api.tx.assets.burn

  • summary: Reduce the balance of who by as much as possible up to amount assets of id.

    Origin must be Signed and the sender should be the Manager of the asset id.

    Bails with NoAccount if the who is already dead.

    • id: The identifier of the asset to have some amount burned.

    • who: The account to be debited from.

    • amount: The maximum amount by which who's balance should be reduced.

    Emits Burned with the actual amount burned. If this takes the balance to below the minimum for the asset, then the amount burned is increased to take it to zero.

    Weight: O(1) Modes: Post-existence of who; Pre & post Zombie-status of who.

cancelApproval(id: Compact<u32>, delegate: MultiAddress)

  • interface: api.tx.assets.cancelApproval

  • summary: Cancel all of some asset approved for delegated transfer by a third-party account.

    Origin must be Signed and there must be an approval in place between signer and delegate.

    Unreserves any deposit previously reserved by approve_transfer for the approval.

    • id: The identifier of the asset.

    • delegate: The account delegated permission to transfer asset.

    Emits ApprovalCancelled on success.

    Weight: O(1)

clearMetadata(id: Compact<u32>)

  • interface: api.tx.assets.clearMetadata

  • summary: Clear the metadata for an asset.

    Origin must be Signed and the sender should be the Owner of the asset id.

    Any deposit is freed for the asset owner.

    • id: The identifier of the asset to clear.

    Emits MetadataCleared.

    Weight: O(1)

create(id: Compact<u32>, admin: MultiAddress, min_balance: u128)

  • interface: api.tx.assets.create

  • summary: Issue a new class of fungible assets from a public origin.

    This new asset class has no assets initially and its owner is the origin.

    The origin must be Signed and the sender must have sufficient funds free.

    Funds of sender are reserved by AssetDeposit.

    Parameters:

    • id: The identifier of the new asset. This must not be currently in use to identify an existing asset.

    • admin: The admin of this class of assets. The admin is the initial address of each member of the asset class's admin team.

    • min_balance: The minimum balance of this new asset that any single account must have. If an account's balance is reduced below this, then it collapses to zero.

    Emits Created event when successful.

    Weight: O(1)

destroy(id: Compact<u32>, witness: PalletAssetsDestroyWitness)

  • interface: api.tx.assets.destroy

  • summary: Destroy a class of fungible assets.

    The origin must conform to ForceOrigin or must be Signed and the sender must be the owner of the asset id.

    • id: The identifier of the asset to be destroyed. This must identify an existing asset.

    Emits Destroyed event when successful.

    NOTE: It can be helpful to first freeze an asset before destroying it so that you can provide accurate witness information and prevent users from manipulating state in a way that can make it harder to destroy.

    Weight: O(c + p + a) where:

    • c = (witness.accounts - witness.sufficients)

    • s = witness.sufficients

    • a = witness.approvals

forceAssetStatus(id: Compact<u32>, owner: MultiAddress, issuer: MultiAddress, admin: MultiAddress, freezer: MultiAddress, min_balance: Compact<u128>, is_sufficient: bool, is_frozen: bool)

  • interface: api.tx.assets.forceAssetStatus

  • summary: Alter the attributes of a given asset.

    Origin must be ForceOrigin.

    • id: The identifier of the asset.

    • owner: The new Owner of this asset.

    • issuer: The new Issuer of this asset.

    • admin: The new Admin of this asset.

    • freezer: The new Freezer of this asset.

    • min_balance: The minimum balance of this new asset that any single account must have. If an account's balance is reduced below this, then it collapses to zero.

    • is_sufficient: Whether a non-zero balance of this asset is deposit of sufficient value to account for the state bloat associated with its balance storage. If set to true, then non-zero balances may be stored without a consumer reference (and thus an ED in the Balances pallet or whatever else is used to control user-account state growth).

    • is_frozen: Whether this asset class is frozen except for permissioned/admin instructions.

    Emits AssetStatusChanged with the identity of the asset.

    Weight: O(1)

forceCancelApproval(id: Compact<u32>, owner: MultiAddress, delegate: MultiAddress)

  • interface: api.tx.assets.forceCancelApproval

  • summary: Cancel all of some asset approved for delegated transfer by a third-party account.

    Origin must be either ForceOrigin or Signed origin with the signer being the Admin account of the asset id.

    Unreserves any deposit previously reserved by approve_transfer for the approval.

    • id: The identifier of the asset.

    • delegate: The account delegated permission to transfer asset.

    Emits ApprovalCancelled on success.

    Weight: O(1)

forceClearMetadata(id: Compact<u32>)

  • interface: api.tx.assets.forceClearMetadata

  • summary: Clear the metadata for an asset.

    Origin must be ForceOrigin.

    Any deposit is returned.

    • id: The identifier of the asset to clear.

    Emits MetadataCleared.

    Weight: O(1)

forceCreate(id: Compact<u32>, owner: MultiAddress, is_sufficient: bool, min_balance: Compact<u128>)

  • interface: api.tx.assets.forceCreate

  • summary: Issue a new class of fungible assets from a privileged origin.

    This new asset class has no assets initially.

    The origin must conform to ForceOrigin.

    Unlike create, no funds are reserved.

    • id: The identifier of the new asset. This must not be currently in use to identify an existing asset.

    • owner: The owner of this class of assets. The owner has full superuser permissions over this asset, but may later change and configure the permissions using transfer_ownership and set_team.

    • min_balance: The minimum balance of this new asset that any single account must have. If an account's balance is reduced below this, then it collapses to zero.

    Emits ForceCreated event when successful.

    Weight: O(1)

forceSetMetadata(id: Compact<u32>, name: Bytes, symbol: Bytes, decimals: u8, is_frozen: bool)

  • interface: api.tx.assets.forceSetMetadata

  • summary: Force the metadata for an asset to some value.

    Origin must be ForceOrigin.

    Any deposit is left alone.

    • id: The identifier of the asset to update.

    • name: The user friendly name of this asset. Limited in length by StringLimit.

    • symbol: The exchange symbol for this asset. Limited in length by StringLimit.

    • decimals: The number of decimals this asset uses to represent one unit.

    Emits MetadataSet.

    Weight: O(N + S) where N and S are the length of the name and symbol respectively.

forceTransfer(id: Compact<u32>, source: MultiAddress, dest: MultiAddress, amount: Compact<u128>)

  • interface: api.tx.assets.forceTransfer

  • summary: Move some assets from one account to another.

    Origin must be Signed and the sender should be the Admin of the asset id.

    • id: The identifier of the asset to have some amount transferred.

    • source: The account to be debited.

    • dest: The account to be credited.

    • amount: The amount by which the source's balance of assets should be reduced and dest's balance increased. The amount actually transferred may be slightly greater in the case that the transfer would otherwise take the source balance above zero but below the minimum balance. Must be greater than zero.

    Emits Transferred with the actual amount transferred. If this takes the source balance to below the minimum for the asset, then the amount transferred is increased to take it to zero.

    Weight: O(1) Modes: Pre-existence of dest; Post-existence of source; Account pre-existence of dest.

freeze(id: Compact<u32>, who: MultiAddress)

  • interface: api.tx.assets.freeze

  • summary: Disallow further unprivileged transfers from an account.

    Origin must be Signed and the sender should be the Freezer of the asset id.

    • id: The identifier of the asset to be frozen.

    • who: The account to be frozen.

    Emits Frozen.

    Weight: O(1)

freezeAsset(id: Compact<u32>)

  • interface: api.tx.assets.freezeAsset

  • summary: Disallow further unprivileged transfers for the asset class.

    Origin must be Signed and the sender should be the Freezer of the asset id.

    • id: The identifier of the asset to be frozen.

    Emits Frozen.

    Weight: O(1)

mint(id: Compact<u32>, beneficiary: MultiAddress, amount: Compact<u128>)

  • interface: api.tx.assets.mint

  • summary: Mint assets of a particular class.

    The origin must be Signed and the sender must be the Issuer of the asset id.

    • id: The identifier of the asset to have some amount minted.

    • beneficiary: The account to be credited with the minted assets.

    • amount: The amount of the asset to be minted.

    Emits Issued event when successful.

    Weight: O(1) Modes: Pre-existing balance of beneficiary; Account pre-existence of beneficiary.

refund(id: Compact<u32>, allow_burn: bool)

  • interface: api.tx.assets.refund

  • summary: Return the deposit (if any) of an asset account.

    The origin must be Signed.

    • id: The identifier of the asset for the account to be created.

    • allow_burn: If true then assets may be destroyed in order to complete the refund.

    Emits Refunded event when successful.

setMetadata(id: Compact<u32>, name: Bytes, symbol: Bytes, decimals: u8)

  • interface: api.tx.assets.setMetadata

  • summary: Set the metadata for an asset.

    Origin must be Signed and the sender should be the Owner of the asset id.

    Funds of sender are reserved according to the formula: MetadataDepositBase + MetadataDepositPerByte * (name.len + symbol.len) taking into account any already reserved funds.

    • id: The identifier of the asset to update.

    • name: The user friendly name of this asset. Limited in length by StringLimit.

    • symbol: The exchange symbol for this asset. Limited in length by StringLimit.

    • decimals: The number of decimals this asset uses to represent one unit.

    Emits MetadataSet.

    Weight: O(1)

setTeam(id: Compact<u32>, issuer: MultiAddress, admin: MultiAddress, freezer: MultiAddress)

  • interface: api.tx.assets.setTeam

  • summary: Change the Issuer, Admin and Freezer of an asset.

    Origin must be Signed and the sender should be the Owner of the asset id.

    • id: The identifier of the asset to be frozen.

    • issuer: The new Issuer of this asset.

    • admin: The new Admin of this asset.

    • freezer: The new Freezer of this asset.

    Emits TeamChanged.

    Weight: O(1)

thaw(id: Compact<u32>, who: MultiAddress)

  • interface: api.tx.assets.thaw

  • summary: Allow unprivileged transfers from an account again.

    Origin must be Signed and the sender should be the Admin of the asset id.

    • id: The identifier of the asset to be frozen.

    • who: The account to be unfrozen.

    Emits Thawed.

    Weight: O(1)

thawAsset(id: Compact<u32>)

  • interface: api.tx.assets.thawAsset

  • summary: Allow unprivileged transfers for the asset again.

    Origin must be Signed and the sender should be the Admin of the asset id.

    • id: The identifier of the asset to be thawed.

    Emits Thawed.

    Weight: O(1)

touch(id: Compact<u32>)

  • interface: api.tx.assets.touch

  • summary: Create an asset account for non-provider assets.

    A deposit will be taken from the signer account.

    • origin: Must be Signed; the signer account must have sufficient funds for a deposit to be taken.

    • id: The identifier of the asset for the account to be created.

    Emits Touched event when successful.

transfer(id: Compact<u32>, target: MultiAddress, amount: Compact<u128>)

  • interface: api.tx.assets.transfer

  • summary: Move some assets from the sender account to another.

    Origin must be Signed.

    • id: The identifier of the asset to have some amount transferred.

    • target: The account to be credited.

    • amount: The amount by which the sender's balance of assets should be reduced and target's balance increased. The amount actually transferred may be slightly greater in the case that the transfer would otherwise take the sender balance above zero but below the minimum balance. Must be greater than zero.

    Emits Transferred with the actual amount transferred. If this takes the source balance to below the minimum for the asset, then the amount transferred is increased to take it to zero.

    Weight: O(1) Modes: Pre-existence of target; Post-existence of sender; Account pre-existence of target.

transferApproved(id: Compact<u32>, owner: MultiAddress, destination: MultiAddress, amount: Compact<u128>)

  • interface: api.tx.assets.transferApproved

  • summary: Transfer some asset balance from a previously delegated account to some third-party account.

    Origin must be Signed and there must be an approval in place by the owner to the signer.

    If the entire amount approved for transfer is transferred, then any deposit previously reserved by approve_transfer is unreserved.

    • id: The identifier of the asset.

    • owner: The account which previously approved for a transfer of at least amount and from which the asset balance will be withdrawn.

    • destination: The account to which the asset balance of amount will be transferred.

    • amount: The amount of assets to transfer.

    Emits TransferredApproved on success.

    Weight: O(1)

transferKeepAlive(id: Compact<u32>, target: MultiAddress, amount: Compact<u128>)

  • interface: api.tx.assets.transferKeepAlive

  • summary: Move some assets from the sender account to another, keeping the sender account alive.

    Origin must be Signed.

    • id: The identifier of the asset to have some amount transferred.

    • target: The account to be credited.

    • amount: The amount by which the sender's balance of assets should be reduced and target's balance increased. The amount actually transferred may be slightly greater in the case that the transfer would otherwise take the sender balance above zero but below the minimum balance. Must be greater than zero.

    Emits Transferred with the actual amount transferred. If this takes the source balance to below the minimum for the asset, then the amount transferred is increased to take it to zero.

    Weight: O(1) Modes: Pre-existence of target; Post-existence of sender; Account pre-existence of target.

transferOwnership(id: Compact<u32>, owner: MultiAddress)

  • interface: api.tx.assets.transferOwnership

  • summary: Change the Owner of an asset.

    Origin must be Signed and the sender should be the Owner of the asset id.

    • id: The identifier of the asset.

    • owner: The new Owner of this asset.

    Emits OwnerChanged.

    Weight: O(1)

authorship

setUncles(new_uncles: Vec<SpRuntimeHeader>)

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

balances

forceTransfer(source: MultiAddress, dest: MultiAddress, value: Compact<u128>)

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

forceUnreserve(who: MultiAddress, amount: u128)

  • interface: api.tx.balances.forceUnreserve

  • summary: Unreserve some balance from a user by force.

    Can only be called by ROOT.

setBalance(who: MultiAddress, new_free: Compact<u128>, new_reserved: Compact<u128>)

  • interface: api.tx.balances.setBalance

  • summary: Set the balances of a given account.

    This will alter FreeBalance and ReservedBalance in storage. it will also alter the total issuance of the system (TotalIssuance) appropriately. If the new free or reserved balance is below the existential deposit, it will reset the account nonce (frame_system::AccountNonce).

    The dispatch origin for this call is root.

transfer(dest: MultiAddress, value: Compact<u128>)

  • interface: api.tx.balances.transfer

  • summary: Transfer some liquid free balance to another account.

    transfer will set the FreeBalance of the sender and receiver. If the sender's account is below the existential deposit as a result of the transfer, the account will be reaped.

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

transferAll(dest: MultiAddress, keep_alive: bool)

  • interface: api.tx.balances.transferAll

  • summary: Transfer the entire transferable balance from the caller account.

    NOTE: This function only attempts to transfer transferable balances. This means that any locked, reserved, or existential deposits (when keep_alive is true), will not be transferred by this function. To ensure that this function results in a killed account, you might need to prepare the account by removing any reference counters, storage deposits, etc...

    The dispatch origin of this call must be Signed.

    • dest: The recipient of the transfer.

    • keep_alive: A boolean to determine if the transfer_all operation should send all of the funds the account has, causing the sender account to be killed (false), or transfer everything except at least the existential deposit, which will guarantee to keep the sender account alive (true). #

transferKeepAlive(dest: MultiAddress, value: Compact<u128>)

  • interface: api.tx.balances.transferKeepAlive

  • summary: Same as the transfer call, but with a check that the transfer will not kill the origin account.

    99% of the time you want transfer instead.

bounties

acceptCurator(bounty_id: Compact<u32>)

  • interface: api.tx.bounties.acceptCurator

  • summary: Accept the curator role for a bounty. A deposit will be reserved from curator and refund upon successful payout.

    May only be called from the curator.

approveBounty(bounty_id: Compact<u32>)

  • interface: api.tx.bounties.approveBounty

  • summary: Approve a bounty proposal. At a later time, the bounty will be funded and become active and the original deposit will be returned.

    May only be called from T::ApproveOrigin.

awardBounty(bounty_id: Compact<u32>, beneficiary: MultiAddress)

  • interface: api.tx.bounties.awardBounty

  • summary: Award bounty to a beneficiary account. The beneficiary will be able to claim the funds after a delay.

    The dispatch origin for this call must be the curator of this bounty.

    • bounty_id: Bounty ID to award.

    • beneficiary: The beneficiary account whom will receive the payout.

claimBounty(bounty_id: Compact<u32>)

  • interface: api.tx.bounties.claimBounty

  • summary: Claim the payout from an awarded bounty after payout delay.

    The dispatch origin for this call must be the beneficiary of this bounty.

    • bounty_id: Bounty ID to claim.

closeBounty(bounty_id: Compact<u32>)

  • interface: api.tx.bounties.closeBounty

  • summary: Cancel a proposed or active bounty. All the funds will be sent to treasury and the curator deposit will be unreserved if possible.

    Only T::RejectOrigin is able to cancel a bounty.

    • bounty_id: Bounty ID to cancel.

extendBountyExpiry(bounty_id: Compact<u32>, remark: Bytes)

  • interface: api.tx.bounties.extendBountyExpiry

  • summary: Extend the expiry time of an active bounty.

    The dispatch origin for this call must be the curator of this bounty.

    • bounty_id: Bounty ID to extend.

    • remark: additional information.

proposeBounty(value: Compact<u128>, description: Bytes)

  • interface: api.tx.bounties.proposeBounty

  • summary: Propose a new bounty.

    The dispatch origin for this call must be Signed.

    Payment: TipReportDepositBase will be reserved from the origin account, as well as DataDepositPerByte for each byte in reason. It will be unreserved upon approval, or slashed when rejected.

    • curator: The curator account whom will manage this bounty.

    • fee: The curator fee.

    • value: The total payment amount of this bounty, curator fee included.

    • description: The description of this bounty.

proposeCurator(bounty_id: Compact<u32>, curator: MultiAddress, fee: Compact<u128>)

  • interface: api.tx.bounties.proposeCurator

  • summary: Assign a curator to a funded bounty.

    May only be called from T::ApproveOrigin.

unassignCurator(bounty_id: Compact<u32>)

  • interface: api.tx.bounties.unassignCurator

  • summary: Unassign curator from a bounty.

    This function can only be called by the RejectOrigin a signed origin.

    If this function is called by the RejectOrigin, we assume that the curator is malicious or inactive. As a result, we will slash the curator when possible.

    If the origin is the curator, we take this as a sign they are unable to do their job and they willingly give up. We could slash them, but for now we allow them to recover their deposit and exit without issue. (We may want to change this if it is abused.)

    Finally, the origin can be anyone if and only if the curator is "inactive". This allows anyone in the community to call out that a curator is not doing their due diligence, and we should pick a new curator. In this case the curator should also be slashed.

childBounties

acceptCurator(parent_bounty_id: Compact<u32>, child_bounty_id: Compact<u32>)

  • interface: api.tx.childBounties.acceptCurator

  • summary: Accept the curator role for the child-bounty.

    The dispatch origin for this call must be the curator of this child-bounty.

    A deposit will be reserved from the curator and refund upon successful payout or cancellation.

    Fee for curator is deducted from curator fee of parent bounty.

    Parent bounty must be in active state, for this child-bounty call to work.

    Child-bounty must be in "CuratorProposed" state, for processing the call. And state of child-bounty is moved to "Active" on successful call completion.

    • parent_bounty_id: Index of parent bounty.

    • child_bounty_id: Index of child bounty.

addChildBounty(parent_bounty_id: Compact<u32>, value: Compact<u128>, description: Bytes)

  • interface: api.tx.childBounties.addChildBounty

  • summary: Add a new child-bounty.

    The dispatch origin for this call must be the curator of parent bounty and the parent bounty must be in "active" state.

    Child-bounty gets added successfully & fund gets transferred from parent bounty to child-bounty account, if parent bounty has enough funds, else the call fails.

    Upper bound to maximum number of active child bounties that can be added are managed via runtime trait config [Config::MaxActiveChildBountyCount].

    If the call is success, the status of child-bounty is updated to "Added".

    • parent_bounty_id: Index of parent bounty for which child-bounty is being added.

    • value: Value for executing the proposal.

    • description: Text description for the child-bounty.

awardChildBounty(parent_bounty_id: Compact<u32>, child_bounty_id: Compact<u32>, beneficiary: MultiAddress)

  • interface: api.tx.childBounties.awardChildBounty

  • summary: Award child-bounty to a beneficiary.

    The beneficiary will be able to claim the funds after a delay.

    The dispatch origin for this call must be the parent curator or curator of this child-bounty.

    Parent bounty must be in active state, for this child-bounty call to work.

    Child-bounty must be in active state, for processing the call. And state of child-bounty is moved to "PendingPayout" on successful call completion.

    • parent_bounty_id: Index of parent bounty.

    • child_bounty_id: Index of child bounty.

    • beneficiary: Beneficiary account.

claimChildBounty(parent_bounty_id: Compact<u32>, child_bounty_id: Compact<u32>)

  • interface: api.tx.childBounties.claimChildBounty

  • summary: Claim the payout from an awarded child-bounty after payout delay.

    The dispatch origin for this call may be any signed origin.

    Call works independent of parent bounty state, No need for parent bounty to be in active state.

    The Beneficiary is paid out with agreed bounty value. Curator fee is paid & curator deposit is unreserved.

    Child-bounty must be in "PendingPayout" state, for processing the call. And instance of child-bounty is removed from the state on successful call completion.

    • parent_bounty_id: Index of parent bounty.

    • child_bounty_id: Index of child bounty.

closeChildBounty(parent_bounty_id: Compact<u32>, child_bounty_id: Compact<u32>)

  • interface: api.tx.childBounties.closeChildBounty

  • summary: Cancel a proposed or active child-bounty. Child-bounty account funds are transferred to parent bounty account. The child-bounty curator deposit may be unreserved if possible.

    The dispatch origin for this call must be either parent curator or T::RejectOrigin.

    If the state of child-bounty is Active, curator deposit is unreserved.

    If the state of child-bounty is PendingPayout, call fails & returns PendingPayout error.

    For the origin other than T::RejectOrigin, parent bounty must be in active state, for this child-bounty call to work. For origin T::RejectOrigin execution is forced.

    Instance of child-bounty is removed from the state on successful call completion.

    • parent_bounty_id: Index of parent bounty.

    • child_bounty_id: Index of child bounty.

proposeCurator(parent_bounty_id: Compact<u32>, child_bounty_id: Compact<u32>, curator: MultiAddress, fee: Compact<u128>)

  • interface: api.tx.childBounties.proposeCurator

  • summary: Propose curator for funded child-bounty.

    The dispatch origin for this call must be curator of parent bounty.

    Parent bounty must be in active state, for this child-bounty call to work.

    Child-bounty must be in "Added" state, for processing the call. And state of child-bounty is moved to "CuratorProposed" on successful call completion.

    • parent_bounty_id: Index of parent bounty.

    • child_bounty_id: Index of child bounty.

    • curator: Address of child-bounty curator.

    • fee: payment fee to child-bounty curator for execution.

unassignCurator(parent_bounty_id: Compact<u32>, child_bounty_id: Compact<u32>)

  • interface: api.tx.childBounties.unassignCurator

  • summary: Unassign curator from a child-bounty.

    The dispatch origin for this call can be either RejectOrigin, or the curator of the parent bounty, or any signed origin.

    For the origin other than T::RejectOrigin and the child-bounty curator, parent bounty must be in active state, for this call to work. We allow child-bounty curator and T::RejectOrigin to execute this call irrespective of the parent bounty state.

    If this function is called by the RejectOrigin or the parent bounty curator, we assume that the child-bounty curator is malicious or inactive. As a result, child-bounty curator deposit is slashed.

    If the origin is the child-bounty curator, we take this as a sign that they are unable to do their job, and are willingly giving up. We could slash the deposit, but for now we allow them to unreserve their deposit and exit without issue. (We may want to change this if it is abused.)

    Finally, the origin can be anyone iff the child-bounty curator is "inactive". Expiry update due of parent bounty is used to estimate inactive state of child-bounty curator.

    This allows anyone in the community to call out that a child-bounty curator is not doing their due diligence, and we should pick a new one. In this case the child-bounty curator deposit is slashed.

    State of child-bounty is moved to Added state on successful call completion.

    • parent_bounty_id: Index of parent bounty.

    • child_bounty_id: Index of child bounty.

collatorSelection

leaveIntent()

  • interface: api.tx.collatorSelection.leaveIntent

  • summary: Deregister origin as a collator candidate. Note that the collator can only leave on session change. The CandidacyBond will be unreserved immediately.

    This call will fail if the total number of candidates would drop below MinCandidates.

    This call is not available to Invulnerable collators.

registerAsCandidate()

  • interface: api.tx.collatorSelection.registerAsCandidate

  • summary: Register this account as a collator candidate. The account must (a) already have registered session keys and (b) be able to reserve the CandidacyBond.

    This call is not available to Invulnerable collators.

setCandidacyBond(bond: u128)

  • interface: api.tx.collatorSelection.setCandidacyBond
  • summary: Set the candidacy bond amount.

setDesiredCandidates(max: u32)

  • interface: api.tx.collatorSelection.setDesiredCandidates
  • summary: Set the ideal number of collators (not including the invulnerables). If lowering this number, then the number of running collators could be higher than this figure. Aside from that edge case, there should be no other way to have more collators than the desired number.

setInvulnerables(new: Vec<AccountId32>)

  • interface: api.tx.collatorSelection.setInvulnerables
  • summary: Set the list of invulnerable (fixed) collators.

council

close(proposal_hash: H256, index: Compact<u32>, proposal_weight_bound: Compact<u64>, length_bound: Compact<u32>)

  • interface: api.tx.council.close

  • summary: Close a vote that is either approved, disapproved or whose voting period has ended.

    May be called by any signed account in order to finish voting and close the proposal.

    If called before the end of the voting period it will only close the vote if it is has enough votes to be approved or disapproved.

    If called after the end of the voting period abstentions are counted as rejections unless there is a prime member set and the prime member cast an approval.

    If the close operation completes successfully with disapproval, the transaction fee will be waived. Otherwise execution of the approved operation will be charged to the caller.

    • proposal_weight_bound: The maximum amount of weight consumed by executing the closed proposal. + length_bound: The upper bound for the length of the proposal in storage. Checked via storage::read so it is size_of::<u32>() == 4 larger than the pure length.

disapproveProposal(proposal_hash: H256)

  • interface: api.tx.council.disapproveProposal

  • summary: Disapprove a proposal, close, and remove it from the system, regardless of its current state.

    Must be called by the Root origin.

    Parameters:

    • proposal_hash: The hash of the proposal that should be disapproved.

execute(proposal: Call, length_bound: Compact<u32>)

  • interface: api.tx.council.execute

  • summary: Dispatch a proposal from a member using the Member origin.

    Origin must be a member of the collective.

propose(threshold: Compact<u32>, proposal: Call, length_bound: Compact<u32>)

  • interface: api.tx.council.propose

  • summary: Add a new proposal to either be voted on or executed directly.

    Requires the sender to be member.

    threshold determines whether proposal is executed directly (threshold < 2) or put up for voting.

setMembers(new_members: Vec<AccountId32>, prime: Option<AccountId32>, old_count: u32)

  • interface: api.tx.council.setMembers

  • summary: Set the collective's membership.

    • new_members: The new member list. Be nice to the chain and provide it sorted.

    • prime: The prime member whose vote sets the default.

    • old_count: The upper bound for the previous number of members in storage. Used for weight estimation.

    Requires root origin.

    NOTE: Does not enforce the expected MaxMembers limit on the amount of members, but the weight estimations rely on it to estimate dispatchable weight.

    WARNING:

    The pallet-collective can also be managed by logic outside of the pallet through the implementation of the trait [ChangeMembers]. Any call to set_members must be careful that the member set doesn't get out of sync with other logic managing the member set.

vote(proposal: H256, index: Compact<u32>, approve: bool)

  • interface: api.tx.council.vote

  • summary: Add an aye or nay vote for the sender to the given proposal.

    Requires the sender to be a member.

    Transaction fees will be waived if the member is voting on any particular proposal for the first time and the call is successful. Subsequent vote changes will charge a fee.

democracy

blacklist(proposal_hash: H256, maybe_ref_index: Option<u32>)

  • interface: api.tx.democracy.blacklist

  • summary: Permanently place a proposal into the blacklist. This prevents it from ever being proposed again.

    If called on a queued public or external proposal, then this will result in it being removed. If the ref_index supplied is an active referendum with the proposal hash, then it will be cancelled.

    The dispatch origin of this call must be BlacklistOrigin.

    • proposal_hash: The proposal hash to blacklist permanently.

    • ref_index: An ongoing referendum whose hash is proposal_hash, which will be cancelled.

    Weight: O(p) (though as this is an high-privilege dispatch, we assume it has a reasonable value).

cancelProposal(prop_index: Compact<u32>)

  • interface: api.tx.democracy.cancelProposal

  • summary: Remove a proposal.

    The dispatch origin of this call must be CancelProposalOrigin.

    • prop_index: The index of the proposal to cancel.

    Weight: O(p) where p = PublicProps::<T>::decode_len()

cancelQueued(which: u32)

  • interface: api.tx.democracy.cancelQueued

  • summary: Cancel a proposal queued for enactment.

    The dispatch origin of this call must be Root.

    • which: The index of the referendum to cancel.

    Weight: O(D) where D is the items in the dispatch queue. Weighted as D = 10.

cancelReferendum(ref_index: Compact<u32>)

  • interface: api.tx.democracy.cancelReferendum

  • summary: Remove a referendum.

    The dispatch origin of this call must be Root.

    • ref_index: The index of the referendum to cancel.

    Weight: O(1).

clearPublicProposals()

  • interface: api.tx.democracy.clearPublicProposals

  • summary: Clears all public proposals.

    The dispatch origin of this call must be Root.

    Weight: O(1).

delegate(to: AccountId32, conviction: PalletDemocracyConviction, balance: u128)

  • interface: api.tx.democracy.delegate

  • summary: Delegate the voting power (with some given conviction) of the sending account.

    The balance delegated is locked for as long as it's delegated, and thereafter for the time appropriate for the conviction's lock period.

    The dispatch origin of this call must be Signed, and the signing account must either:

    • be delegating already; or

    • have no voting activity (if there is, then it will need to be removed/consolidated through reap_vote or unvote).

    • to: The account whose voting the target account's voting power will follow.

    • conviction: The conviction that will be attached to the delegated votes. When the account is undelegated, the funds will be locked for the corresponding period.

    • balance: The amount of the account's balance to be used in delegating. This must not be more than the account's current balance.

    Emits Delegated.

    Weight: O(R) where R is the number of referendums the voter delegating to has voted on. Weight is charged as if maximum votes.

emergencyCancel(ref_index: u32)

  • interface: api.tx.democracy.emergencyCancel

  • summary: Schedule an emergency cancellation of a referendum. Cannot happen twice to the same referendum.

    The dispatch origin of this call must be CancellationOrigin.

    -ref_index: The index of the referendum to cancel.

    Weight: O(1).

enactProposal(proposal_hash: H256, index: u32)

  • interface: api.tx.democracy.enactProposal
  • summary: Enact a proposal from a referendum. For now we just make the weight be the maximum.

externalPropose(proposal_hash: H256)

  • interface: api.tx.democracy.externalPropose

  • summary: Schedule a referendum to be tabled once it is legal to schedule an external referendum.

    The dispatch origin of this call must be ExternalOrigin.

    • proposal_hash: The preimage hash of the proposal.

    Weight: O(V) with V number of vetoers in the blacklist of proposal. Decoding vec of length V. Charged as maximum

externalProposeDefault(proposal_hash: H256)

  • interface: api.tx.democracy.externalProposeDefault

  • summary: Schedule a negative-turnout-bias referendum to be tabled next once it is legal to schedule an external referendum.

    The dispatch of this call must be ExternalDefaultOrigin.

    • proposal_hash: The preimage hash of the proposal.

    Unlike external_propose, blacklisting has no effect on this and it may replace a pre-scheduled external_propose call.

    Weight: O(1)

externalProposeMajority(proposal_hash: H256)

  • interface: api.tx.democracy.externalProposeMajority

  • summary: Schedule a majority-carries referendum to be tabled next once it is legal to schedule an external referendum.

    The dispatch of this call must be ExternalMajorityOrigin.

    • proposal_hash: The preimage hash of the proposal.

    Unlike external_propose, blacklisting has no effect on this and it may replace a pre-scheduled external_propose call.

    Weight: O(1)

fastTrack(proposal_hash: H256, voting_period: u32, delay: u32)

  • interface: api.tx.democracy.fastTrack

  • summary: Schedule the currently externally-proposed majority-carries referendum to be tabled immediately. If there is no externally-proposed referendum currently, or if there is one but it is not a majority-carries referendum then it fails.

    The dispatch of this call must be FastTrackOrigin.

    • proposal_hash: The hash of the current external proposal.

    • voting_period: The period that is allowed for voting on this proposal. Increased to FastTrackVotingPeriod if too low.

    • delay: The number of block after voting has ended in approval and this should be enacted. This doesn't have a minimum amount.

    Emits Started.

    Weight: O(1)

noteImminentPreimage(encoded_proposal: Bytes)

  • interface: api.tx.democracy.noteImminentPreimage

  • summary: Register the preimage for an upcoming proposal. This requires the proposal to be in the dispatch queue. No deposit is needed. When this call is successful, i.e. the preimage has not been uploaded before and matches some imminent proposal, no fee is paid.

    The dispatch origin of this call must be Signed.

    • encoded_proposal: The preimage of a proposal.

    Emits PreimageNoted.

    Weight: O(E) with E size of encoded_proposal (protected by a required deposit).

noteImminentPreimageOperational(encoded_proposal: Bytes)

  • interface: api.tx.democracy.noteImminentPreimageOperational
  • summary: Same as note_imminent_preimage but origin is OperationalPreimageOrigin.

notePreimage(encoded_proposal: Bytes)

  • interface: api.tx.democracy.notePreimage

  • summary: Register the preimage for an upcoming proposal. This doesn't require the proposal to be in the dispatch queue but does require a deposit, returned once enacted.

    The dispatch origin of this call must be Signed.

    • encoded_proposal: The preimage of a proposal.

    Emits PreimageNoted.

    Weight: O(E) with E size of encoded_proposal (protected by a required deposit).

notePreimageOperational(encoded_proposal: Bytes)

  • interface: api.tx.democracy.notePreimageOperational
  • summary: Same as note_preimage but origin is OperationalPreimageOrigin.

propose(proposal_hash: H256, value: Compact<u128>)

  • interface: api.tx.democracy.propose

  • summary: Propose a sensitive action to be taken.

    The dispatch origin of this call must be Signed and the sender must have funds to cover the deposit.

    • proposal_hash: The hash of the proposal preimage.

    • value: The amount of deposit (must be at least MinimumDeposit).

    Emits Proposed.

    Weight: O(p)

reapPreimage(proposal_hash: H256, proposal_len_upper_bound: Compact<u32>)

  • interface: api.tx.democracy.reapPreimage

  • summary: Remove an expired proposal preimage and collect the deposit.

    The dispatch origin of this call must be Signed.

    • proposal_hash: The preimage hash of a proposal.

    • proposal_length_upper_bound: an upper bound on length of the proposal. Extrinsic is weighted according to this value with no refund.

    This will only work after VotingPeriod blocks from the time that the preimage was noted, if it's the same account doing it. If it's a different account, then it'll only work an additional EnactmentPeriod later.

    Emits PreimageReaped.

    Weight: O(D) where D is length of proposal.

removeOtherVote(target: AccountId32, index: u32)

  • interface: api.tx.democracy.removeOtherVote

  • summary: Remove a vote for a referendum.

    If the target is equal to the signer, then this function is exactly equivalent to remove_vote. If not equal to the signer, then the vote must have expired, either because the referendum was cancelled, because the voter lost the referendum or because the conviction period is over.

    The dispatch origin of this call must be Signed.

    • target: The account of the vote to be removed; this account must have voted for referendum index.

    • index: The index of referendum of the vote to be removed.

    Weight: O(R + log R) where R is the number of referenda that target has voted on. Weight is calculated for the maximum number of vote.

removeVote(index: u32)

  • interface: api.tx.democracy.removeVote

  • summary: Remove a vote for a referendum.

    If:

    • the referendum was cancelled, or

    • the referendum is ongoing, or

    • the referendum has ended such that

    • the vote of the account was in opposition to the result; or

    • there was no conviction to the account's vote; or

    • the account made a split vote ...then the vote is removed cleanly and a following call to unlock may result in more funds being available.

    If, however, the referendum has ended and:

    • it finished corresponding to the vote of the account, and

    • the account made a standard vote with conviction, and

    • the lock period of the conviction is not over ...then the lock will be aggregated into the overall account's lock, which may involve

    overlocking (where the two locks are combined into a single lock that is the maximum of both the amount locked and the time is it locked for).

    The dispatch origin of this call must be Signed, and the signer must have a vote registered for referendum index.

    • index: The index of referendum of the vote to be removed.

    Weight: O(R + log R) where R is the number of referenda that target has voted on. Weight is calculated for the maximum number of vote.

second(proposal: Compact<u32>, seconds_upper_bound: Compact<u32>)

  • interface: api.tx.democracy.second

  • summary: Signals agreement with a particular proposal.

    The dispatch origin of this call must be Signed and the sender must have funds to cover the deposit, equal to the original deposit.

    • proposal: The index of the proposal to second.

    • seconds_upper_bound: an upper bound on the current number of seconds on this proposal. Extrinsic is weighted according to this value with no refund.

    Weight: O(S) where S is the number of seconds a proposal already has.

undelegate()

  • interface: api.tx.democracy.undelegate

  • summary: Undelegate the voting power of the sending account.

    Tokens may be unlocked following once an amount of time consistent with the lock period of the conviction with which the delegation was issued.

    The dispatch origin of this call must be Signed and the signing account must be currently delegating.

    Emits Undelegated.

    Weight: O(R) where R is the number of referendums the voter delegating to has voted on. Weight is charged as if maximum votes.

unlock(target: AccountId32)

  • interface: api.tx.democracy.unlock

  • summary: Unlock tokens that have an expired lock.

    The dispatch origin of this call must be Signed.

    • target: The account to remove the lock on.

    Weight: O(R) with R number of vote of target.

vetoExternal(proposal_hash: H256)

  • interface: api.tx.democracy.vetoExternal

  • summary: Veto and blacklist the external proposal hash.

    The dispatch origin of this call must be VetoOrigin.

    • proposal_hash: The preimage hash of the proposal to veto and blacklist.

    Emits Vetoed.

    Weight: O(V + log(V)) where V is number of existing vetoers

vote(ref_index: Compact<u32>, vote: PalletDemocracyVoteAccountVote)

  • interface: api.tx.democracy.vote

  • summary: Vote in a referendum. If vote.is_aye(), the vote is to enact the proposal; otherwise it is a vote to keep the status quo.

    The dispatch origin of this call must be Signed.

    • ref_index: The index of the referendum to vote for.

    • vote: The vote configuration.

    Weight: O(R) where R is the number of referendums the voter has voted on.

identity

addRegistrar(account: AccountId32)

  • interface: api.tx.identity.addRegistrar

  • summary: Add a registrar to the system.

    The dispatch origin for this call must be T::RegistrarOrigin.

    • account: the account of the registrar.

    Emits RegistrarAdded if successful.

addSub(sub: MultiAddress, data: Data)

  • interface: api.tx.identity.addSub

  • summary: Add the given account to the sender's subs.

    Payment: Balance reserved by a previous set_subs call for one sub will be repatriated to the sender.

    The dispatch origin for this call must be Signed and the sender must have a registered sub identity of sub.

cancelRequest(reg_index: u32)

  • interface: api.tx.identity.cancelRequest

  • summary: Cancel a previous request.

    Payment: A previously reserved deposit is returned on success.

    The dispatch origin for this call must be Signed and the sender must have a registered identity.

    • reg_index: The index of the registrar whose judgement is no longer requested.

    Emits JudgementUnrequested if successful.

clearIdentity()

  • interface: api.tx.identity.clearIdentity

  • summary: Clear an account's identity info and all sub-accounts and return all deposits.

    Payment: All reserved balances on the account are returned.

    The dispatch origin for this call must be Signed and the sender must have a registered identity.

    Emits IdentityCleared if successful.

killIdentity(target: MultiAddress)

  • interface: api.tx.identity.killIdentity

  • summary: Remove an account's identity and sub-account information and slash the deposits.

    Payment: Reserved balances from set_subs and set_identity are slashed and handled by Slash. Verification request deposits are not returned; they should be cancelled manually using cancel_request.

    The dispatch origin for this call must match T::ForceOrigin.

    • target: the account whose identity the judgement is upon. This must be an account with a registered identity.

    Emits IdentityKilled if successful.

provideJudgement(reg_index: Compact<u32>, target: MultiAddress, judgement: PalletIdentityJudgement)

  • interface: api.tx.identity.provideJudgement

  • summary: Provide a judgement for an account's identity.

    The dispatch origin for this call must be Signed and the sender must be the account of the registrar whose index is reg_index.

    • reg_index: the index of the registrar whose judgement is being made.

    • target: the account whose identity the judgement is upon. This must be an account with a registered identity.

    • judgement: the judgement of the registrar of index reg_index about target.

    Emits JudgementGiven if successful.

quitSub()

  • interface: api.tx.identity.quitSub

  • summary: Remove the sender as a sub-account.

    Payment: Balance reserved by a previous set_subs call for one sub will be repatriated to the sender (not the original depositor).

    The dispatch origin for this call must be Signed and the sender must have a registered super-identity.

    NOTE: This should not normally be used, but is provided in the case that the non- controller of an account is maliciously registered as a sub-account.

removeSub(sub: MultiAddress)

  • interface: api.tx.identity.removeSub

  • summary: Remove the given account from the sender's subs.

    Payment: Balance reserved by a previous set_subs call for one sub will be repatriated to the sender.

    The dispatch origin for this call must be Signed and the sender must have a registered sub identity of sub.

renameSub(sub: MultiAddress, data: Data)

  • interface: api.tx.identity.renameSub

  • summary: Alter the associated name of the given sub-account.

    The dispatch origin for this call must be Signed and the sender must have a registered sub identity of sub.

requestJudgement(reg_index: Compact<u32>, max_fee: Compact<u128>)

  • interface: api.tx.identity.requestJudgement

  • summary: Request a judgement from a registrar.

    Payment: At most max_fee will be reserved for payment to the registrar if judgement given.

    The dispatch origin for this call must be Signed and the sender must have a registered identity.

    • reg_index: The index of the registrar whose judgement is requested.

    • max_fee: The maximum fee that may be paid. This should just be auto-populated as:

    nocompile Self::registrars().get(reg_index).unwrap().fee

    Emits JudgementRequested if successful.

setAccountId(index: Compact<u32>, new: AccountId32)

  • interface: api.tx.identity.setAccountId

  • summary: Change the account associated with a registrar.

    The dispatch origin for this call must be Signed and the sender must be the account of the registrar whose index is index.

    • index: the index of the registrar whose fee is to be set.

    • new: the new account ID.

setFee(index: Compact<u32>, fee: Compact<u128>)

  • interface: api.tx.identity.setFee

  • summary: Set the fee required for a judgement to be requested from a registrar.

    The dispatch origin for this call must be Signed and the sender must be the account of the registrar whose index is index.

    • index: the index of the registrar whose fee is to be set.

    • fee: the new fee.

setFields(index: Compact<u32>, fields: PalletIdentityBitFlags)

  • interface: api.tx.identity.setFields

  • summary: Set the field information for a registrar.

    The dispatch origin for this call must be Signed and the sender must be the account of the registrar whose index is index.

    • index: the index of the registrar whose fee is to be set.

    • fields: the fields that the registrar concerns themselves with.

setIdentity(info: PalletIdentityIdentityInfo)

  • interface: api.tx.identity.setIdentity

  • summary: Set an account's identity information and reserve the appropriate deposit.

    If the account already has identity information, the deposit is taken as part payment for the new deposit.

    The dispatch origin for this call must be Signed.

    • info: The identity information.

    Emits IdentitySet if successful.

setSubs(subs: Vec<(AccountId32,Data)>)

  • interface: api.tx.identity.setSubs

  • summary: Set the sub-accounts of the sender.

    Payment: Any aggregate balance reserved by previous set_subs calls will be returned and an amount SubAccountDeposit will be reserved for each item in subs.

    The dispatch origin for this call must be Signed and the sender must have a registered identity.

    • subs: The identity's (new) sub-accounts.

lottery

buyTicket(call: Call)

  • interface: api.tx.lottery.buyTicket

  • summary: Buy a ticket to enter the lottery.

    This extrinsic acts as a passthrough function for call. In all situations where call alone would succeed, this extrinsic should succeed.

    If call is successful, then we will attempt to purchase a ticket, which may fail silently. To detect success of a ticket purchase, you should listen for the TicketBought event.

    This extrinsic must be called by a signed origin.

setCalls(calls: Vec<Call>)

  • interface: api.tx.lottery.setCalls

  • summary: Set calls in storage which can be used to purchase a lottery ticket.

    This function only matters if you use the ValidateCall implementation provided by this pallet, which uses storage to determine the valid calls.

    This extrinsic must be called by the Manager origin.

startLottery(price: u128, length: u32, delay: u32, repeat: bool)

  • interface: api.tx.lottery.startLottery

  • summary: Start a lottery using the provided configuration.

    This extrinsic must be called by the ManagerOrigin.

    Parameters:

    • price: The cost of a single ticket.

    • length: How long the lottery should run for starting at the current block.

    • delay: How long after the lottery end we should wait before picking a winner.

    • repeat: If the lottery should repeat when completed.

stopRepeat()

  • interface: api.tx.lottery.stopRepeat

  • summary: If a lottery is repeating, you can use this to stop the repeat. The lottery will continue to run to completion.

    This extrinsic must be called by the ManagerOrigin.

multisig

approveAsMulti(threshold: u16, other_signatories: Vec<AccountId32>, maybe_timepoint: Option<PalletMultisigTimepoint>, call_hash: [u8;32], max_weight: u64)

  • interface: api.tx.multisig.approveAsMulti

  • summary: Register approval for a dispatch to be made from a deterministic composite account if approved by a total of threshold - 1 of other_signatories.

    Payment: DepositBase will be reserved if this is the first approval, plus threshold times DepositFactor. It is returned once this dispatch happens or is cancelled.

    The dispatch origin for this call must be Signed.

    • threshold: The total number of approvals for this dispatch before it is executed.

    • other_signatories: The accounts (other than the sender) who can approve this dispatch. May not be empty.

    • maybe_timepoint: If this is the first approval, then this must be None. If it is not the first approval, then it must be Some, with the timepoint (block number and transaction index) of the first approval transaction.

    • call_hash: The hash of the call to be executed.

    NOTE: If this is the final approval, you will want to use as_multi instead.

asMulti(threshold: u16, other_signatories: Vec<AccountId32>, maybe_timepoint: Option<PalletMultisigTimepoint>, call: WrapperKeepOpaque<Call>, store_call: bool, max_weight: u64)

  • interface: api.tx.multisig.asMulti

  • summary: Register approval for a dispatch to be made from a deterministic composite account if approved by a total of threshold - 1 of other_signatories.

    If there are enough, then dispatch the call.

    Payment: DepositBase will be reserved if this is the first approval, plus threshold times DepositFactor. It is returned once this dispatch happens or is cancelled.

    The dispatch origin for this call must be Signed.

    • threshold: The total number of approvals for this dispatch before it is executed.

    • other_signatories: The accounts (other than the sender) who can approve this dispatch. May not be empty.

    • maybe_timepoint: If this is the first approval, then this must be None. If it is not the first approval, then it must be Some, with the timepoint (block number and transaction index) of the first approval transaction.

    • call: The call to be executed.

    NOTE: Unless this is the final approval, you will generally want to use approve_as_multi instead, since it only requires a hash of the call.

    Result is equivalent to the dispatched result if threshold is exactly 1. Otherwise on success, result is Ok and the result from the interior call, if it was executed, may be found in the deposited MultisigExecuted event.

asMultiThreshold1(other_signatories: Vec<AccountId32>, call: Call)

  • interface: api.tx.multisig.asMultiThreshold1

  • summary: Immediately dispatch a multi-signature call using a single approval from the caller.

    The dispatch origin for this call must be Signed.

    • other_signatories: The accounts (other than the sender) who are part of the multi-signature, but do not participate in the approval process.

    • call: The call to be executed.

    Result is equivalent to the dispatched result.

cancelAsMulti(threshold: u16, other_signatories: Vec<AccountId32>, timepoint: PalletMultisigTimepoint, call_hash: [u8;32])

  • interface: api.tx.multisig.cancelAsMulti

  • summary: Cancel a pre-existing, on-going multisig transaction. Any deposit reserved previously for this operation will be unreserved on success.

    The dispatch origin for this call must be Signed.

    • threshold: The total number of approvals for this dispatch before it is executed.

    • other_signatories: The accounts (other than the sender) who can approve this dispatch. May not be empty.

    • timepoint: The timepoint (block number and transaction index) of the first approval transaction for this dispatch.

    • call_hash: The hash of the call to be executed.

parachainSystem

authorizeUpgrade(code_hash: H256)

  • interface: api.tx.parachainSystem.authorizeUpgrade

enactAuthorizedUpgrade(code: Bytes)

  • interface: api.tx.parachainSystem.enactAuthorizedUpgrade

setValidationData(data: CumulusPrimitivesParachainInherentParachainInherentData)

  • interface: api.tx.parachainSystem.setValidationData

  • summary: Set the current validation data.

    This should be invoked exactly once per block. It will panic at the finalization phase if the call was not invoked.

    The dispatch origin for this call must be Inherent

    As a side effect, this function upgrades the current validation function if the appropriate time has come.

sudoSendUpwardMessage(message: Bytes)

  • interface: api.tx.parachainSystem.sudoSendUpwardMessage

phragmenElection

cleanDefunctVoters(num_voters: u32, num_defunct: u32)

  • interface: api.tx.phragmenElection.cleanDefunctVoters

  • summary: Clean all voters who are defunct (i.e. they do not serve any purpose at all). The deposit of the removed voters are returned.

    This is an root function to be used only for cleaning the state.

    The dispatch origin of this call must be root.

removeMember(who: MultiAddress, has_replacement: bool)

  • interface: api.tx.phragmenElection.removeMember

  • summary: Remove a particular member from the set. This is effective immediately and the bond of the outgoing member is slashed.

    If a runner-up is available, then the best runner-up will be removed and replaces the outgoing member. Otherwise, a new phragmen election is started.

    The dispatch origin of this call must be root.

    Note that this does not affect the designated block number of the next election.

removeVoter()

  • interface: api.tx.phragmenElection.removeVoter

  • summary: Remove origin as a voter.

    This removes the lock and returns the deposit.

    The dispatch origin of this call must be signed and be a voter.

renounceCandidacy(renouncing: PalletElectionsPhragmenRenouncing)

  • interface: api.tx.phragmenElection.renounceCandidacy

  • summary: Renounce one's intention to be a candidate for the next election round. 3 potential outcomes exist:

    • origin is a candidate and not elected in any set. In this case, the deposit is unreserved, returned and origin is removed as a candidate.

    • origin is a current runner-up. In this case, the deposit is unreserved, returned and origin is removed as a runner-up.

    • origin is a current member. In this case, the deposit is unreserved and origin is removed as a member, consequently not being a candidate for the next round anymore. Similar to remove_member, if replacement runners exists, they are immediately used. If the prime is renouncing, then no prime will exist until the next round.

    The dispatch origin of this call must be signed, and have one of the above roles.

submitCandidacy(candidate_count: Compact<u32>)

  • interface: api.tx.phragmenElection.submitCandidacy

  • summary: Submit oneself for candidacy. A fixed amount of deposit is recorded.

    All candidates are wiped at the end of the term. They either become a member/runner-up, or leave the system while their deposit is slashed.

    The dispatch origin of this call must be signed.

    Warning

    Even if a candidate ends up being a member, they must call [Call::renounce_candidacy] to get their deposit back. Losing the spot in an election will always lead to a slash.

vote(votes: Vec<AccountId32>, value: Compact<u128>)

  • interface: api.tx.phragmenElection.vote

  • summary: Vote for a set of candidates for the upcoming round of election. This can be called to set the initial votes, or update already existing votes.

    Upon initial voting, value units of who's balance is locked and a deposit amount is reserved. The deposit is based on the number of votes and can be updated over time.

    The votes should:

    • not be empty.

    • be less than the number of possible candidates. Note that all current members and runners-up are also automatically candidates for the next round.

    If value is more than who's free balance, then the maximum of the two is used.

    The dispatch origin of this call must be signed.

    Warning

    It is the responsibility of the caller to NOT place all of their balance into the lock and keep some for further operations.

preimage

notePreimage(bytes: Bytes)

  • interface: api.tx.preimage.notePreimage

  • summary: Register a preimage on-chain.

    If the preimage was previously requested, no fees or deposits are taken for providing the preimage. Otherwise, a deposit is taken proportional to the size of the preimage.

requestPreimage(hash: H256)

  • interface: api.tx.preimage.requestPreimage

  • summary: Request a preimage be uploaded to the chain without paying any fees or deposits.

    If the preimage requests has already been provided on-chain, we unreserve any deposit a user may have paid, and take the control of the preimage out of their hands.

unnotePreimage(hash: H256)

  • interface: api.tx.preimage.unnotePreimage
  • summary: Clear an unrequested preimage from the runtime storage.

unrequestPreimage(hash: H256)

  • interface: api.tx.preimage.unrequestPreimage

  • summary: Clear a previously made request for a preimage.

    NOTE: THIS MUST NOT BE CALLED ON hash MORE TIMES THAN request_preimage.

proxy

addProxy(delegate: AccountId32, proxy_type: PhalaParachainRuntimeProxyType, delay: u32)

  • interface: api.tx.proxy.addProxy

  • summary: Register a proxy account for the sender that is able to make calls on its behalf.

    The dispatch origin for this call must be Signed.

    Parameters:

    • proxy: The account that the caller would like to make a proxy.

    • proxy_type: The permissions allowed for this proxy account.

    • delay: The announcement period required of the initial proxy. Will generally be zero.

announce(real: AccountId32, call_hash: H256)

  • interface: api.tx.proxy.announce

  • summary: Publish the hash of a proxy-call that will be made in the future.

    This must be called some number of blocks before the corresponding proxy is attempted if the delay associated with the proxy relationship is greater than zero.

    No more than MaxPending announcements may be made at any one time.

    This will take a deposit of AnnouncementDepositFactor as well as AnnouncementDepositBase if there are no other pending announcements.

    The dispatch origin for this call must be Signed and a proxy of real.

    Parameters:

    • real: The account that the proxy will make a call on behalf of.

    • call_hash: The hash of the call to be made by the real account.

anonymous(proxy_type: PhalaParachainRuntimeProxyType, delay: u32, index: u16)

  • interface: api.tx.proxy.anonymous

  • summary: Spawn a fresh new account that is guaranteed to be otherwise inaccessible, and initialize it with a proxy of proxy_type for origin sender.

    Requires a Signed origin.

    • proxy_type: The type of the proxy that the sender will be registered as over the new account. This will almost always be the most permissive ProxyType possible to allow for maximum flexibility.

    • index: A disambiguation index, in case this is called multiple times in the same transaction (e.g. with utility::batch). Unless you're using batch you probably just want to use 0.

    • delay: The announcement period required of the initial proxy. Will generally be zero.

    Fails with Duplicate if this has already been called in this transaction, from the same sender, with the same parameters.

    Fails if there are insufficient funds to pay for deposit.

    TODO: Might be over counting 1 read

killAnonymous(spawner: AccountId32, proxy_type: PhalaParachainRuntimeProxyType, index: u16, height: Compact<u32>, ext_index: Compact<u32>)

  • interface: api.tx.proxy.killAnonymous

  • summary: Removes a previously spawned anonymous proxy.

    WARNING: All access to this account will be lost. Any funds held in it will be inaccessible.

    Requires a Signed origin, and the sender account must have been created by a call to anonymous with corresponding parameters.

    • spawner: The account that originally called anonymous to create this account.

    • index: The disambiguation index originally passed to anonymous. Probably 0.

    • proxy_type: The proxy type originally passed to anonymous.

    • height: The height of the chain when the call to anonymous was processed.

    • ext_index: The extrinsic index in which the call to anonymous was processed.

    Fails with NoPermission in case the caller is not a previously created anonymous account whose anonymous call has corresponding parameters.

proxy(real: AccountId32, force_proxy_type: Option<PhalaParachainRuntimeProxyType>, call: Call)

  • interface: api.tx.proxy.proxy

  • summary: Dispatch the given call from an account that the sender is authorised for through add_proxy.

    Removes any corresponding announcement(s).

    The dispatch origin for this call must be Signed.

    Parameters:

    • real: The account that the proxy will make a call on behalf of.

    • force_proxy_type: Specify the exact proxy type to be used and checked for this call.

    • call: The call to be made by the real account.

proxyAnnounced(delegate: AccountId32, real: AccountId32, force_proxy_type: Option<PhalaParachainRuntimeProxyType>, call: Call)

  • interface: api.tx.proxy.proxyAnnounced

  • summary: Dispatch the given call from an account that the sender is authorized for through add_proxy.

    Removes any corresponding announcement(s).

    The dispatch origin for this call must be Signed.

    Parameters:

    • real: The account that the proxy will make a call on behalf of.

    • force_proxy_type: Specify the exact proxy type to be used and checked for this call.

    • call: The call to be made by the real account.

rejectAnnouncement(delegate: AccountId32, call_hash: H256)

  • interface: api.tx.proxy.rejectAnnouncement

  • summary: Remove the given announcement of a delegate.

    May be called by a target (proxied) account to remove a call that one of their delegates (delegate) has announced they want to execute. The deposit is returned.

    The dispatch origin for this call must be Signed.

    Parameters:

    • delegate: The account that previously announced the call.

    • call_hash: The hash of the call to be made.

removeAnnouncement(real: AccountId32, call_hash: H256)

  • interface: api.tx.proxy.removeAnnouncement

  • summary: Remove a given announcement.

    May be called by a proxy account to remove a call they previously announced and return the deposit.

    The dispatch origin for this call must be Signed.

    Parameters:

    • real: The account that the proxy will make a call on behalf of.

    • call_hash: The hash of the call to be made by the real account.

removeProxies()

  • interface: api.tx.proxy.removeProxies

  • summary: Unregister all proxy accounts for the sender.

    The dispatch origin for this call must be Signed.

    WARNING: This may be called on accounts created by anonymous, however if done, then the unreserved fees will be inaccessible. All access to this account will be lost.

removeProxy(delegate: AccountId32, proxy_type: PhalaParachainRuntimeProxyType, delay: u32)

  • interface: api.tx.proxy.removeProxy

  • summary: Unregister a proxy account for the sender.

    The dispatch origin for this call must be Signed.

    Parameters:

    • proxy: The account that the caller would like to remove as a proxy.

    • proxy_type: The permissions currently enabled for the removed proxy account.

scheduler

cancel(when: u32, 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: u32, maybe_periodic: Option<(u32,u32)>, priority: u8, call: FrameSupportScheduleMaybeHashed)

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

scheduleAfter(after: u32, maybe_periodic: Option<(u32,u32)>, priority: u8, call: FrameSupportScheduleMaybeHashed)

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

scheduleNamed(id: Bytes, when: u32, maybe_periodic: Option<(u32,u32)>, priority: u8, call: FrameSupportScheduleMaybeHashed)

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

scheduleNamedAfter(id: Bytes, after: u32, maybe_periodic: Option<(u32,u32)>, priority: u8, call: FrameSupportScheduleMaybeHashed)

  • 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 and the account must be either be convertible to a validator ID using the chain's typical addressing system (this usually means being a controller account) or directly convertible into a validator ID (which usually means being a stash account).

setKeys(keys: PhalaParachainRuntimeOpaqueSessionKeys, 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.

sudo

setKey(new: MultiAddress)

  • 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: MultiAddress, 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: u64)

  • 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: Bytes, 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<Bytes>)

  • 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.

remarkWithEvent(remark: Bytes)

  • interface: api.tx.system.remarkWithEvent
  • summary: Make some on-chain remark and emit event.

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<(Bytes,Bytes)>)

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

technicalCommittee

close(proposal_hash: H256, index: Compact<u32>, proposal_weight_bound: Compact<u64>, length_bound: Compact<u32>)

  • interface: api.tx.technicalCommittee.close

  • summary: Close a vote that is either approved, disapproved or whose voting period has ended.

    May be called by any signed account in order to finish voting and close the proposal.

    If called before the end of the voting period it will only close the vote if it is has enough votes to be approved or disapproved.

    If called after the end of the voting period abstentions are counted as rejections unless there is a prime member set and the prime member cast an approval.

    If the close operation completes successfully with disapproval, the transaction fee will be waived. Otherwise execution of the approved operation will be charged to the caller.

    • proposal_weight_bound: The maximum amount of weight consumed by executing the closed proposal. + length_bound: The upper bound for the length of the proposal in storage. Checked via storage::read so it is size_of::<u32>() == 4 larger than the pure length.

disapproveProposal(proposal_hash: H256)

  • interface: api.tx.technicalCommittee.disapproveProposal

  • summary: Disapprove a proposal, close, and remove it from the system, regardless of its current state.

    Must be called by the Root origin.

    Parameters:

    • proposal_hash: The hash of the proposal that should be disapproved.

execute(proposal: Call, length_bound: Compact<u32>)

  • interface: api.tx.technicalCommittee.execute

  • summary: Dispatch a proposal from a member using the Member origin.

    Origin must be a member of the collective.

propose(threshold: Compact<u32>, proposal: Call, length_bound: Compact<u32>)

  • interface: api.tx.technicalCommittee.propose

  • summary: Add a new proposal to either be voted on or executed directly.

    Requires the sender to be member.

    threshold determines whether proposal is executed directly (threshold < 2) or put up for voting.

setMembers(new_members: Vec<AccountId32>, prime: Option<AccountId32>, old_count: u32)

  • interface: api.tx.technicalCommittee.setMembers

  • summary: Set the collective's membership.

    • new_members: The new member list. Be nice to the chain and provide it sorted.

    • prime: The prime member whose vote sets the default.

    • old_count: The upper bound for the previous number of members in storage. Used for weight estimation.

    Requires root origin.

    NOTE: Does not enforce the expected MaxMembers limit on the amount of members, but the weight estimations rely on it to estimate dispatchable weight.

    WARNING:

    The pallet-collective can also be managed by logic outside of the pallet through the implementation of the trait [ChangeMembers]. Any call to set_members must be careful that the member set doesn't get out of sync with other logic managing the member set.

vote(proposal: H256, index: Compact<u32>, approve: bool)

  • interface: api.tx.technicalCommittee.vote

  • summary: Add an aye or nay vote for the sender to the given proposal.

    Requires the sender to be a member.

    Transaction fees will be waived if the member is voting on any particular proposal for the first time and the call is successful. Subsequent vote changes will charge a fee.

technicalMembership

addMember(who: AccountId32)

  • interface: api.tx.technicalMembership.addMember

  • summary: Add a member who to the set.

    May only be called from T::AddOrigin.

changeKey(new: AccountId32)

  • interface: api.tx.technicalMembership.changeKey

  • summary: Swap out the sending member for some other key new.

    May only be called from Signed origin of a current member.

    Prime membership is passed from the origin account to new, if extant.

clearPrime()

  • interface: api.tx.technicalMembership.clearPrime

  • summary: Remove the prime member if it exists.

    May only be called from T::PrimeOrigin.

removeMember(who: AccountId32)

  • interface: api.tx.technicalMembership.removeMember

  • summary: Remove a member who from the set.

    May only be called from T::RemoveOrigin.

resetMembers(members: Vec<AccountId32>)

  • interface: api.tx.technicalMembership.resetMembers

  • summary: Change the membership to a new set, disregarding the existing membership. Be nice and pass members pre-sorted.

    May only be called from T::ResetOrigin.

setPrime(who: AccountId32)

  • interface: api.tx.technicalMembership.setPrime

  • summary: Set the prime member. Must be a current member.

    May only be called from T::PrimeOrigin.

swapMember(remove: AccountId32, add: AccountId32)

  • interface: api.tx.technicalMembership.swapMember

  • summary: Swap out one member remove for another add.

    May only be called from T::SwapOrigin.

    Prime membership is not passed from remove to add, if extant.

timestamp

set(now: Compact<u64>)

  • 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.

tips

closeTip(hash: H256)

  • interface: api.tx.tips.closeTip

  • summary: Close and payout a tip.

    The dispatch origin for this call must be Signed.

    The tip identified by hash must have finished its countdown period.

    • hash: The identity of the open tip for which a tip value is declared. This is formed as the hash of the tuple of the original tip reason and the beneficiary account ID.

reportAwesome(reason: Bytes, who: AccountId32)

  • interface: api.tx.tips.reportAwesome

  • summary: Report something reason that deserves a tip and claim any eventual the finder's fee.

    The dispatch origin for this call must be Signed.

    Payment: TipReportDepositBase will be reserved from the origin account, as well as DataDepositPerByte for each byte in reason.

    • reason: The reason for, or the thing that deserves, the tip; generally this will be a UTF-8-encoded URL.

    • who: The account which should be credited for the tip.

    Emits NewTip if successful.

retractTip(hash: H256)

  • interface: api.tx.tips.retractTip

  • summary: Retract a prior tip-report from report_awesome, and cancel the process of tipping.

    If successful, the original deposit will be unreserved.

    The dispatch origin for this call must be Signed and the tip identified by hash must have been reported by the signing account through report_awesome (and not through tip_new).

    • hash: The identity of the open tip for which a tip value is declared. This is formed as the hash of the tuple of the original tip reason and the beneficiary account ID.

    Emits TipRetracted if successful.

slashTip(hash: H256)

  • interface: api.tx.tips.slashTip

  • summary: Remove and slash an already-open tip.

    May only be called from T::RejectOrigin.

    As a result, the finder is slashed and the deposits are lost.

    Emits TipSlashed if successful.

tip(hash: H256, tip_value: Compact<u128>)

  • interface: api.tx.tips.tip

  • summary: Declare a tip value for an already-open tip.

    The dispatch origin for this call must be Signed and the signing account must be a member of the Tippers set.

    • hash: The identity of the open tip for which a tip value is declared. This is formed as the hash of the tuple of the hash of the original tip reason and the beneficiary account ID.

    • tip_value: The amount of tip that the sender would like to give. The median tip value of active tippers will be given to the who.

    Emits TipClosing if the threshold of tippers has been reached and the countdown period has started.

tipNew(reason: Bytes, who: AccountId32, tip_value: Compact<u128>)

  • interface: api.tx.tips.tipNew

  • summary: Give a tip for something new; no finder's fee will be taken.

    The dispatch origin for this call must be Signed and the signing account must be a member of the Tippers set.

    • reason: The reason for, or the thing that deserves, the tip; generally this will be a UTF-8-encoded URL.

    • who: The account which should be credited for the tip.

    • tip_value: The amount of tip that the sender would like to give. The median tip value of active tippers will be given to the who.

    Emits NewTip if successful.

treasury

approveProposal(proposal_id: Compact<u32>)

  • interface: api.tx.treasury.approveProposal

  • summary: Approve a proposal. At a later time, the proposal will be allocated to the beneficiary and the original deposit will be returned.

    May only be called from T::ApproveOrigin.

proposeSpend(value: Compact<u128>, beneficiary: MultiAddress)

  • interface: api.tx.treasury.proposeSpend
  • summary: Put forward a suggestion for spending. A deposit proportional to the value is reserved and slashed if the proposal is rejected. It is returned once the proposal is awarded.

rejectProposal(proposal_id: Compact<u32>)

  • interface: api.tx.treasury.rejectProposal

  • summary: Reject a proposed spend. The original deposit will be slashed.

    May only be called from T::RejectOrigin.

removeApproval(proposal_id: Compact<u32>)

  • interface: api.tx.treasury.removeApproval

  • summary: Force a previously approved proposal to be removed from the approval queue. The original deposit will no longer be returned.

    May only be called from T::RejectOrigin.

    • proposal_id: The index of a proposal

    Errors:

    • ProposalNotApproved: The proposal_id supplied was not found in the approval queue, i.e., the proposal has not been approved. This could also mean the proposal does not exist altogether, thus there is no way it would have been approved in the first place.

utility

asDerivative(index: u16, call: Call)

  • interface: api.tx.utility.asDerivative

  • summary: Send a call through an indexed pseudonym of the sender.

    Filter from origin are passed along. The call will be dispatched with an origin which use the same filter as the origin of this call.

    NOTE: If you need to ensure that any account-based filtering is not honored (i.e. because you expect proxy to have been used prior in the call stack and you do not want the call restrictions to apply to any sub-accounts), then use as_multi_threshold_1 in the Multisig pallet instead.

    NOTE: Prior to version *12, this was called as_limited_sub.

    The dispatch origin for this call must be Signed.

batch(calls: Vec<Call>)

  • interface: api.tx.utility.batch

  • summary: Send a batch of dispatch calls.

    May be called from any origin.

    • calls: The calls to be dispatched from the same origin. The number of call must not exceed the constant: batched_calls_limit (available in constant metadata).

    If origin is root then call are dispatch without checking origin filter. (This includes bypassing frame_system::Config::BaseCallFilter).

    This will return Ok in all circumstances. 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.

batchAll(calls: Vec<Call>)

  • interface: api.tx.utility.batchAll

  • summary: Send a batch of dispatch calls and atomically execute them. The whole transaction will rollback and fail if any of the calls failed.

    May be called from any origin.

    • calls: The calls to be dispatched from the same origin. The number of call must not exceed the constant: batched_calls_limit (available in constant metadata).

    If origin is root then call are dispatch without checking origin filter. (This includes bypassing frame_system::Config::BaseCallFilter).

batchTry(calls: Vec<Call>)

  • interface: api.tx.utility.batchTry

  • summary: DEPRECATED: Replaced by force_batch

    Send a batch of dispatch calls. Unlike batch, it allows errors and won't interrupt.

    May be called from any origin.

    • calls: The calls to be dispatched from the same origin. The number of call must not exceed the constant: batched_calls_limit (available in constant metadata).

    If origin is root then call are dispatch without checking origin filter. (This includes bypassing frame_system::Config::BaseCallFilter).

dispatchAs(as_origin: PhalaParachainRuntimeOriginCaller, call: Call)

  • interface: api.tx.utility.dispatchAs

  • summary: Dispatches a function call with a provided origin.

    The dispatch origin for this call must be Root.

forceBatch(calls: Vec<Call>)

  • interface: api.tx.utility.forceBatch

  • summary: Send a batch of dispatch calls. Unlike batch, it allows errors and won't interrupt.

    May be called from any origin.

    • calls: The calls to be dispatched from the same origin. The number of call must not exceed the constant: batched_calls_limit (available in constant metadata).

    If origin is root then call are dispatch without checking origin filter. (This includes bypassing frame_system::Config::BaseCallFilter).

vesting

forceVestedTransfer(source: MultiAddress, target: MultiAddress, schedule: PalletVestingVestingInfo)

  • interface: api.tx.vesting.forceVestedTransfer

  • summary: Force a vested transfer.

    The dispatch origin for this call must be Root.

    • source: The account whose funds should be transferred.

    • target: The account that should be transferred the vested funds.

    • schedule: The vesting schedule attached to the transfer.

    Emits VestingCreated.

    NOTE: This will unlock all schedules through the current block.

mergeSchedules(schedule1_index: u32, schedule2_index: u32)

  • interface: api.tx.vesting.mergeSchedules

  • summary: Merge two vesting schedules together, creating a new vesting schedule that unlocks over the highest possible start and end blocks. If both schedules have already started the current block will be used as the schedule start; with the caveat that if one schedule is finished by the current block, the other will be treated as the new merged schedule, unmodified.

    NOTE: If schedule1_index == schedule2_index this is a no-op. NOTE: This will unlock all schedules through the current block prior to merging. NOTE: If both schedules have ended by the current block, no new schedule will be created and both will be removed.

    Merged schedule attributes:

    • starting_block: MAX(schedule1.starting_block, scheduled2.starting_block, current_block).

    • ending_block: MAX(schedule1.ending_block, schedule2.ending_block).

    • locked: schedule1.locked_at(current_block) + schedule2.locked_at(current_block).

    The dispatch origin for this call must be Signed.

    • schedule1_index: index of the first schedule to merge.

    • schedule2_index: index of the second schedule to merge.

vest()

  • interface: api.tx.vesting.vest

  • summary: Unlock any vested funds of the sender account.

    The dispatch origin for this call must be Signed and the sender must have funds still locked under this pallet.

    Emits either VestingCompleted or VestingUpdated.

vestOther(target: MultiAddress)

  • interface: api.tx.vesting.vestOther

  • summary: Unlock any vested funds of a target account.

    The dispatch origin for this call must be Signed.

    • target: The account whose vested funds should be unlocked. Must have funds still locked under this pallet.

    Emits either VestingCompleted or VestingUpdated.

vestedTransfer(target: MultiAddress, schedule: PalletVestingVestingInfo)

  • interface: api.tx.vesting.vestedTransfer

  • summary: Create a vested transfer.

    The dispatch origin for this call must be Signed.

    • target: The account receiving the vested funds.

    • schedule: The vesting schedule attached to the transfer.

    Emits VestingCreated.

    NOTE: This will unlock all schedules through the current block.