authorship:

authorship.setUncles

docs
@ Provide a set of uncles.
args
┌─────────┬─────────────┬────────────────────────┬───────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼─────────────┼────────────────────────┼───────────────┤ │ 0 │ 'newUncles' │ 'Vec<SpRuntimeHeader>' │ 'Vec<Header>' │ └─────────┴─────────────┴────────────────────────┴───────────────┘

babe:

babe.reportEquivocation

docs
@ 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.
args
┌─────────┬─────────────────────┬─────────────────────────────────────┬─────────────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼─────────────────────┼─────────────────────────────────────┼─────────────────────┤ │ 0 │ 'equivocationProof' │ 'SpConsensusSlotsEquivocationProof' │ 'EquivocationProof' │ │ 1 │ 'keyOwnerProof' │ 'SpSessionMembershipProof' │ 'KeyOwnerProof' │ └─────────┴─────────────────────┴─────────────────────────────────────┴─────────────────────┘

babe.reportEquivocationUnsigned

docs
@ 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.
args
┌─────────┬─────────────────────┬─────────────────────────────────────┬─────────────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼─────────────────────┼─────────────────────────────────────┼─────────────────────┤ │ 0 │ 'equivocationProof' │ 'SpConsensusSlotsEquivocationProof' │ 'EquivocationProof' │ │ 1 │ 'keyOwnerProof' │ 'SpSessionMembershipProof' │ 'KeyOwnerProof' │ └─────────┴─────────────────────┴─────────────────────────────────────┴─────────────────────┘

babe.planConfigChange

docs
@ Plan an epoch config change. The epoch config change is recorded and will be enacted on @ the next call to `enact_epoch_change`. The config will be activated one epoch after. @ Multiple calls to this method will replace any existing planned config change that had @ not been enacted yet.
args
┌─────────┬──────────┬──────────────────────────────────────────────┬────────────────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼──────────┼──────────────────────────────────────────────┼────────────────────────┤ │ 0 │ 'config' │ 'SpConsensusBabeDigestsNextConfigDescriptor' │ 'NextConfigDescriptor' │ └─────────┴──────────┴──────────────────────────────────────────────┴────────────────────────┘

bagsList:

bagsList.rebag

docs
@ Declare that some `dislocated` account has, through rewards or penalties, sufficiently @ changed its weight that it should properly fall into a different bag than its current @ one. @ @ Anyone can call this function about any potentially dislocated account. @ @ Will never return an error; if `dislocated` does not exist or doesn't need a rebag, then @ it is a noop and fees are still collected from `origin`.
args
┌─────────┬──────────────┬───────────────┬─────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼──────────────┼───────────────┼─────────────┤ │ 0 │ 'dislocated' │ 'AccountId32' │ 'AccountId' │ └─────────┴──────────────┴───────────────┴─────────────┘

balances:

balances.transfer

docs
@ 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`. @ 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. @ @ # <weight> @ - Dependent on arguments but not critical, given proper implementations for input config @ types. See related functions below. @ - It contains a limited number of reads and writes internally and no complex @ computation. @ @ Related functions: @ @ - `ensure_can_withdraw` is always called internally but has a bounded complexity. @ - Transferring balances to accounts that did not exist before will cause @ `T::OnNewAccount::on_new_account` to be called. @ - Removing enough funds from an account will trigger `T::DustRemoval::on_unbalanced`. @ - `transfer_keep_alive` works the same way as `transfer`, but has an additional check @ that the transfer will not kill the origin account. @ --------------------------------- @ - Origin account is already in memory, so no DB operations for them. @ # </weight>
args
┌─────────┬─────────┬─────────────────┬────────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼─────────┼─────────────────┼────────────────┤ │ 0 │ 'dest' │ 'MultiAddress' │ 'LookupSource' │ │ 1 │ 'value' │ 'Compact<u128>' │ 'Balance' │ └─────────┴─────────┴─────────────────┴────────────────┘

balances.setBalance

docs
@ 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`). @ 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`.
args
┌─────────┬───────────────┬─────────────────┬────────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼───────────────┼─────────────────┼────────────────┤ │ 0 │ 'who' │ 'MultiAddress' │ 'LookupSource' │ │ 1 │ 'newFree' │ 'Compact<u128>' │ 'Balance' │ │ 2 │ 'newReserved' │ 'Compact<u128>' │ 'Balance' │ └─────────┴───────────────┴─────────────────┴────────────────┘

balances.forceTransfer

docs
@ Exactly as `transfer`, except the origin must be root and the source account may be @ specified. @ # <weight> @ - Same as transfer, but additional read and write because the source account is not @ assumed to be in the overlay. @ # </weight>
args
┌─────────┬──────────┬─────────────────┬────────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼──────────┼─────────────────┼────────────────┤ │ 0 │ 'source' │ 'MultiAddress' │ 'LookupSource' │ │ 1 │ 'dest' │ 'MultiAddress' │ 'LookupSource' │ │ 2 │ 'value' │ 'Compact<u128>' │ 'Balance' │ └─────────┴──────────┴─────────────────┴────────────────┘

balances.transferKeepAlive

docs
@ 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. @ @ [`transfer`]: struct.Pallet.html#method.transfer
args
┌─────────┬─────────┬─────────────────┬────────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼─────────┼─────────────────┼────────────────┤ │ 0 │ 'dest' │ 'MultiAddress' │ 'LookupSource' │ │ 1 │ 'value' │ 'Compact<u128>' │ 'Balance' │ └─────────┴─────────┴─────────────────┴────────────────┘

balances.transferAll

docs
@ 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). # <weight> @ - O(1). Just like transfer, but reading the user's transferable balance first. @ #</weight>
args
┌─────────┬─────────────┬────────────────┬────────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼─────────────┼────────────────┼────────────────┤ │ 0 │ 'dest' │ 'MultiAddress' │ 'LookupSource' │ │ 1 │ 'keepAlive' │ 'bool' │ 'bool' │ └─────────┴─────────────┴────────────────┴────────────────┘

balances.forceUnreserve

docs
@ Unreserve some balance from a user by force. @ @ Can only be called by ROOT.
args
┌─────────┬──────────┬────────────────┬────────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼──────────┼────────────────┼────────────────┤ │ 0 │ 'who' │ 'MultiAddress' │ 'LookupSource' │ │ 1 │ 'amount' │ 'u128' │ 'Balance' │ └─────────┴──────────┴────────────────┴────────────────┘

bounties:

bounties.proposeBounty

docs
@ 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.
args
┌─────────┬───────────────┬─────────────────┬─────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼───────────────┼─────────────────┼─────────────┤ │ 0 │ 'value' │ 'Compact<u128>' │ 'BalanceOf' │ │ 1 │ 'description' │ 'Bytes' │ 'Bytes' │ └─────────┴───────────────┴─────────────────┴─────────────┘

bounties.approveBounty

docs
@ 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`. @ @ # <weight> @ - O(1). @ # </weight>
args
┌─────────┬────────────┬────────────────┬───────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼────────────┼────────────────┼───────────────┤ │ 0 │ 'bountyId' │ 'Compact<u32>' │ 'BountyIndex' │ └─────────┴────────────┴────────────────┴───────────────┘

bounties.proposeCurator

docs
@ Assign a curator to a funded bounty. @ @ May only be called from `T::ApproveOrigin`. @ @ # <weight> @ - O(1). @ # </weight>
args
┌─────────┬────────────┬─────────────────┬────────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼────────────┼─────────────────┼────────────────┤ │ 0 │ 'bountyId' │ 'Compact<u32>' │ 'BountyIndex' │ │ 1 │ 'curator' │ 'MultiAddress' │ 'LookupSource' │ │ 2 │ 'fee' │ 'Compact<u128>' │ 'BalanceOf' │ └─────────┴────────────┴─────────────────┴────────────────┘

bounties.unassignCurator

docs
@ 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. @ @ # <weight> @ - O(1). @ # </weight>
args
┌─────────┬────────────┬────────────────┬───────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼────────────┼────────────────┼───────────────┤ │ 0 │ 'bountyId' │ 'Compact<u32>' │ 'BountyIndex' │ └─────────┴────────────┴────────────────┴───────────────┘

bounties.acceptCurator

docs
@ 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. @ @ # <weight> @ - O(1). @ # </weight>
args
┌─────────┬────────────┬────────────────┬───────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼────────────┼────────────────┼───────────────┤ │ 0 │ 'bountyId' │ 'Compact<u32>' │ 'BountyIndex' │ └─────────┴────────────┴────────────────┴───────────────┘

bounties.awardBounty

docs
@ 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. @ @ # <weight> @ - O(1). @ # </weight>
args
┌─────────┬───────────────┬────────────────┬────────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼───────────────┼────────────────┼────────────────┤ │ 0 │ 'bountyId' │ 'Compact<u32>' │ 'BountyIndex' │ │ 1 │ 'beneficiary' │ 'MultiAddress' │ 'LookupSource' │ └─────────┴───────────────┴────────────────┴────────────────┘

bounties.claimBounty

docs
@ 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. @ @ # <weight> @ - O(1). @ # </weight>
args
┌─────────┬────────────┬────────────────┬───────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼────────────┼────────────────┼───────────────┤ │ 0 │ 'bountyId' │ 'Compact<u32>' │ 'BountyIndex' │ └─────────┴────────────┴────────────────┴───────────────┘

bounties.closeBounty

docs
@ 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. @ @ # <weight> @ - O(1). @ # </weight>
args
┌─────────┬────────────┬────────────────┬───────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼────────────┼────────────────┼───────────────┤ │ 0 │ 'bountyId' │ 'Compact<u32>' │ 'BountyIndex' │ └─────────┴────────────┴────────────────┴───────────────┘

bounties.extendBountyExpiry

docs
@ 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. @ @ # <weight> @ - O(1). @ # </weight>
args
┌─────────┬────────────┬────────────────┬───────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼────────────┼────────────────┼───────────────┤ │ 0 │ 'bountyId' │ 'Compact<u32>' │ 'BountyIndex' │ │ 1 │ 'remark' │ 'Bytes' │ 'Bytes' │ └─────────┴────────────┴────────────────┴───────────────┘

contracts:

contracts.call

docs
@ Makes a call to an account, optionally transferring some balance. @ @ * If the account is a smart-contract account, the associated code will be @ executed and any value will be transferred. @ * If the account is a regular account, any value will be transferred. @ * If no account exists and the call value is not less than `existential_deposit`, @ a regular account will be created and any value will be transferred.
args
┌─────────┬────────────┬─────────────────┬────────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼────────────┼─────────────────┼────────────────┤ │ 0 │ 'dest' │ 'MultiAddress' │ 'LookupSource' │ │ 1 │ 'value' │ 'Compact<u128>' │ 'BalanceOf' │ │ 2 │ 'gasLimit' │ 'Compact<u64>' │ 'Weight' │ │ 3 │ 'data' │ 'Bytes' │ 'Bytes' │ └─────────┴────────────┴─────────────────┴────────────────┘

contracts.instantiateWithCode

docs
@ Instantiates a new contract from the supplied `code` optionally transferring @ some balance. @ @ This is the only function that can deploy new code to the chain. @ @ # Parameters @ @ * `endowment`: The balance to transfer from the `origin` to the newly created contract. @ * `gas_limit`: The gas limit enforced when executing the constructor. @ * `code`: The contract code to deploy in raw bytes. @ * `data`: The input data to pass to the contract constructor. @ * `salt`: Used for the address derivation. See [`Pallet::contract_address`]. @ @ Instantiation is executed as follows: @ @ - The supplied `code` is instrumented, deployed, and a `code_hash` is created for that @ code. @ - If the `code_hash` already exists on the chain the underlying `code` will be shared. @ - The destination address is computed based on the sender, code_hash and the salt. @ - The smart-contract account is created at the computed address. @ - The `endowment` is transferred to the new account. @ - The `deploy` function is executed in the context of the newly-created account.
args
┌─────────┬─────────────┬─────────────────┬─────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼─────────────┼─────────────────┼─────────────┤ │ 0 │ 'endowment' │ 'Compact<u128>' │ 'BalanceOf' │ │ 1 │ 'gasLimit' │ 'Compact<u64>' │ 'Weight' │ │ 2 │ 'code' │ 'Bytes' │ 'Bytes' │ │ 3 │ 'data' │ 'Bytes' │ 'Bytes' │ │ 4 │ 'salt' │ 'Bytes' │ 'Bytes' │ └─────────┴─────────────┴─────────────────┴─────────────┘

contracts.instantiate

docs
@ Instantiates a contract from a previously deployed wasm binary. @ @ This function is identical to [`Self::instantiate_with_code`] but without the @ code deployment step. Instead, the `code_hash` of an on-chain deployed wasm binary @ must be supplied.
args
┌─────────┬─────────────┬─────────────────┬─────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼─────────────┼─────────────────┼─────────────┤ │ 0 │ 'endowment' │ 'Compact<u128>' │ 'BalanceOf' │ │ 1 │ 'gasLimit' │ 'Compact<u64>' │ 'Weight' │ │ 2 │ 'codeHash' │ 'H256' │ 'CodeHash' │ │ 3 │ 'data' │ 'Bytes' │ 'Bytes' │ │ 4 │ 'salt' │ 'Bytes' │ 'Bytes' │ └─────────┴─────────────┴─────────────────┴─────────────┘

council:

council.setMembers

docs
@ 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. @ @ # <weight> @ ## Weight @ - `O(MP + N)` where: @ - `M` old-members-count (code- and governance-bounded) @ - `N` new-members-count (code- and governance-bounded) @ - `P` proposals-count (code-bounded) @ - DB: @ - 1 storage mutation (codec `O(M)` read, `O(N)` write) for reading and writing the @ members @ - 1 storage read (codec `O(P)`) for reading the proposals @ - `P` storage mutations (codec `O(M)`) for updating the votes for each proposal @ - 1 storage write (codec `O(1)`) for deleting the old `prime` and setting the new one @ # </weight>
args
┌─────────┬──────────────┬───────────────────────┬─────────────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼──────────────┼───────────────────────┼─────────────────────┤ │ 0 │ 'newMembers' │ 'Vec<AccountId32>' │ 'Vec<AccountId>' │ │ 1 │ 'prime' │ 'Option<AccountId32>' │ 'Option<AccountId>' │ │ 2 │ 'oldCount' │ 'u32' │ 'MemberCount' │ └─────────┴──────────────┴───────────────────────┴─────────────────────┘

council.execute

docs
@ Dispatch a proposal from a member using the `Member` origin. @ @ Origin must be a member of the collective. @ @ # <weight> @ ## Weight @ - `O(M + P)` where `M` members-count (code-bounded) and `P` complexity of dispatching @ `proposal` @ - DB: 1 read (codec `O(M)`) + DB access of `proposal` @ - 1 event @ # </weight>
args
┌─────────┬───────────────┬────────────────┬────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼───────────────┼────────────────┼────────────┤ │ 0 │ 'proposal' │ 'Call' │ 'Proposal' │ │ 1 │ 'lengthBound' │ 'Compact<u32>' │ 'u32' │ └─────────┴───────────────┴────────────────┴────────────┘

council.propose

docs
@ 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. @ @ # <weight> @ ## Weight @ - `O(B + M + P1)` or `O(B + M + P2)` where: @ - `B` is `proposal` size in bytes (length-fee-bounded) @ - `M` is members-count (code- and governance-bounded) @ - branching is influenced by `threshold` where: @ - `P1` is proposal execution complexity (`threshold < 2`) @ - `P2` is proposals-count (code-bounded) (`threshold >= 2`) @ - DB: @ - 1 storage read `is_member` (codec `O(M)`) @ - 1 storage read `ProposalOf::contains_key` (codec `O(1)`) @ - DB accesses influenced by `threshold`: @ - EITHER storage accesses done by `proposal` (`threshold < 2`) @ - OR proposal insertion (`threshold <= 2`) @ - 1 storage mutation `Proposals` (codec `O(P2)`) @ - 1 storage mutation `ProposalCount` (codec `O(1)`) @ - 1 storage write `ProposalOf` (codec `O(B)`) @ - 1 storage write `Voting` (codec `O(M)`) @ - 1 event @ # </weight>
args
┌─────────┬───────────────┬────────────────┬───────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼───────────────┼────────────────┼───────────────┤ │ 0 │ 'threshold' │ 'Compact<u32>' │ 'MemberCount' │ │ 1 │ 'proposal' │ 'Call' │ 'Proposal' │ │ 2 │ 'lengthBound' │ 'Compact<u32>' │ 'u32' │ └─────────┴───────────────┴────────────────┴───────────────┘

council.vote

docs
@ 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. @ # <weight> @ ## Weight @ - `O(M)` where `M` is members-count (code- and governance-bounded) @ - DB: @ - 1 storage read `Members` (codec `O(M)`) @ - 1 storage mutation `Voting` (codec `O(M)`) @ - 1 event @ # </weight>
args
┌─────────┬────────────┬────────────────┬─────────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼────────────┼────────────────┼─────────────────┤ │ 0 │ 'proposal' │ 'H256' │ 'Hash' │ │ 1 │ 'index' │ 'Compact<u32>' │ 'ProposalIndex' │ │ 2 │ 'approve' │ 'bool' │ 'bool' │ └─────────┴────────────┴────────────────┴─────────────────┘

council.close

docs
@ 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. @ @ # <weight> @ ## Weight @ - `O(B + M + P1 + P2)` where: @ - `B` is `proposal` size in bytes (length-fee-bounded) @ - `M` is members-count (code- and governance-bounded) @ - `P1` is the complexity of `proposal` preimage. @ - `P2` is proposal-count (code-bounded) @ - DB: @ - 2 storage reads (`Members`: codec `O(M)`, `Prime`: codec `O(1)`) @ - 3 mutations (`Voting`: codec `O(M)`, `ProposalOf`: codec `O(B)`, `Proposals`: codec @ `O(P2)`) @ - any mutations done while executing `proposal` (`P1`) @ - up to 3 events @ # </weight>
args
┌─────────┬───────────────────────┬────────────────┬─────────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼───────────────────────┼────────────────┼─────────────────┤ │ 0 │ 'proposalHash' │ 'H256' │ 'Hash' │ │ 1 │ 'index' │ 'Compact<u32>' │ 'ProposalIndex' │ │ 2 │ 'proposalWeightBound' │ 'Compact<u64>' │ 'Weight' │ │ 3 │ 'lengthBound' │ 'Compact<u32>' │ 'u32' │ └─────────┴───────────────────────┴────────────────┴─────────────────┘

council.disapproveProposal

docs
@ 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. @ @ # <weight> @ Complexity: O(P) where P is the number of max proposals @ DB Weight: @ * Reads: Proposals @ * Writes: Voting, Proposals, ProposalOf @ # </weight>
args
┌─────────┬────────────────┬────────┬──────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼────────────────┼────────┼──────────┤ │ 0 │ 'proposalHash' │ 'H256' │ 'Hash' │ └─────────┴────────────────┴────────┴──────────┘

currencies:

currencies.transfer

docs
@ Transfer some balance to another account under `currency_id`. @ @ The dispatch origin for this call must be `Signed` by the @ transactor.
args
┌─────────┬──────────────┬─────────────────┬────────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼──────────────┼─────────────────┼────────────────┤ │ 0 │ 'dest' │ 'MultiAddress' │ 'LookupSource' │ │ 1 │ 'currencyId' │ 'u32' │ 'CurrencyIdOf' │ │ 2 │ 'amount' │ 'Compact<u128>' │ 'BalanceOf' │ └─────────┴──────────────┴─────────────────┴────────────────┘

currencies.transferNativeCurrency

docs
@ Transfer some native currency to another account. @ @ The dispatch origin for this call must be `Signed` by the @ transactor.
args
┌─────────┬──────────┬─────────────────┬────────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼──────────┼─────────────────┼────────────────┤ │ 0 │ 'dest' │ 'MultiAddress' │ 'LookupSource' │ │ 1 │ 'amount' │ 'Compact<u128>' │ 'BalanceOf' │ └─────────┴──────────┴─────────────────┴────────────────┘

currencies.updateBalance

docs
@ update amount of account `who` under `currency_id`. @ @ The dispatch origin of this call must be _Root_.
args
┌─────────┬──────────────┬────────────────┬────────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼──────────────┼────────────────┼────────────────┤ │ 0 │ 'who' │ 'MultiAddress' │ 'LookupSource' │ │ 1 │ 'currencyId' │ 'u32' │ 'CurrencyIdOf' │ │ 2 │ 'amount' │ 'i128' │ 'AmountOf' │ └─────────┴──────────────┴────────────────┴────────────────┘

democracy:

democracy.propose

docs
@ 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)`
args
┌─────────┬────────────────┬─────────────────┬─────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼────────────────┼─────────────────┼─────────────┤ │ 0 │ 'proposalHash' │ 'H256' │ 'Hash' │ │ 1 │ 'value' │ 'Compact<u128>' │ 'BalanceOf' │ └─────────┴────────────────┴─────────────────┴─────────────┘

democracy.second

docs
@ 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.
args
┌─────────┬─────────────────────┬────────────────┬─────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼─────────────────────┼────────────────┼─────────────┤ │ 0 │ 'proposal' │ 'Compact<u32>' │ 'PropIndex' │ │ 1 │ 'secondsUpperBound' │ 'Compact<u32>' │ 'u32' │ └─────────┴─────────────────────┴────────────────┴─────────────┘

democracy.vote

docs
@ 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.
args
┌─────────┬────────────┬──────────────────────────────────┬───────────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼────────────┼──────────────────────────────────┼───────────────────┤ │ 0 │ 'refIndex' │ 'Compact<u32>' │ 'ReferendumIndex' │ │ 1 │ 'vote' │ 'PalletDemocracyVoteAccountVote' │ 'AccountVote' │ └─────────┴────────────┴──────────────────────────────────┴───────────────────┘

democracy.emergencyCancel

docs
@ 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)`.
args
┌─────────┬────────────┬───────┬───────────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼────────────┼───────┼───────────────────┤ │ 0 │ 'refIndex' │ 'u32' │ 'ReferendumIndex' │ └─────────┴────────────┴───────┴───────────────────┘

democracy.externalPropose

docs
@ 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
args
┌─────────┬────────────────┬────────┬──────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼────────────────┼────────┼──────────┤ │ 0 │ 'proposalHash' │ 'H256' │ 'Hash' │ └─────────┴────────────────┴────────┴──────────┘

democracy.externalProposeMajority

docs
@ 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)`
args
┌─────────┬────────────────┬────────┬──────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼────────────────┼────────┼──────────┤ │ 0 │ 'proposalHash' │ 'H256' │ 'Hash' │ └─────────┴────────────────┴────────┴──────────┘

democracy.externalProposeDefault

docs
@ 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)`
args
┌─────────┬────────────────┬────────┬──────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼────────────────┼────────┼──────────┤ │ 0 │ 'proposalHash' │ 'H256' │ 'Hash' │ └─────────┴────────────────┴────────┴──────────┘

democracy.fastTrack

docs
@ 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)`
args
┌─────────┬────────────────┬────────┬───────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼────────────────┼────────┼───────────────┤ │ 0 │ 'proposalHash' │ 'H256' │ 'Hash' │ │ 1 │ 'votingPeriod' │ 'u32' │ 'BlockNumber' │ │ 2 │ 'delay' │ 'u32' │ 'BlockNumber' │ └─────────┴────────────────┴────────┴───────────────┘

democracy.vetoExternal

docs
@ 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`
args
┌─────────┬────────────────┬────────┬──────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼────────────────┼────────┼──────────┤ │ 0 │ 'proposalHash' │ 'H256' │ 'Hash' │ └─────────┴────────────────┴────────┴──────────┘

democracy.cancelReferendum

docs
@ Remove a referendum. @ @ The dispatch origin of this call must be _Root_. @ @ - `ref_index`: The index of the referendum to cancel. @ @ # Weight: `O(1)`.
args
┌─────────┬────────────┬────────────────┬───────────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼────────────┼────────────────┼───────────────────┤ │ 0 │ 'refIndex' │ 'Compact<u32>' │ 'ReferendumIndex' │ └─────────┴────────────┴────────────────┴───────────────────┘

democracy.cancelQueued

docs
@ 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`.
args
┌─────────┬─────────┬───────┬───────────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼─────────┼───────┼───────────────────┤ │ 0 │ 'which' │ 'u32' │ 'ReferendumIndex' │ └─────────┴─────────┴───────┴───────────────────┘

democracy.delegate

docs
@ 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.
args
┌─────────┬──────────────┬─────────────────────────────┬──────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼──────────────┼─────────────────────────────┼──────────────┤ │ 0 │ 'to' │ 'AccountId32' │ 'AccountId' │ │ 1 │ 'conviction' │ 'PalletDemocracyConviction' │ 'Conviction' │ │ 2 │ 'balance' │ 'u128' │ 'BalanceOf' │ └─────────┴──────────────┴─────────────────────────────┴──────────────┘

democracy.undelegate

docs
@ 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.
args
┌─────────┐ │ (index) │ ├─────────┤ └─────────┘

democracy.clearPublicProposals

docs
@ Clears all public proposals. @ @ The dispatch origin of this call must be _Root_. @ @ Weight: `O(1)`.
args
┌─────────┐ │ (index) │ ├─────────┤ └─────────┘

democracy.notePreimage

docs
@ 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).
args
┌─────────┬───────────────────┬─────────┬──────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼───────────────────┼─────────┼──────────┤ │ 0 │ 'encodedProposal' │ 'Bytes' │ 'Bytes' │ └─────────┴───────────────────┴─────────┴──────────┘

democracy.notePreimageOperational

docs
@ Same as `note_preimage` but origin is `OperationalPreimageOrigin`.
args
┌─────────┬───────────────────┬─────────┬──────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼───────────────────┼─────────┼──────────┤ │ 0 │ 'encodedProposal' │ 'Bytes' │ 'Bytes' │ └─────────┴───────────────────┴─────────┴──────────┘

democracy.noteImminentPreimage

docs
@ 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).
args
┌─────────┬───────────────────┬─────────┬──────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼───────────────────┼─────────┼──────────┤ │ 0 │ 'encodedProposal' │ 'Bytes' │ 'Bytes' │ └─────────┴───────────────────┴─────────┴──────────┘

democracy.noteImminentPreimageOperational

docs
@ Same as `note_imminent_preimage` but origin is `OperationalPreimageOrigin`.
args
┌─────────┬───────────────────┬─────────┬──────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼───────────────────┼─────────┼──────────┤ │ 0 │ 'encodedProposal' │ 'Bytes' │ 'Bytes' │ └─────────┴───────────────────┴─────────┴──────────┘

democracy.reapPreimage

docs
@ 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.
args
┌─────────┬─────────────────────────┬────────────────┬──────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼─────────────────────────┼────────────────┼──────────┤ │ 0 │ 'proposalHash' │ 'H256' │ 'Hash' │ │ 1 │ 'proposalLenUpperBound' │ 'Compact<u32>' │ 'u32' │ └─────────┴─────────────────────────┴────────────────┴──────────┘

democracy.unlock

docs
@ 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.
args
┌─────────┬──────────┬───────────────┬─────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼──────────┼───────────────┼─────────────┤ │ 0 │ 'target' │ 'AccountId32' │ 'AccountId' │ └─────────┴──────────┴───────────────┴─────────────┘

democracy.removeVote

docs
@ 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.
args
┌─────────┬─────────┬───────┬───────────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼─────────┼───────┼───────────────────┤ │ 0 │ 'index' │ 'u32' │ 'ReferendumIndex' │ └─────────┴─────────┴───────┴───────────────────┘

democracy.removeOtherVote

docs
@ 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.
args
┌─────────┬──────────┬───────────────┬───────────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼──────────┼───────────────┼───────────────────┤ │ 0 │ 'target' │ 'AccountId32' │ 'AccountId' │ │ 1 │ 'index' │ 'u32' │ 'ReferendumIndex' │ └─────────┴──────────┴───────────────┴───────────────────┘

democracy.enactProposal

docs
@ Enact a proposal from a referendum. For now we just make the weight be the maximum.
args
┌─────────┬────────────────┬────────┬───────────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼────────────────┼────────┼───────────────────┤ │ 0 │ 'proposalHash' │ 'H256' │ 'Hash' │ │ 1 │ 'index' │ 'u32' │ 'ReferendumIndex' │ └─────────┴────────────────┴────────┴───────────────────┘

democracy.blacklist

docs
@ 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).
args
┌─────────┬─────────────────┬───────────────┬───────────────────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼─────────────────┼───────────────┼───────────────────────────┤ │ 0 │ 'proposalHash' │ 'H256' │ 'Hash' │ │ 1 │ 'maybeRefIndex' │ 'Option<u32>' │ 'Option<ReferendumIndex>' │ └─────────┴─────────────────┴───────────────┴───────────────────────────┘

democracy.cancelProposal

docs
@ 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()`
args
┌─────────┬─────────────┬────────────────┬─────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼─────────────┼────────────────┼─────────────┤ │ 0 │ 'propIndex' │ 'Compact<u32>' │ 'PropIndex' │ └─────────┴─────────────┴────────────────┴─────────────┘

deposit:

deposit.depositBalance

docs
args
┌─────────┬───────────┬────────┬─────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼───────────┼────────┼─────────────┤ │ 0 │ 'address' │ 'H160' │ 'H160' │ │ 1 │ 'value' │ 'u128' │ 'BalanceOf' │ └─────────┴───────────┴────────┴─────────────┘

electionProviderMultiPhase:

electionProviderMultiPhase.submitUnsigned

docs
@ Submit a solution for the unsigned phase. @ @ The dispatch origin fo this call must be __none__. @ @ This submission is checked on the fly. Moreover, this unsigned solution is only @ validated when submitted to the pool from the **local** node. Effectively, this means @ that only active validators can submit this transaction when authoring a block (similar @ to an inherent). @ @ To prevent any incorrect solution (and thus wasted time/weight), this transaction will @ panic if the solution submitted by the validator is invalid in any way, effectively @ putting their authoring reward at risk. @ @ No deposit or reward is associated with this submission.
args
┌─────────┬───────────────┬──────────────────────────────────────────────────────────┬──────────────────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼───────────────┼──────────────────────────────────────────────────────────┼──────────────────────────┤ │ 0 │ 'rawSolution' │ 'PalletElectionProviderMultiPhaseRawSolution' │ 'RawSolution' │ │ 1 │ 'witness' │ 'PalletElectionProviderMultiPhaseSolutionOrSnapshotSize' │ 'SolutionOrSnapshotSize' │ └─────────┴───────────────┴──────────────────────────────────────────────────────────┴──────────────────────────┘

electionProviderMultiPhase.setMinimumUntrustedScore

docs
@ Set a new value for `MinimumUntrustedScore`. @ @ Dispatch origin must be aligned with `T::ForceOrigin`. @ @ This check can be turned off by setting the value to `None`.
args
┌─────────┬──────────────────┬────────────────────┬─────────────────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼──────────────────┼────────────────────┼─────────────────────────┤ │ 0 │ 'maybeNextScore' │ 'Option<[u128;3]>' │ 'Option<ElectionScore>' │ └─────────┴──────────────────┴────────────────────┴─────────────────────────┘

electionProviderMultiPhase.setEmergencyElectionResult

docs
@ Set a solution in the queue, to be handed out to the client of this pallet in the next @ call to `ElectionProvider::elect`. @ @ This can only be set by `T::ForceOrigin`, and only when the phase is `Emergency`. @ @ The solution is not checked for any feasibility and is assumed to be trustworthy, as any @ feasibility check itself can in principle cause the election process to fail (due to @ memory/weight constrains).
args
┌─────────┬────────────┬─────────────────────────────────────────────┬────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼────────────┼─────────────────────────────────────────────┼────────────┤ │ 0 │ 'supports' │ 'Vec<(AccountId32,SpNposElectionsSupport)>' │ 'Supports' │ └─────────┴────────────┴─────────────────────────────────────────────┴────────────┘

electionProviderMultiPhase.submit

docs
@ Submit a solution for the signed phase. @ @ The dispatch origin fo this call must be __signed__. @ @ The solution is potentially queued, based on the claimed score and processed at the end @ of the signed phase. @ @ A deposit is reserved and recorded for the solution. Based on the outcome, the solution @ might be rewarded, slashed, or get all or a part of the deposit back. @ @ # <weight> @ Queue size must be provided as witness data. @ # </weight>
args
┌─────────┬────────────────────────┬───────────────────────────────────────────────┬───────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼────────────────────────┼───────────────────────────────────────────────┼───────────────┤ │ 0 │ 'rawSolution' │ 'PalletElectionProviderMultiPhaseRawSolution' │ 'RawSolution' │ │ 1 │ 'numSignedSubmissions' │ 'u32' │ 'u32' │ └─────────┴────────────────────────┴───────────────────────────────────────────────┴───────────────┘

elections:

elections.vote

docs
@ 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 total 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. @ @ # <weight> @ We assume the maximum weight among all 3 cases: vote_equal, vote_more and vote_less. @ # </weight>
args
┌─────────┬─────────┬────────────────────┬──────────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼─────────┼────────────────────┼──────────────────┤ │ 0 │ 'votes' │ 'Vec<AccountId32>' │ 'Vec<AccountId>' │ │ 1 │ 'value' │ 'Compact<u128>' │ 'BalanceOf' │ └─────────┴─────────┴────────────────────┴──────────────────┘

elections.removeVoter

docs
@ 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.
args
┌─────────┐ │ (index) │ ├─────────┤ └─────────┘

elections.submitCandidacy

docs
@ 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. @ @ # <weight> @ The number of current candidates must be provided as witness data. @ # </weight>
args
┌─────────┬──────────────────┬────────────────┬──────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼──────────────────┼────────────────┼──────────┤ │ 0 │ 'candidateCount' │ 'Compact<u32>' │ 'u32' │ └─────────┴──────────────────┴────────────────┴──────────┘

elections.renounceCandidacy

docs
@ 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`](Self::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. @ @ # <weight> @ The type of renouncing must be provided as witness data. @ # </weight>
args
┌─────────┬──────────────┬─────────────────────────────────────┬──────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼──────────────┼─────────────────────────────────────┼──────────────┤ │ 0 │ 'renouncing' │ 'PalletElectionsPhragmenRenouncing' │ 'Renouncing' │ └─────────┴──────────────┴─────────────────────────────────────┴──────────────┘

elections.removeMember

docs
@ 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. @ @ # <weight> @ If we have a replacement, we use a small weight. Else, since this is a root call and @ will go into phragmen, we assume full block for now. @ # </weight>
args
┌─────────┬──────────────────┬────────────────┬────────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼──────────────────┼────────────────┼────────────────┤ │ 0 │ 'who' │ 'MultiAddress' │ 'LookupSource' │ │ 1 │ 'hasReplacement' │ 'bool' │ 'bool' │ └─────────┴──────────────────┴────────────────┴────────────────┘

elections.cleanDefunctVoters

docs
@ 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. @ @ # <weight> @ The total number of voters and those that are defunct must be provided as witness data. @ # </weight>
args
┌─────────┬──────────────┬───────┬──────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼──────────────┼───────┼──────────┤ │ 0 │ 'numVoters' │ 'u32' │ 'u32' │ │ 1 │ 'numDefunct' │ 'u32' │ 'u32' │ └─────────┴──────────────┴───────┴──────────┘

ethereum:

ethereum.transact

docs
@ Transact an Ethereum transaction.
args
┌─────────┬───────────────┬────────────────────────────────────┬───────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼───────────────┼────────────────────────────────────┼───────────────┤ │ 0 │ 'transaction' │ 'EthereumTransactionTransactionV2' │ 'Transaction' │ └─────────┴───────────────┴────────────────────────────────────┴───────────────┘

ethereumChainId:

ethereumChainId.setChainId

docs
@ set chain_id
args
┌─────────┬───────────┬───────┬──────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼───────────┼───────┼──────────┤ │ 0 │ 'chainId' │ 'u64' │ 'u64' │ └─────────┴───────────┴───────┴──────────┘

evm:

evm.withdraw

docs
@ Withdraw balance from EVM into currency/balances pallet.
args
┌─────────┬───────────┬────────┬─────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼───────────┼────────┼─────────────┤ │ 0 │ 'address' │ 'H160' │ 'H160' │ │ 1 │ 'value' │ 'u128' │ 'BalanceOf' │ └─────────┴───────────┴────────┴─────────────┘

evm.call

docs
@ Issue an EVM call operation. This is similar to a message call transaction in Ethereum.
args
┌─────────┬────────────────────────┬─────────────────────────┬─────────────────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼────────────────────────┼─────────────────────────┼─────────────────────────┤ │ 0 │ 'source' │ 'H160' │ 'H160' │ │ 1 │ 'target' │ 'H160' │ 'H160' │ │ 2 │ 'input' │ 'Bytes' │ 'Bytes' │ │ 3 │ 'value' │ 'U256' │ 'U256' │ │ 4 │ 'gasLimit' │ 'u64' │ 'u64' │ │ 5 │ 'maxFeePerGas' │ 'U256' │ 'U256' │ │ 6 │ 'maxPriorityFeePerGas' │ 'Option<U256>' │ 'Option<U256>' │ │ 7 │ 'nonce' │ 'Option<U256>' │ 'Option<U256>' │ │ 8 │ 'accessList' │ 'Vec<(H160,Vec<H256>)>' │ 'Vec<(H160,Vec<H256>)>' │ └─────────┴────────────────────────┴─────────────────────────┴─────────────────────────┘

evm.create

docs
@ Issue an EVM create operation. This is similar to a contract creation transaction in @ Ethereum.
args
┌─────────┬────────────────────────┬─────────────────────────┬─────────────────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼────────────────────────┼─────────────────────────┼─────────────────────────┤ │ 0 │ 'source' │ 'H160' │ 'H160' │ │ 1 │ 'init' │ 'Bytes' │ 'Bytes' │ │ 2 │ 'value' │ 'U256' │ 'U256' │ │ 3 │ 'gasLimit' │ 'u64' │ 'u64' │ │ 4 │ 'maxFeePerGas' │ 'U256' │ 'U256' │ │ 5 │ 'maxPriorityFeePerGas' │ 'Option<U256>' │ 'Option<U256>' │ │ 6 │ 'nonce' │ 'Option<U256>' │ 'Option<U256>' │ │ 7 │ 'accessList' │ 'Vec<(H160,Vec<H256>)>' │ 'Vec<(H160,Vec<H256>)>' │ └─────────┴────────────────────────┴─────────────────────────┴─────────────────────────┘

evm.create2

docs
@ Issue an EVM create2 operation.
args
┌─────────┬────────────────────────┬─────────────────────────┬─────────────────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼────────────────────────┼─────────────────────────┼─────────────────────────┤ │ 0 │ 'source' │ 'H160' │ 'H160' │ │ 1 │ 'init' │ 'Bytes' │ 'Bytes' │ │ 2 │ 'salt' │ 'H256' │ 'H256' │ │ 3 │ 'value' │ 'U256' │ 'U256' │ │ 4 │ 'gasLimit' │ 'u64' │ 'u64' │ │ 5 │ 'maxFeePerGas' │ 'U256' │ 'U256' │ │ 6 │ 'maxPriorityFeePerGas' │ 'Option<U256>' │ 'Option<U256>' │ │ 7 │ 'nonce' │ 'Option<U256>' │ 'Option<U256>' │ │ 8 │ 'accessList' │ 'Vec<(H160,Vec<H256>)>' │ 'Vec<(H160,Vec<H256>)>' │ └─────────┴────────────────────────┴─────────────────────────┴─────────────────────────┘

grandpa:

grandpa.reportEquivocation

docs
@ 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.
args
┌─────────┬─────────────────────┬──────────────────────────────────────┬─────────────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼─────────────────────┼──────────────────────────────────────┼─────────────────────┤ │ 0 │ 'equivocationProof' │ 'SpFinalityGrandpaEquivocationProof' │ 'EquivocationProof' │ │ 1 │ 'keyOwnerProof' │ 'SpSessionMembershipProof' │ 'KeyOwnerProof' │ └─────────┴─────────────────────┴──────────────────────────────────────┴─────────────────────┘

grandpa.reportEquivocationUnsigned

docs
@ 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.
args
┌─────────┬─────────────────────┬──────────────────────────────────────┬─────────────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼─────────────────────┼──────────────────────────────────────┼─────────────────────┤ │ 0 │ 'equivocationProof' │ 'SpFinalityGrandpaEquivocationProof' │ 'EquivocationProof' │ │ 1 │ 'keyOwnerProof' │ 'SpSessionMembershipProof' │ 'KeyOwnerProof' │ └─────────┴─────────────────────┴──────────────────────────────────────┴─────────────────────┘

grandpa.noteStalled

docs
@ 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.
args
┌─────────┬────────────────────────────┬───────┬───────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼────────────────────────────┼───────┼───────────────┤ │ 0 │ 'delay' │ 'u32' │ 'BlockNumber' │ │ 1 │ 'bestFinalizedBlockNumber' │ 'u32' │ 'BlockNumber' │ └─────────┴────────────────────────────┴───────┴───────────────┘

identity:

identity.addRegistrar

docs
@ 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. @ @ # <weight> @ - `O(R)` where `R` registrar-count (governance-bounded and code-bounded). @ - One storage mutation (codec `O(R)`). @ - One event. @ # </weight>
args
┌─────────┬───────────┬───────────────┬─────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼───────────┼───────────────┼─────────────┤ │ 0 │ 'account' │ 'AccountId32' │ 'AccountId' │ └─────────┴───────────┴───────────────┴─────────────┘

identity.setIdentity

docs
@ 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. @ @ # <weight> @ - `O(X + X' + R)` @ - where `X` additional-field-count (deposit-bounded and code-bounded) @ - where `R` judgements-count (registrar-count-bounded) @ - One balance reserve operation. @ - One storage mutation (codec-read `O(X' + R)`, codec-write `O(X + R)`). @ - One event. @ # </weight>
args
┌─────────┬────────┬──────────────────────────────┬────────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼────────┼──────────────────────────────┼────────────────┤ │ 0 │ 'info' │ 'PalletIdentityIdentityInfo' │ 'IdentityInfo' │ └─────────┴────────┴──────────────────────────────┴────────────────┘

identity.setSubs

docs
@ 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. @ @ # <weight> @ - `O(P + S)` @ - where `P` old-subs-count (hard- and deposit-bounded). @ - where `S` subs-count (hard- and deposit-bounded). @ - At most one balance operations. @ - DB: @ - `P + S` storage mutations (codec complexity `O(1)`) @ - One storage read (codec complexity `O(P)`). @ - One storage write (codec complexity `O(S)`). @ - One storage-exists (`IdentityOf::contains_key`). @ # </weight>
args
┌─────────┬────────┬───────────────────────────┬─────────────────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼────────┼───────────────────────────┼─────────────────────────┤ │ 0 │ 'subs' │ 'Vec<(AccountId32,Data)>' │ 'Vec<(AccountId,Data)>' │ └─────────┴────────┴───────────────────────────┴─────────────────────────┘

identity.clearIdentity

docs
@ 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. @ @ # <weight> @ - `O(R + S + X)` @ - where `R` registrar-count (governance-bounded). @ - where `S` subs-count (hard- and deposit-bounded). @ - where `X` additional-field-count (deposit-bounded and code-bounded). @ - One balance-unreserve operation. @ - `2` storage reads and `S + 2` storage deletions. @ - One event. @ # </weight>
args
┌─────────┐ │ (index) │ ├─────────┤ └─────────┘

identity.requestJudgement

docs
@ 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. @ @ # <weight> @ - `O(R + X)`. @ - One balance-reserve operation. @ - Storage: 1 read `O(R)`, 1 mutate `O(X + R)`. @ - One event. @ # </weight>
args
┌─────────┬────────────┬─────────────────┬──────────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼────────────┼─────────────────┼──────────────────┤ │ 0 │ 'regIndex' │ 'Compact<u32>' │ 'RegistrarIndex' │ │ 1 │ 'maxFee' │ 'Compact<u128>' │ 'BalanceOf' │ └─────────┴────────────┴─────────────────┴──────────────────┘

identity.cancelRequest

docs
@ 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. @ @ # <weight> @ - `O(R + X)`. @ - One balance-reserve operation. @ - One storage mutation `O(R + X)`. @ - One event @ # </weight>
args
┌─────────┬────────────┬───────┬──────────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼────────────┼───────┼──────────────────┤ │ 0 │ 'regIndex' │ 'u32' │ 'RegistrarIndex' │ └─────────┴────────────┴───────┴──────────────────┘

identity.setFee

docs
@ 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. @ @ # <weight> @ - `O(R)`. @ - One storage mutation `O(R)`. @ - Benchmark: 7.315 + R * 0.329 µs (min squares analysis) @ # </weight>
args
┌─────────┬─────────┬─────────────────┬──────────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼─────────┼─────────────────┼──────────────────┤ │ 0 │ 'index' │ 'Compact<u32>' │ 'RegistrarIndex' │ │ 1 │ 'fee' │ 'Compact<u128>' │ 'BalanceOf' │ └─────────┴─────────┴─────────────────┴──────────────────┘

identity.setAccountId

docs
@ 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. @ @ # <weight> @ - `O(R)`. @ - One storage mutation `O(R)`. @ - Benchmark: 8.823 + R * 0.32 µs (min squares analysis) @ # </weight>
args
┌─────────┬─────────┬────────────────┬──────────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼─────────┼────────────────┼──────────────────┤ │ 0 │ 'index' │ 'Compact<u32>' │ 'RegistrarIndex' │ │ 1 │ 'new' │ 'AccountId32' │ 'AccountId' │ └─────────┴─────────┴────────────────┴──────────────────┘

identity.setFields

docs
@ 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. @ @ # <weight> @ - `O(R)`. @ - One storage mutation `O(R)`. @ - Benchmark: 7.464 + R * 0.325 µs (min squares analysis) @ # </weight>
args
┌─────────┬──────────┬──────────────────────────┬──────────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼──────────┼──────────────────────────┼──────────────────┤ │ 0 │ 'index' │ 'Compact<u32>' │ 'RegistrarIndex' │ │ 1 │ 'fields' │ 'PalletIdentityBitFlags' │ 'IdentityFields' │ └─────────┴──────────┴──────────────────────────┴──────────────────┘

identity.provideJudgement

docs
@ 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. @ @ # <weight> @ - `O(R + X)`. @ - One balance-transfer operation. @ - Up to one account-lookup operation. @ - Storage: 1 read `O(R)`, 1 mutate `O(R + X)`. @ - One event. @ # </weight>
args
┌─────────┬─────────────┬───────────────────────────┬──────────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼─────────────┼───────────────────────────┼──────────────────┤ │ 0 │ 'regIndex' │ 'Compact<u32>' │ 'RegistrarIndex' │ │ 1 │ 'target' │ 'MultiAddress' │ 'LookupSource' │ │ 2 │ 'judgement' │ 'PalletIdentityJudgement' │ 'Judgement' │ └─────────┴─────────────┴───────────────────────────┴──────────────────┘

identity.killIdentity

docs
@ 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. @ @ # <weight> @ - `O(R + S + X)`. @ - One balance-reserve operation. @ - `S + 2` storage mutations. @ - One event. @ # </weight>
args
┌─────────┬──────────┬────────────────┬────────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼──────────┼────────────────┼────────────────┤ │ 0 │ 'target' │ 'MultiAddress' │ 'LookupSource' │ └─────────┴──────────┴────────────────┴────────────────┘

identity.addSub

docs
@ 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`.
args
┌─────────┬────────┬────────────────┬────────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼────────┼────────────────┼────────────────┤ │ 0 │ 'sub' │ 'MultiAddress' │ 'LookupSource' │ │ 1 │ 'data' │ 'Data' │ 'Data' │ └─────────┴────────┴────────────────┴────────────────┘

identity.renameSub

docs
@ 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`.
args
┌─────────┬────────┬────────────────┬────────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼────────┼────────────────┼────────────────┤ │ 0 │ 'sub' │ 'MultiAddress' │ 'LookupSource' │ │ 1 │ 'data' │ 'Data' │ 'Data' │ └─────────┴────────┴────────────────┴────────────────┘

identity.removeSub

docs
@ 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`.
args
┌─────────┬───────┬────────────────┬────────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼───────┼────────────────┼────────────────┤ │ 0 │ 'sub' │ 'MultiAddress' │ 'LookupSource' │ └─────────┴───────┴────────────────┴────────────────┘

identity.quitSub

docs
@ 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.
args
┌─────────┐ │ (index) │ ├─────────┤ └─────────┘

imOnline:

imOnline.heartbeat

docs
@ # <weight> @ - Complexity: `O(K + E)` where K is length of `Keys` (heartbeat.validators_len) and E is @ length of `heartbeat.network_state.external_address` @ - `O(K)`: decoding of length `K` @ - `O(E)`: decoding/encoding of length `E` @ - DbReads: pallet_session `Validators`, pallet_session `CurrentIndex`, `Keys`, @ `ReceivedHeartbeats` @ - DbWrites: `ReceivedHeartbeats` @ # </weight>
args
┌─────────┬─────────────┬────────────────────────────────────────────┬─────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼─────────────┼────────────────────────────────────────────┼─────────────┤ │ 0 │ 'heartbeat' │ 'PalletImOnlineHeartbeat' │ 'Heartbeat' │ │ 1 │ 'signature' │ 'PalletImOnlineSr25519AppSr25519Signature' │ 'Signature' │ └─────────┴─────────────┴────────────────────────────────────────────┴─────────────┘

indices:

indices.claim

docs
@ 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. @ @ # <weight> @ - `O(1)`. @ - One storage mutation (codec `O(1)`). @ - One reserve operation. @ - One event. @ ------------------- @ - DB Weight: 1 Read/Write (Accounts) @ # </weight>
args
┌─────────┬─────────┬───────┬────────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼─────────┼───────┼────────────────┤ │ 0 │ 'index' │ 'u32' │ 'AccountIndex' │ └─────────┴─────────┴───────┴────────────────┘

indices.transfer

docs
@ 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. @ @ # <weight> @ - `O(1)`. @ - One storage mutation (codec `O(1)`). @ - One transfer operation. @ - One event. @ ------------------- @ - DB Weight: @ - Reads: Indices Accounts, System Account (recipient) @ - Writes: Indices Accounts, System Account (recipient) @ # </weight>
args
┌─────────┬─────────┬───────────────┬────────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼─────────┼───────────────┼────────────────┤ │ 0 │ 'new' │ 'AccountId32' │ 'AccountId' │ │ 1 │ 'index' │ 'u32' │ 'AccountIndex' │ └─────────┴─────────┴───────────────┴────────────────┘

indices.free

docs
@ 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. @ @ # <weight> @ - `O(1)`. @ - One storage mutation (codec `O(1)`). @ - One reserve operation. @ - One event. @ ------------------- @ - DB Weight: 1 Read/Write (Accounts) @ # </weight>
args
┌─────────┬─────────┬───────┬────────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼─────────┼───────┼────────────────┤ │ 0 │ 'index' │ 'u32' │ 'AccountIndex' │ └─────────┴─────────┴───────┴────────────────┘

indices.forceTransfer

docs
@ 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. @ @ # <weight> @ - `O(1)`. @ - One storage mutation (codec `O(1)`). @ - Up to one reserve operation. @ - One event. @ ------------------- @ - DB Weight: @ - Reads: Indices Accounts, System Account (original owner) @ - Writes: Indices Accounts, System Account (original owner) @ # </weight>
args
┌─────────┬──────────┬───────────────┬────────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼──────────┼───────────────┼────────────────┤ │ 0 │ 'new' │ 'AccountId32' │ 'AccountId' │ │ 1 │ 'index' │ 'u32' │ 'AccountIndex' │ │ 2 │ 'freeze' │ 'bool' │ 'bool' │ └─────────┴──────────┴───────────────┴────────────────┘

indices.freeze

docs
@ 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. @ @ # <weight> @ - `O(1)`. @ - One storage mutation (codec `O(1)`). @ - Up to one slash operation. @ - One event. @ ------------------- @ - DB Weight: 1 Read/Write (Accounts) @ # </weight>
args
┌─────────┬─────────┬───────┬────────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼─────────┼───────┼────────────────┤ │ 0 │ 'index' │ 'u32' │ 'AccountIndex' │ └─────────┴─────────┴───────┴────────────────┘

multisig:

multisig.asMultiThreshold1

docs
@ 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. @ @ # <weight> @ O(Z + C) where Z is the length of the call and C its execution weight. @ ------------------------------- @ - DB Weight: None @ - Plus Call Weight @ # </weight>
args
┌─────────┬────────────────────┬────────────────────┬──────────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼────────────────────┼────────────────────┼──────────────────┤ │ 0 │ 'otherSignatories' │ 'Vec<AccountId32>' │ 'Vec<AccountId>' │ │ 1 │ 'call' │ 'Call' │ 'Call' │ └─────────┴────────────────────┴────────────────────┴──────────────────┘

multisig.asMulti

docs
@ 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. @ @ # <weight> @ - `O(S + Z + Call)`. @ - Up to one balance-reserve or unreserve operation. @ - One passthrough operation, one insert, both `O(S)` where `S` is the number of @ signatories. `S` is capped by `MaxSignatories`, with weight being proportional. @ - One call encode & hash, both of complexity `O(Z)` where `Z` is tx-len. @ - One encode & hash, both of complexity `O(S)`. @ - Up to one binary search and insert (`O(logS + S)`). @ - I/O: 1 read `O(S)`, up to 1 mutate `O(S)`. Up to one remove. @ - One event. @ - The weight of the `call`. @ - Storage: inserts one item, value size bounded by `MaxSignatories`, with a deposit @ taken for its lifetime of `DepositBase + threshold * DepositFactor`. @ ------------------------------- @ - DB Weight: @ - Reads: Multisig Storage, [Caller Account], Calls (if `store_call`) @ - Writes: Multisig Storage, [Caller Account], Calls (if `store_call`) @ - Plus Call Weight @ # </weight>
args
┌─────────┬────────────────────┬───────────────────────────────────┬─────────────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼────────────────────┼───────────────────────────────────┼─────────────────────┤ │ 0 │ 'threshold' │ 'u16' │ 'u16' │ │ 1 │ 'otherSignatories' │ 'Vec<AccountId32>' │ 'Vec<AccountId>' │ │ 2 │ 'maybeTimepoint' │ 'Option<PalletMultisigTimepoint>' │ 'Option<Timepoint>' │ │ 3 │ 'call' │ 'WrapperKeepOpaque<Call>' │ 'OpaqueCall' │ │ 4 │ 'storeCall' │ 'bool' │ 'bool' │ │ 5 │ 'maxWeight' │ 'u64' │ 'Weight' │ └─────────┴────────────────────┴───────────────────────────────────┴─────────────────────┘

multisig.approveAsMulti

docs
@ 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. @ @ # <weight> @ - `O(S)`. @ - Up to one balance-reserve or unreserve operation. @ - One passthrough operation, one insert, both `O(S)` where `S` is the number of @ signatories. `S` is capped by `MaxSignatories`, with weight being proportional. @ - One encode & hash, both of complexity `O(S)`. @ - Up to one binary search and insert (`O(logS + S)`). @ - I/O: 1 read `O(S)`, up to 1 mutate `O(S)`. Up to one remove. @ - One event. @ - Storage: inserts one item, value size bounded by `MaxSignatories`, with a deposit @ taken for its lifetime of `DepositBase + threshold * DepositFactor`. @ ---------------------------------- @ - DB Weight: @ - Read: Multisig Storage, [Caller Account] @ - Write: Multisig Storage, [Caller Account] @ # </weight>
args
┌─────────┬────────────────────┬───────────────────────────────────┬─────────────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼────────────────────┼───────────────────────────────────┼─────────────────────┤ │ 0 │ 'threshold' │ 'u16' │ 'u16' │ │ 1 │ 'otherSignatories' │ 'Vec<AccountId32>' │ 'Vec<AccountId>' │ │ 2 │ 'maybeTimepoint' │ 'Option<PalletMultisigTimepoint>' │ 'Option<Timepoint>' │ │ 3 │ 'callHash' │ '[u8;32]' │ '[u8;32]' │ │ 4 │ 'maxWeight' │ 'u64' │ 'Weight' │ └─────────┴────────────────────┴───────────────────────────────────┴─────────────────────┘

multisig.cancelAsMulti

docs
@ 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. @ @ # <weight> @ - `O(S)`. @ - Up to one balance-reserve or unreserve operation. @ - One passthrough operation, one insert, both `O(S)` where `S` is the number of @ signatories. `S` is capped by `MaxSignatories`, with weight being proportional. @ - One encode & hash, both of complexity `O(S)`. @ - One event. @ - I/O: 1 read `O(S)`, one remove. @ - Storage: removes one item. @ ---------------------------------- @ - DB Weight: @ - Read: Multisig Storage, [Caller Account], Refund Account, Calls @ - Write: Multisig Storage, [Caller Account], Refund Account, Calls @ # </weight>
args
┌─────────┬────────────────────┬───────────────────────────┬──────────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼────────────────────┼───────────────────────────┼──────────────────┤ │ 0 │ 'threshold' │ 'u16' │ 'u16' │ │ 1 │ 'otherSignatories' │ 'Vec<AccountId32>' │ 'Vec<AccountId>' │ │ 2 │ 'timepoint' │ 'PalletMultisigTimepoint' │ 'Timepoint' │ │ 3 │ 'callHash' │ '[u8;32]' │ '[u8;32]' │ └─────────┴────────────────────┴───────────────────────────┴──────────────────┘

nftmart:

nftmart.createClass

docs
@ Create NFT class, tokens belong to the class. @ @ - `metadata`: external metadata @ - `properties`: class property, include `Transferable` `Burnable` @ - `name`: class name, with len limitation. @ - `description`: class description, with len limitation.
args
┌─────────┬───────────────┬───────────────────┬─────────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼───────────────┼───────────────────┼─────────────────┤ │ 0 │ 'metadata' │ 'Bytes' │ 'NFTMetadata' │ │ 1 │ 'name' │ 'Bytes' │ 'Bytes' │ │ 2 │ 'description' │ 'Bytes' │ 'Bytes' │ │ 3 │ 'royaltyRate' │ 'Compact<PerU16>' │ 'PerU16' │ │ 4 │ 'properties' │ 'u64' │ 'Properties' │ │ 5 │ 'categoryIds' │ 'Vec<u64>' │ 'Vec<GlobalId>' │ └─────────┴───────────────┴───────────────────┴─────────────────┘

nftmart.updateClass

docs
@ Update NFT class. @ @ - `class_id`: class id @ - `metadata`: external metadata @ - `properties`: class property, include `Transferable` `Burnable` @ - `name`: class name, with len limitation. @ - `description`: class description, with len limitation.
args
┌─────────┬───────────────┬───────────────────┬─────────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼───────────────┼───────────────────┼─────────────────┤ │ 0 │ 'classId' │ 'Compact<u32>' │ 'ClassIdOf' │ │ 1 │ 'metadata' │ 'Bytes' │ 'NFTMetadata' │ │ 2 │ 'name' │ 'Bytes' │ 'Bytes' │ │ 3 │ 'description' │ 'Bytes' │ 'Bytes' │ │ 4 │ 'royaltyRate' │ 'Compact<PerU16>' │ 'PerU16' │ │ 5 │ 'properties' │ 'u64' │ 'Properties' │ │ 6 │ 'categoryIds' │ 'Vec<u64>' │ 'Vec<GlobalId>' │ └─────────┴───────────────┴───────────────────┴─────────────────┘

nftmart.updateTokenRoyalty

docs
@ Update token royalty.
args
┌─────────┬─────────────────┬──────────────────┬──────────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼─────────────────┼──────────────────┼──────────────────┤ │ 0 │ 'classId' │ 'Compact<u32>' │ 'ClassIdOf' │ │ 1 │ 'tokenId' │ 'Compact<u64>' │ 'TokenIdOf' │ │ 2 │ 'chargeRoyalty' │ 'Option<PerU16>' │ 'Option<PerU16>' │ └─────────┴─────────────────┴──────────────────┴──────────────────┘

nftmart.updateTokenRoyaltyBeneficiary

docs
@ Update token royalty beneficiary.
args
┌─────────┬───────────┬────────────────┬────────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼───────────┼────────────────┼────────────────┤ │ 0 │ 'classId' │ 'Compact<u32>' │ 'ClassIdOf' │ │ 1 │ 'tokenId' │ 'Compact<u64>' │ 'TokenIdOf' │ │ 2 │ 'to' │ 'MultiAddress' │ 'LookupSource' │ └─────────┴───────────┴────────────────┴────────────────┘

nftmart.updateTokenMetadata

docs
@ Update token metadata.
args
┌─────────┬────────────┬────────────────┬───────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼────────────┼────────────────┼───────────────┤ │ 0 │ 'classId' │ 'Compact<u32>' │ 'ClassIdOf' │ │ 1 │ 'tokenId' │ 'Compact<u64>' │ 'TokenIdOf' │ │ 2 │ 'metadata' │ 'Bytes' │ 'NFTMetadata' │ └─────────┴────────────┴────────────────┴───────────────┘

nftmart.updateToken

docs
@ Update token royalty_beneficiary, quantity, metadata, and royalty.
args
┌─────────┬─────────────────┬──────────────────┬──────────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼─────────────────┼──────────────────┼──────────────────┤ │ 0 │ 'to' │ 'MultiAddress' │ 'LookupSource' │ │ 1 │ 'classId' │ 'Compact<u32>' │ 'ClassIdOf' │ │ 2 │ 'tokenId' │ 'Compact<u64>' │ 'TokenIdOf' │ │ 3 │ 'quantity' │ 'Compact<u64>' │ 'TokenIdOf' │ │ 4 │ 'metadata' │ 'Bytes' │ 'NFTMetadata' │ │ 5 │ 'chargeRoyalty' │ 'Option<PerU16>' │ 'Option<PerU16>' │ └─────────┴─────────────────┴──────────────────┴──────────────────┘

nftmart.mint

docs
@ Mint NFT token @ @ - `to`: the token owner's account @ - `class_id`: token belong to the class id @ - `metadata`: external metadata @ - `quantity`: token quantity
args
┌─────────┬─────────────────┬──────────────────┬──────────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼─────────────────┼──────────────────┼──────────────────┤ │ 0 │ 'to' │ 'MultiAddress' │ 'LookupSource' │ │ 1 │ 'classId' │ 'Compact<u32>' │ 'ClassIdOf' │ │ 2 │ 'metadata' │ 'Bytes' │ 'NFTMetadata' │ │ 3 │ 'quantity' │ 'Compact<u64>' │ 'TokenIdOf' │ │ 4 │ 'chargeRoyalty' │ 'Option<PerU16>' │ 'Option<PerU16>' │ └─────────┴─────────────────┴──────────────────┴──────────────────┘

nftmart.proxyMint

docs
@ Mint NFT token by a proxy account. @ @ - `origin`: a proxy account
args
┌─────────┬─────────────────┬──────────────────┬──────────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼─────────────────┼──────────────────┼──────────────────┤ │ 0 │ 'to' │ 'MultiAddress' │ 'LookupSource' │ │ 1 │ 'classId' │ 'Compact<u32>' │ 'ClassIdOf' │ │ 2 │ 'metadata' │ 'Bytes' │ 'NFTMetadata' │ │ 3 │ 'quantity' │ 'Compact<u64>' │ 'TokenIdOf' │ │ 4 │ 'chargeRoyalty' │ 'Option<PerU16>' │ 'Option<PerU16>' │ └─────────┴─────────────────┴──────────────────┴──────────────────┘

nftmart.transfer

docs
@ Transfer NFT tokens to another account @ @ - `to`: the token owner's account @ - `class_id`: class id @ - `token_id`: token id @ - `quantity`: quantity
args
┌─────────┬─────────┬──────────────────────┬────────────────────────────────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼─────────┼──────────────────────┼────────────────────────────────────────┤ │ 0 │ 'to' │ 'MultiAddress' │ 'LookupSource' │ │ 1 │ 'items' │ 'Vec<(u32,u64,u64)>' │ 'Vec<(ClassIdOf,TokenIdOf,TokenIdOf)>' │ └─────────┴─────────┴──────────────────────┴────────────────────────────────────────┘

nftmart.burn

docs
@ Burn NFT token @ @ - `class_id`: class id @ - `token_id`: token id @ - `quantity`: quantity
args
┌─────────┬────────────┬────────────────┬─────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼────────────┼────────────────┼─────────────┤ │ 0 │ 'classId' │ 'Compact<u32>' │ 'ClassIdOf' │ │ 1 │ 'tokenId' │ 'Compact<u64>' │ 'TokenIdOf' │ │ 2 │ 'quantity' │ 'Compact<u64>' │ 'TokenIdOf' │ └─────────┴────────────┴────────────────┴─────────────┘

nftmart.destroyClass

docs
@ Destroy NFT class @ @ - `class_id`: destroy class id @ - `dest`: transfer reserve balance from sub_account to dest
args
┌─────────┬───────────┬────────────────┬────────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼───────────┼────────────────┼────────────────┤ │ 0 │ 'classId' │ 'Compact<u32>' │ 'ClassIdOf' │ │ 1 │ 'dest' │ 'MultiAddress' │ 'LookupSource' │ └─────────┴───────────┴────────────────┴────────────────┘

nftmartAuction:

nftmartAuction.submitDutchAuction

docs
args
┌─────────┬───────────────────────┬──────────────────────┬────────────────────────────────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼───────────────────────┼──────────────────────┼────────────────────────────────────────┤ │ 0 │ 'currencyId' │ 'Compact<u32>' │ 'CurrencyIdOf' │ │ 1 │ 'deposit' │ 'Compact<u128>' │ 'Balance' │ │ 2 │ 'minPrice' │ 'Compact<u128>' │ 'Balance' │ │ 3 │ 'maxPrice' │ 'Compact<u128>' │ 'Balance' │ │ 4 │ 'deadline' │ 'Compact<u32>' │ 'BlockNumberOf' │ │ 5 │ 'items' │ 'Vec<(u32,u64,u64)>' │ 'Vec<(ClassIdOf,TokenIdOf,TokenIdOf)>' │ │ 6 │ 'allowBritishAuction' │ 'bool' │ 'bool' │ │ 7 │ 'minRaise' │ 'Compact<PerU16>' │ 'PerU16' │ │ 8 │ 'commissionRate' │ 'Compact<PerU16>' │ 'PerU16' │ └─────────┴───────────────────────┴──────────────────────┴────────────────────────────────────────┘

nftmartAuction.bidDutchAuction

docs
args
┌─────────┬───────────────────┬───────────────────────┬─────────────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼───────────────────┼───────────────────────┼─────────────────────┤ │ 0 │ 'price' │ 'Compact<u128>' │ 'Balance' │ │ 1 │ 'auctionOwner' │ 'MultiAddress' │ 'LookupSource' │ │ 2 │ 'auctionId' │ 'Compact<u64>' │ 'GlobalId' │ │ 3 │ 'commissionAgent' │ 'Option<AccountId32>' │ 'Option<AccountId>' │ │ 4 │ 'commissionData' │ 'Option<Bytes>' │ 'Option<Bytes>' │ └─────────┴───────────────────┴───────────────────────┴─────────────────────┘

nftmartAuction.redeemDutchAuction

docs
@ redeem
args
┌─────────┬────────────────┬────────────────┬────────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼────────────────┼────────────────┼────────────────┤ │ 0 │ 'auctionOwner' │ 'MultiAddress' │ 'LookupSource' │ │ 1 │ 'auctionId' │ 'Compact<u64>' │ 'GlobalId' │ └─────────┴────────────────┴────────────────┴────────────────┘

nftmartAuction.removeDutchAuction

docs
@ remove a dutch auction by auction owner.
args
┌─────────┬─────────────┬────────────────┬────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼─────────────┼────────────────┼────────────┤ │ 0 │ 'auctionId' │ 'Compact<u64>' │ 'GlobalId' │ └─────────┴─────────────┴────────────────┴────────────┘

nftmartAuction.removeExpiredDutchAuction

docs
@ remove an expired dutch auction by auction owner.
args
┌─────────┬────────────────┬────────────────┬─────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼────────────────┼────────────────┼─────────────┤ │ 0 │ 'auctionOwner' │ 'AccountId32' │ 'AccountId' │ │ 1 │ 'auctionId' │ 'Compact<u64>' │ 'GlobalId' │ └─────────┴────────────────┴────────────────┴─────────────┘

nftmartAuction.submitBritishAuction

docs
@ Create an British auction. @ @ - `currency_id`: Currency Id @ - `hammer_price`: If somebody offer this price, the auction will be finished. Set to zero to disable. @ - `min_raise`: The next price of bid should be larger than old_price * ( 1 + min_raise ) @ - `deposit`: A higher deposit will be good for the display of the auction in the market. @ - `init_price`: The initial price for the auction to kick off. @ - `deadline`: A block number which represents the end of the auction activity. @ - `allow_delay`: If ture, in some cases the deadline will be extended. @ - `items`: Nft list.
args
┌─────────┬──────────────────┬──────────────────────┬────────────────────────────────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼──────────────────┼──────────────────────┼────────────────────────────────────────┤ │ 0 │ 'currencyId' │ 'Compact<u32>' │ 'CurrencyIdOf' │ │ 1 │ 'hammerPrice' │ 'Compact<u128>' │ 'Balance' │ │ 2 │ 'minRaise' │ 'Compact<PerU16>' │ 'PerU16' │ │ 3 │ 'deposit' │ 'Compact<u128>' │ 'Balance' │ │ 4 │ 'initPrice' │ 'Compact<u128>' │ 'Balance' │ │ 5 │ 'deadline' │ 'Compact<u32>' │ 'BlockNumberOf' │ │ 6 │ 'allowDelay' │ 'bool' │ 'bool' │ │ 7 │ 'items' │ 'Vec<(u32,u64,u64)>' │ 'Vec<(ClassIdOf,TokenIdOf,TokenIdOf)>' │ │ 8 │ 'commissionRate' │ 'Compact<PerU16>' │ 'PerU16' │ └─────────┴──────────────────┴──────────────────────┴────────────────────────────────────────┘

nftmartAuction.bidBritishAuction

docs
@ Bid
args
┌─────────┬───────────────────┬───────────────────────┬─────────────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼───────────────────┼───────────────────────┼─────────────────────┤ │ 0 │ 'price' │ 'Compact<u128>' │ 'Balance' │ │ 1 │ 'auctionOwner' │ 'MultiAddress' │ 'LookupSource' │ │ 2 │ 'auctionId' │ 'Compact<u64>' │ 'GlobalId' │ │ 3 │ 'commissionAgent' │ 'Option<AccountId32>' │ 'Option<AccountId>' │ │ 4 │ 'commissionData' │ 'Option<Bytes>' │ 'Option<Bytes>' │ └─────────┴───────────────────┴───────────────────────┴─────────────────────┘

nftmartAuction.redeemBritishAuction

docs
@ redeem
args
┌─────────┬────────────────┬────────────────┬────────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼────────────────┼────────────────┼────────────────┤ │ 0 │ 'auctionOwner' │ 'MultiAddress' │ 'LookupSource' │ │ 1 │ 'auctionId' │ 'Compact<u64>' │ 'GlobalId' │ └─────────┴────────────────┴────────────────┴────────────────┘

nftmartAuction.removeBritishAuction

docs
@ remove an auction by auction owner.
args
┌─────────┬─────────────┬────────────────┬────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼─────────────┼────────────────┼────────────┤ │ 0 │ 'auctionId' │ 'Compact<u64>' │ 'GlobalId' │ └─────────┴─────────────┴────────────────┴────────────┘

nftmartAuction.removeExpiredBritishAuction

docs
@ remove an expired british auction by auction owner.
args
┌─────────┬────────────────┬────────────────┬─────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼────────────────┼────────────────┼─────────────┤ │ 0 │ 'auctionOwner' │ 'AccountId32' │ 'AccountId' │ │ 1 │ 'auctionId' │ 'Compact<u64>' │ 'GlobalId' │ └─────────┴────────────────┴────────────────┴─────────────┘

nftmartConf:

nftmartConf.addWhitelist

docs
@ add an account into whitelist
args
┌─────────┬───────┬───────────────┬─────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼───────┼───────────────┼─────────────┤ │ 0 │ 'who' │ 'AccountId32' │ 'AccountId' │ └─────────┴───────┴───────────────┴─────────────┘

nftmartConf.removeWhitelist

docs
@ remove an account from whitelist
args
┌─────────┬───────┬───────────────┬─────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼───────┼───────────────┼─────────────┤ │ 0 │ 'who' │ 'AccountId32' │ 'AccountId' │ └─────────┴───────┴───────────────┴─────────────┘

nftmartConf.createCategory

docs
@ Create a common category for trading NFT. @ A Selling NFT should belong to a category. @ @ - `metadata`: metadata
args
┌─────────┬────────────┬─────────┬───────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼────────────┼─────────┼───────────────┤ │ 0 │ 'metadata' │ 'Bytes' │ 'NFTMetadata' │ └─────────┴────────────┴─────────┴───────────────┘

nftmartConf.updateCategory

docs
@ Update a common category. @ @ - `category_id`: category ID @ - `metadata`: metadata
args
┌─────────┬──────────────┬─────────┬───────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼──────────────┼─────────┼───────────────┤ │ 0 │ 'categoryId' │ 'u64' │ 'GlobalId' │ │ 1 │ 'metadata' │ 'Bytes' │ 'NFTMetadata' │ └─────────┴──────────────┴─────────┴───────────────┘

nftmartConf.updateAuctionCloseDelay

docs
args
┌─────────┬─────────┬───────┬──────────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼─────────┼───────┼──────────────────┤ │ 0 │ 'delay' │ 'u32' │ 'BlockNumberFor' │ └─────────┴─────────┴───────┴──────────────────┘

nftmartOrder:

nftmartOrder.submitOrder

docs
@ Create an order. @ @ - `currency_id`: currency id @ - `category_id`: category id @ - `deposit`: The balances to create an order @ - `price`: nfts' price. @ - `deadline`: deadline @ - `items`: a list of `(class_id, token_id, quantity, price)`
args
┌─────────┬──────────────────┬──────────────────────┬────────────────────────────────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼──────────────────┼──────────────────────┼────────────────────────────────────────┤ │ 0 │ 'currencyId' │ 'Compact<u32>' │ 'CurrencyIdOf' │ │ 1 │ 'deposit' │ 'Compact<u128>' │ 'Balance' │ │ 2 │ 'price' │ 'Compact<u128>' │ 'Balance' │ │ 3 │ 'deadline' │ 'Compact<u32>' │ 'BlockNumberOf' │ │ 4 │ 'items' │ 'Vec<(u32,u64,u64)>' │ 'Vec<(ClassIdOf,TokenIdOf,TokenIdOf)>' │ │ 5 │ 'commissionRate' │ 'Compact<PerU16>' │ 'PerU16' │ └─────────┴──────────────────┴──────────────────────┴────────────────────────────────────────┘

nftmartOrder.takeOrder

docs
@ Take a NFT order. @ @ - `order_id`: order id @ - `order_owner`: token owner
args
┌─────────┬───────────────────┬───────────────────────┬─────────────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼───────────────────┼───────────────────────┼─────────────────────┤ │ 0 │ 'orderId' │ 'Compact<u64>' │ 'GlobalId' │ │ 1 │ 'orderOwner' │ 'MultiAddress' │ 'LookupSource' │ │ 2 │ 'commissionAgent' │ 'Option<AccountId32>' │ 'Option<AccountId>' │ │ 3 │ 'commissionData' │ 'Option<Bytes>' │ 'Option<Bytes>' │ └─────────┴───────────────────┴───────────────────────┴─────────────────────┘

nftmartOrder.removeOrder

docs
@ remove an order by order owner. @ @ - `order_id`: order id
args
┌─────────┬───────────┬────────────────┬────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼───────────┼────────────────┼────────────┤ │ 0 │ 'orderId' │ 'Compact<u64>' │ 'GlobalId' │ └─────────┴───────────┴────────────────┴────────────┘

nftmartOrder.removeOffer

docs
@ remove an offer by offer owner. @ @ - `offer_id`: offer id
args
┌─────────┬───────────┬────────────────┬────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼───────────┼────────────────┼────────────┤ │ 0 │ 'offerId' │ 'Compact<u64>' │ 'GlobalId' │ └─────────┴───────────┴────────────────┴────────────┘

nftmartOrder.submitOffer

docs
args
┌─────────┬──────────────────┬──────────────────────┬────────────────────────────────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼──────────────────┼──────────────────────┼────────────────────────────────────────┤ │ 0 │ 'currencyId' │ 'Compact<u32>' │ 'CurrencyIdOf' │ │ 1 │ 'price' │ 'Compact<u128>' │ 'Balance' │ │ 2 │ 'deadline' │ 'Compact<u32>' │ 'BlockNumberOf' │ │ 3 │ 'items' │ 'Vec<(u32,u64,u64)>' │ 'Vec<(ClassIdOf,TokenIdOf,TokenIdOf)>' │ │ 4 │ 'commissionRate' │ 'Compact<PerU16>' │ 'PerU16' │ └─────────┴──────────────────┴──────────────────────┴────────────────────────────────────────┘

nftmartOrder.takeOffer

docs
@ Take a NFT offer. @ @ - `offer_id`: offer id @ - `offer_owner`: token owner
args
┌─────────┬───────────────────┬───────────────────────┬─────────────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼───────────────────┼───────────────────────┼─────────────────────┤ │ 0 │ 'offerId' │ 'Compact<u64>' │ 'GlobalId' │ │ 1 │ 'offerOwner' │ 'MultiAddress' │ 'LookupSource' │ │ 2 │ 'commissionAgent' │ 'Option<AccountId32>' │ 'Option<AccountId>' │ │ 3 │ 'commissionData' │ 'Option<Bytes>' │ 'Option<Bytes>' │ └─────────┴───────────────────┴───────────────────────┴─────────────────────┘

nopEmitT:

nopEmitT.emit

docs
args
┌─────────┐ │ (index) │ ├─────────┤ └─────────┘

proxy:

proxy.proxy

docs
@ 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. @ @ # <weight> @ Weight is a function of the number of proxies the user has (P). @ # </weight>
args
┌─────────┬──────────────────┬────────────────────────────────┬─────────────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼──────────────────┼────────────────────────────────┼─────────────────────┤ │ 0 │ 'real' │ 'AccountId32' │ 'AccountId' │ │ 1 │ 'forceProxyType' │ 'Option<NodeRuntimeProxyType>' │ 'Option<ProxyType>' │ │ 2 │ 'call' │ 'Call' │ 'Call' │ └─────────┴──────────────────┴────────────────────────────────┴─────────────────────┘

proxy.addProxy

docs
@ 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. @ @ # <weight> @ Weight is a function of the number of proxies the user has (P). @ # </weight>
args
┌─────────┬─────────────┬────────────────────────┬───────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼─────────────┼────────────────────────┼───────────────┤ │ 0 │ 'delegate' │ 'AccountId32' │ 'AccountId' │ │ 1 │ 'proxyType' │ 'NodeRuntimeProxyType' │ 'ProxyType' │ │ 2 │ 'delay' │ 'u32' │ 'BlockNumber' │ └─────────┴─────────────┴────────────────────────┴───────────────┘

proxy.removeProxy

docs
@ 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. @ @ # <weight> @ Weight is a function of the number of proxies the user has (P). @ # </weight>
args
┌─────────┬─────────────┬────────────────────────┬───────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼─────────────┼────────────────────────┼───────────────┤ │ 0 │ 'delegate' │ 'AccountId32' │ 'AccountId' │ │ 1 │ 'proxyType' │ 'NodeRuntimeProxyType' │ 'ProxyType' │ │ 2 │ 'delay' │ 'u32' │ 'BlockNumber' │ └─────────┴─────────────┴────────────────────────┴───────────────┘

proxy.removeProxies

docs
@ 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.** @ @ # <weight> @ Weight is a function of the number of proxies the user has (P). @ # </weight>
args
┌─────────┐ │ (index) │ ├─────────┤ └─────────┘

proxy.anonymous

docs
@ 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. @ @ # <weight> @ Weight is a function of the number of proxies the user has (P). @ # </weight> @ TODO: Might be over counting 1 read
args
┌─────────┬─────────────┬────────────────────────┬───────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼─────────────┼────────────────────────┼───────────────┤ │ 0 │ 'proxyType' │ 'NodeRuntimeProxyType' │ 'ProxyType' │ │ 1 │ 'delay' │ 'u32' │ 'BlockNumber' │ │ 2 │ 'index' │ 'u16' │ 'u16' │ └─────────┴─────────────┴────────────────────────┴───────────────┘

proxy.killAnonymous

docs
@ 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. @ @ # <weight> @ Weight is a function of the number of proxies the user has (P). @ # </weight>
args
┌─────────┬─────────────┬────────────────────────┬───────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼─────────────┼────────────────────────┼───────────────┤ │ 0 │ 'spawner' │ 'AccountId32' │ 'AccountId' │ │ 1 │ 'proxyType' │ 'NodeRuntimeProxyType' │ 'ProxyType' │ │ 2 │ 'index' │ 'u16' │ 'u16' │ │ 3 │ 'height' │ 'Compact<u32>' │ 'BlockNumber' │ │ 4 │ 'extIndex' │ 'Compact<u32>' │ 'u32' │ └─────────┴─────────────┴────────────────────────┴───────────────┘

proxy.announce

docs
@ 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. @ @ # <weight> @ Weight is a function of: @ - A: the number of announcements made. @ - P: the number of proxies the user has. @ # </weight>
args
┌─────────┬────────────┬───────────────┬──────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼────────────┼───────────────┼──────────────┤ │ 0 │ 'real' │ 'AccountId32' │ 'AccountId' │ │ 1 │ 'callHash' │ 'H256' │ 'CallHashOf' │ └─────────┴────────────┴───────────────┴──────────────┘

proxy.removeAnnouncement

docs
@ 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. @ @ # <weight> @ Weight is a function of: @ - A: the number of announcements made. @ - P: the number of proxies the user has. @ # </weight>
args
┌─────────┬────────────┬───────────────┬──────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼────────────┼───────────────┼──────────────┤ │ 0 │ 'real' │ 'AccountId32' │ 'AccountId' │ │ 1 │ 'callHash' │ 'H256' │ 'CallHashOf' │ └─────────┴────────────┴───────────────┴──────────────┘

proxy.rejectAnnouncement

docs
@ 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. @ @ # <weight> @ Weight is a function of: @ - A: the number of announcements made. @ - P: the number of proxies the user has. @ # </weight>
args
┌─────────┬────────────┬───────────────┬──────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼────────────┼───────────────┼──────────────┤ │ 0 │ 'delegate' │ 'AccountId32' │ 'AccountId' │ │ 1 │ 'callHash' │ 'H256' │ 'CallHashOf' │ └─────────┴────────────┴───────────────┴──────────────┘

proxy.proxyAnnounced

docs
@ 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. @ @ # <weight> @ Weight is a function of: @ - A: the number of announcements made. @ - P: the number of proxies the user has. @ # </weight>
args
┌─────────┬──────────────────┬────────────────────────────────┬─────────────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼──────────────────┼────────────────────────────────┼─────────────────────┤ │ 0 │ 'delegate' │ 'AccountId32' │ 'AccountId' │ │ 1 │ 'real' │ 'AccountId32' │ 'AccountId' │ │ 2 │ 'forceProxyType' │ 'Option<NodeRuntimeProxyType>' │ 'Option<ProxyType>' │ │ 3 │ 'call' │ 'Call' │ 'Call' │ └─────────┴──────────────────┴────────────────────────────────┴─────────────────────┘

recovery:

recovery.asRecovered

docs
@ Send a call through a recovered account. @ @ The dispatch origin for this call must be _Signed_ and registered to @ be able to make calls on behalf of the recovered account. @ @ Parameters: @ - `account`: The recovered account you want to make a call on-behalf-of. @ - `call`: The call you want to make with the recovered account. @ @ # <weight> @ - The weight of the `call` + 10,000. @ - One storage lookup to check account is recovered by `who`. O(1) @ # </weight>
args
┌─────────┬───────────┬───────────────┬─────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼───────────┼───────────────┼─────────────┤ │ 0 │ 'account' │ 'AccountId32' │ 'AccountId' │ │ 1 │ 'call' │ 'Call' │ 'Call' │ └─────────┴───────────┴───────────────┴─────────────┘

recovery.setRecovered

docs
@ Allow ROOT to bypass the recovery process and set an a rescuer account @ for a lost account directly. @ @ The dispatch origin for this call must be _ROOT_. @ @ Parameters: @ - `lost`: The "lost account" to be recovered. @ - `rescuer`: The "rescuer account" which can call as the lost account. @ @ # <weight> @ - One storage write O(1) @ - One event @ # </weight>
args
┌─────────┬───────────┬───────────────┬─────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼───────────┼───────────────┼─────────────┤ │ 0 │ 'lost' │ 'AccountId32' │ 'AccountId' │ │ 1 │ 'rescuer' │ 'AccountId32' │ 'AccountId' │ └─────────┴───────────┴───────────────┴─────────────┘

recovery.createRecovery

docs
@ Create a recovery configuration for your account. This makes your account recoverable. @ @ Payment: `ConfigDepositBase` + `FriendDepositFactor` * #_of_friends balance @ will be reserved for storing the recovery configuration. This deposit is returned @ in full when the user calls `remove_recovery`. @ @ The dispatch origin for this call must be _Signed_. @ @ Parameters: @ - `friends`: A list of friends you trust to vouch for recovery attempts. Should be @ ordered and contain no duplicate values. @ - `threshold`: The number of friends that must vouch for a recovery attempt before the @ account can be recovered. Should be less than or equal to the length of the list of @ friends. @ - `delay_period`: The number of blocks after a recovery attempt is initialized that @ needs to pass before the account can be recovered. @ @ # <weight> @ - Key: F (len of friends) @ - One storage read to check that account is not already recoverable. O(1). @ - A check that the friends list is sorted and unique. O(F) @ - One currency reserve operation. O(X) @ - One storage write. O(1). Codec O(F). @ - One event. @ @ Total Complexity: O(F + X) @ # </weight>
args
┌─────────┬───────────────┬────────────────────┬──────────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼───────────────┼────────────────────┼──────────────────┤ │ 0 │ 'friends' │ 'Vec<AccountId32>' │ 'Vec<AccountId>' │ │ 1 │ 'threshold' │ 'u16' │ 'u16' │ │ 2 │ 'delayPeriod' │ 'u32' │ 'BlockNumber' │ └─────────┴───────────────┴────────────────────┴──────────────────┘

recovery.initiateRecovery

docs
@ Initiate the process for recovering a recoverable account. @ @ Payment: `RecoveryDeposit` balance will be reserved for initiating the @ recovery process. This deposit will always be repatriated to the account @ trying to be recovered. See `close_recovery`. @ @ The dispatch origin for this call must be _Signed_. @ @ Parameters: @ - `account`: The lost account that you want to recover. This account needs to be @ recoverable (i.e. have a recovery configuration). @ @ # <weight> @ - One storage read to check that account is recoverable. O(F) @ - One storage read to check that this recovery process hasn't already started. O(1) @ - One currency reserve operation. O(X) @ - One storage read to get the current block number. O(1) @ - One storage write. O(1). @ - One event. @ @ Total Complexity: O(F + X) @ # </weight>
args
┌─────────┬───────────┬───────────────┬─────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼───────────┼───────────────┼─────────────┤ │ 0 │ 'account' │ 'AccountId32' │ 'AccountId' │ └─────────┴───────────┴───────────────┴─────────────┘

recovery.vouchRecovery

docs
@ Allow a "friend" of a recoverable account to vouch for an active recovery @ process for that account. @ @ The dispatch origin for this call must be _Signed_ and must be a "friend" @ for the recoverable account. @ @ Parameters: @ - `lost`: The lost account that you want to recover. @ - `rescuer`: The account trying to rescue the lost account that you want to vouch for. @ @ The combination of these two parameters must point to an active recovery @ process. @ @ # <weight> @ Key: F (len of friends in config), V (len of vouching friends) @ - One storage read to get the recovery configuration. O(1), Codec O(F) @ - One storage read to get the active recovery process. O(1), Codec O(V) @ - One binary search to confirm caller is a friend. O(logF) @ - One binary search to confirm caller has not already vouched. O(logV) @ - One storage write. O(1), Codec O(V). @ - One event. @ @ Total Complexity: O(F + logF + V + logV) @ # </weight>
args
┌─────────┬───────────┬───────────────┬─────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼───────────┼───────────────┼─────────────┤ │ 0 │ 'lost' │ 'AccountId32' │ 'AccountId' │ │ 1 │ 'rescuer' │ 'AccountId32' │ 'AccountId' │ └─────────┴───────────┴───────────────┴─────────────┘

recovery.claimRecovery

docs
@ Allow a successful rescuer to claim their recovered account. @ @ The dispatch origin for this call must be _Signed_ and must be a "rescuer" @ who has successfully completed the account recovery process: collected @ `threshold` or more vouches, waited `delay_period` blocks since initiation. @ @ Parameters: @ - `account`: The lost account that you want to claim has been successfully recovered by @ you. @ @ # <weight> @ Key: F (len of friends in config), V (len of vouching friends) @ - One storage read to get the recovery configuration. O(1), Codec O(F) @ - One storage read to get the active recovery process. O(1), Codec O(V) @ - One storage read to get the current block number. O(1) @ - One storage write. O(1), Codec O(V). @ - One event. @ @ Total Complexity: O(F + V) @ # </weight>
args
┌─────────┬───────────┬───────────────┬─────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼───────────┼───────────────┼─────────────┤ │ 0 │ 'account' │ 'AccountId32' │ 'AccountId' │ └─────────┴───────────┴───────────────┴─────────────┘

recovery.closeRecovery

docs
@ As the controller of a recoverable account, close an active recovery @ process for your account. @ @ Payment: By calling this function, the recoverable account will receive @ the recovery deposit `RecoveryDeposit` placed by the rescuer. @ @ The dispatch origin for this call must be _Signed_ and must be a @ recoverable account with an active recovery process for it. @ @ Parameters: @ - `rescuer`: The account trying to rescue this recoverable account. @ @ # <weight> @ Key: V (len of vouching friends) @ - One storage read/remove to get the active recovery process. O(1), Codec O(V) @ - One balance call to repatriate reserved. O(X) @ - One event. @ @ Total Complexity: O(V + X) @ # </weight>
args
┌─────────┬───────────┬───────────────┬─────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼───────────┼───────────────┼─────────────┤ │ 0 │ 'rescuer' │ 'AccountId32' │ 'AccountId' │ └─────────┴───────────┴───────────────┴─────────────┘

recovery.removeRecovery

docs
@ Remove the recovery process for your account. Recovered accounts are still accessible. @ @ NOTE: The user must make sure to call `close_recovery` on all active @ recovery attempts before calling this function else it will fail. @ @ Payment: By calling this function the recoverable account will unreserve @ their recovery configuration deposit. @ (`ConfigDepositBase` + `FriendDepositFactor` * #_of_friends) @ @ The dispatch origin for this call must be _Signed_ and must be a @ recoverable account (i.e. has a recovery configuration). @ @ # <weight> @ Key: F (len of friends) @ - One storage read to get the prefix iterator for active recoveries. O(1) @ - One storage read/remove to get the recovery configuration. O(1), Codec O(F) @ - One balance call to unreserved. O(X) @ - One event. @ @ Total Complexity: O(F + X) @ # </weight>
args
┌─────────┐ │ (index) │ ├─────────┤ └─────────┘

recovery.cancelRecovered

docs
@ Cancel the ability to use `as_recovered` for `account`. @ @ The dispatch origin for this call must be _Signed_ and registered to @ be able to make calls on behalf of the recovered account. @ @ Parameters: @ - `account`: The recovered account you are able to call on-behalf-of. @ @ # <weight> @ - One storage mutation to check account is recovered by `who`. O(1) @ # </weight>
args
┌─────────┬───────────┬───────────────┬─────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼───────────┼───────────────┼─────────────┤ │ 0 │ 'account' │ 'AccountId32' │ 'AccountId' │ └─────────┴───────────┴───────────────┴─────────────┘

scheduler:

scheduler.schedule

docs
@ Anonymously schedule a task.
args
┌─────────┬─────────────────┬─────────────────────┬──────────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼─────────────────┼─────────────────────┼──────────────────┤ │ 0 │ 'when' │ 'u32' │ 'BlockNumber' │ │ 1 │ 'maybePeriodic' │ 'Option<(u32,u32)>' │ 'Option<Period>' │ │ 2 │ 'priority' │ 'u8' │ 'Priority' │ │ 3 │ 'call' │ 'Call' │ 'Call' │ └─────────┴─────────────────┴─────────────────────┴──────────────────┘

scheduler.cancel

docs
@ Cancel an anonymously scheduled task.
args
┌─────────┬─────────┬───────┬───────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼─────────┼───────┼───────────────┤ │ 0 │ 'when' │ 'u32' │ 'BlockNumber' │ │ 1 │ 'index' │ 'u32' │ 'u32' │ └─────────┴─────────┴───────┴───────────────┘

scheduler.scheduleNamed

docs
@ Schedule a named task.
args
┌─────────┬─────────────────┬─────────────────────┬──────────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼─────────────────┼─────────────────────┼──────────────────┤ │ 0 │ 'id' │ 'Bytes' │ 'Bytes' │ │ 1 │ 'when' │ 'u32' │ 'BlockNumber' │ │ 2 │ 'maybePeriodic' │ 'Option<(u32,u32)>' │ 'Option<Period>' │ │ 3 │ 'priority' │ 'u8' │ 'Priority' │ │ 4 │ 'call' │ 'Call' │ 'Call' │ └─────────┴─────────────────┴─────────────────────┴──────────────────┘

scheduler.cancelNamed

docs
@ Cancel a named scheduled task.
args
┌─────────┬──────┬─────────┬──────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼──────┼─────────┼──────────┤ │ 0 │ 'id' │ 'Bytes' │ 'Bytes' │ └─────────┴──────┴─────────┴──────────┘

scheduler.scheduleAfter

docs
@ Anonymously schedule a task after a delay. @ @ # <weight> @ Same as [`schedule`]. @ # </weight>
args
┌─────────┬─────────────────┬─────────────────────┬──────────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼─────────────────┼─────────────────────┼──────────────────┤ │ 0 │ 'after' │ 'u32' │ 'BlockNumber' │ │ 1 │ 'maybePeriodic' │ 'Option<(u32,u32)>' │ 'Option<Period>' │ │ 2 │ 'priority' │ 'u8' │ 'Priority' │ │ 3 │ 'call' │ 'Call' │ 'Call' │ └─────────┴─────────────────┴─────────────────────┴──────────────────┘

scheduler.scheduleNamedAfter

docs
@ Schedule a named task after a delay. @ @ # <weight> @ Same as [`schedule_named`](Self::schedule_named). @ # </weight>
args
┌─────────┬─────────────────┬─────────────────────┬──────────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼─────────────────┼─────────────────────┼──────────────────┤ │ 0 │ 'id' │ 'Bytes' │ 'Bytes' │ │ 1 │ 'after' │ 'u32' │ 'BlockNumber' │ │ 2 │ 'maybePeriodic' │ 'Option<(u32,u32)>' │ 'Option<Period>' │ │ 3 │ 'priority' │ 'u8' │ 'Priority' │ │ 4 │ 'call' │ 'Call' │ 'Call' │ └─────────┴─────────────────┴─────────────────────┴──────────────────┘

session:

session.setKeys

docs
@ 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. @ @ # <weight> @ - Complexity: `O(1)`. Actual cost depends on the number of length of @ `T::Keys::key_ids()` which is fixed. @ - DbReads: `origin account`, `T::ValidatorIdOf`, `NextKeys` @ - DbWrites: `origin account`, `NextKeys` @ - DbReads per key id: `KeyOwner` @ - DbWrites per key id: `KeyOwner` @ # </weight>
args
┌─────────┬─────────┬──────────────────────────┬──────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼─────────┼──────────────────────────┼──────────┤ │ 0 │ 'keys' │ 'NodeRuntimeSessionKeys' │ 'Keys' │ │ 1 │ 'proof' │ 'Bytes' │ 'Bytes' │ └─────────┴─────────┴──────────────────────────┴──────────┘

session.purgeKeys

docs
@ 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). @ @ # <weight> @ - Complexity: `O(1)` in number of key types. Actual cost depends on the number of length @ of `T::Keys::key_ids()` which is fixed. @ - DbReads: `T::ValidatorIdOf`, `NextKeys`, `origin account` @ - DbWrites: `NextKeys`, `origin account` @ - DbWrites per key id: `KeyOwner` @ # </weight>
args
┌─────────┐ │ (index) │ ├─────────┤ └─────────┘

staking:

staking.bond

docs
@ 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`. @ # <weight> @ - Independent of the arguments. Moderate complexity. @ - O(1). @ - Three extra DB entries. @ @ NOTE: Two of the storage writes (`Self::bonded`, `Self::payee`) are _never_ cleaned @ unless the `origin` falls below _existential deposit_ and gets removed as dust. @ ------------------ @ # </weight>
args
┌─────────┬──────────────┬──────────────────────────────────┬─────────────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼──────────────┼──────────────────────────────────┼─────────────────────┤ │ 0 │ 'controller' │ 'MultiAddress' │ 'LookupSource' │ │ 1 │ 'value' │ 'Compact<u128>' │ 'BalanceOf' │ │ 2 │ 'payee' │ 'PalletStakingRewardDestination' │ 'RewardDestination' │ └─────────┴──────────────┴──────────────────────────────────┴─────────────────────┘

staking.bondExtra

docs
@ Add some extra amount that have appeared in the stash `free_balance` into the balance up @ for staking. @ @ The dispatch origin for this call must be _Signed_ by the stash, not the controller. @ @ Use this if there are additional funds in your stash account that you wish to bond. @ Unlike [`bond`](Self::bond) or [`unbond`](Self::unbond) this function does not impose @ any limitation on the amount that can be added. @ @ Emits `Bonded`. @ @ # <weight> @ - Independent of the arguments. Insignificant complexity. @ - O(1). @ # </weight>
args
┌─────────┬─────────────────┬─────────────────┬─────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼─────────────────┼─────────────────┼─────────────┤ │ 0 │ 'maxAdditional' │ 'Compact<u128>' │ 'BalanceOf' │ └─────────┴─────────────────┴─────────────────┴─────────────┘

staking.unbond

docs
@ 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. @ @ The dispatch origin for this call must be _Signed_ by the controller, not the stash. @ @ 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). @ @ If a user encounters the `InsufficientBond` error when calling this extrinsic, @ they should call `chill` first in order to free up their bonded funds. @ @ Emits `Unbonded`. @ @ See also [`Call::withdraw_unbonded`].
args
┌─────────┬─────────┬─────────────────┬─────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼─────────┼─────────────────┼─────────────┤ │ 0 │ 'value' │ 'Compact<u128>' │ 'BalanceOf' │ └─────────┴─────────┴─────────────────┴─────────────┘

staking.withdrawUnbonded

docs
@ 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. @ @ Emits `Withdrawn`. @ @ See also [`Call::unbond`]. @ @ # <weight> @ Complexity O(S) where S is the number of slashing spans to remove @ NOTE: Weight annotation is the kill scenario, we refund otherwise. @ # </weight>
args
┌─────────┬────────────────────┬───────┬──────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼────────────────────┼───────┼──────────┤ │ 0 │ 'numSlashingSpans' │ 'u32' │ 'u32' │ └─────────┴────────────────────┴───────┴──────────┘

staking.validate

docs
@ 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.
args
┌─────────┬─────────┬───────────────────────────────┬──────────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼─────────┼───────────────────────────────┼──────────────────┤ │ 0 │ 'prefs' │ 'PalletStakingValidatorPrefs' │ 'ValidatorPrefs' │ └─────────┴─────────┴───────────────────────────────┴──────────────────┘

staking.nominate

docs
@ Declare the desire to nominate `targets` 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. @ @ # <weight> @ - The transaction's complexity is proportional to the size of `targets` (N) @ which is capped at CompactAssignments::LIMIT (MAX_NOMINATIONS). @ - Both the reads and writes follow a similar pattern. @ # </weight>
args
┌─────────┬───────────┬─────────────────────┬─────────────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼───────────┼─────────────────────┼─────────────────────┤ │ 0 │ 'targets' │ 'Vec<MultiAddress>' │ 'Vec<LookupSource>' │ └─────────┴───────────┴─────────────────────┴─────────────────────┘

staking.chill

docs
@ 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. @ @ # <weight> @ - Independent of the arguments. Insignificant complexity. @ - Contains one read. @ - Writes are limited to the `origin` account key. @ # </weight>
args
┌─────────┐ │ (index) │ ├─────────┤ └─────────┘

staking.setPayee

docs
@ (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. @ @ # <weight> @ - Independent of the arguments. Insignificant complexity. @ - Contains a limited number of reads. @ - Writes are limited to the `origin` account key. @ --------- @ - Weight: O(1) @ - DB Weight: @ - Read: Ledger @ - Write: Payee @ # </weight>
args
┌─────────┬─────────┬──────────────────────────────────┬─────────────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼─────────┼──────────────────────────────────┼─────────────────────┤ │ 0 │ 'payee' │ 'PalletStakingRewardDestination' │ 'RewardDestination' │ └─────────┴─────────┴──────────────────────────────────┴─────────────────────┘

staking.setController

docs
@ (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. @ @ # <weight> @ - Independent of the arguments. Insignificant complexity. @ - Contains a limited number of reads. @ - Writes are limited to the `origin` account key. @ ---------- @ Weight: O(1) @ DB Weight: @ - Read: Bonded, Ledger New Controller, Ledger Old Controller @ - Write: Bonded, Ledger New Controller, Ledger Old Controller @ # </weight>
args
┌─────────┬──────────────┬────────────────┬────────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼──────────────┼────────────────┼────────────────┤ │ 0 │ 'controller' │ 'MultiAddress' │ 'LookupSource' │ └─────────┴──────────────┴────────────────┴────────────────┘

staking.setValidatorCount

docs
@ Sets the ideal number of validators. @ @ The dispatch origin must be Root. @ @ # <weight> @ Weight: O(1) @ Write: Validator Count @ # </weight>
args
┌─────────┬───────┬────────────────┬──────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼───────┼────────────────┼──────────┤ │ 0 │ 'new' │ 'Compact<u32>' │ 'u32' │ └─────────┴───────┴────────────────┴──────────┘

staking.increaseValidatorCount

docs
@ Increments the ideal number of validators. @ @ The dispatch origin must be Root. @ @ # <weight> @ Same as [`Self::set_validator_count`]. @ # </weight>
args
┌─────────┬──────────────┬────────────────┬──────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼──────────────┼────────────────┼──────────┤ │ 0 │ 'additional' │ 'Compact<u32>' │ 'u32' │ └─────────┴──────────────┴────────────────┴──────────┘

staking.scaleValidatorCount

docs
@ Scale up the ideal number of validators by a factor. @ @ The dispatch origin must be Root. @ @ # <weight> @ Same as [`Self::set_validator_count`]. @ # </weight>
args
┌─────────┬──────────┬───────────┬───────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼──────────┼───────────┼───────────┤ │ 0 │ 'factor' │ 'Percent' │ 'Percent' │ └─────────┴──────────┴───────────┴───────────┘

staking.forceNoEras

docs
@ Force there to be no new eras indefinitely. @ @ The dispatch origin must be Root. @ @ # Warning @ @ The election process starts multiple blocks before the end of the era. @ Thus the election process may be ongoing when this is called. In this case the @ election will continue until the next era is triggered. @ @ # <weight> @ - No arguments. @ - Weight: O(1) @ - Write: ForceEra @ # </weight>
args
┌─────────┐ │ (index) │ ├─────────┤ └─────────┘

staking.forceNewEra

docs
@ 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. @ @ # Warning @ @ The election process starts multiple blocks before the end of the era. @ If this is called just before a new era is triggered, the election process may not @ have enough blocks to get a result. @ @ # <weight> @ - No arguments. @ - Weight: O(1) @ - Write ForceEra @ # </weight>
args
┌─────────┐ │ (index) │ ├─────────┤ └─────────┘

staking.setInvulnerables

docs
@ Set the validators who cannot be slashed (if any). @ @ The dispatch origin must be Root. @ @ # <weight> @ - O(V) @ - Write: Invulnerables @ # </weight>
args
┌─────────┬─────────────────┬────────────────────┬──────────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼─────────────────┼────────────────────┼──────────────────┤ │ 0 │ 'invulnerables' │ 'Vec<AccountId32>' │ 'Vec<AccountId>' │ └─────────┴─────────────────┴────────────────────┴──────────────────┘

staking.forceUnstake

docs
@ Force a current staker to become completely unstaked, immediately. @ @ The dispatch origin must be Root. @ @ # <weight> @ O(S) where S is the number of slashing spans to be removed @ Reads: Bonded, Slashing Spans, Account, Locks @ Writes: Bonded, Slashing Spans (if S > 0), Ledger, Payee, Validators, Nominators, @ Account, Locks Writes Each: SpanSlash * S @ # </weight>
args
┌─────────┬────────────────────┬───────────────┬─────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼────────────────────┼───────────────┼─────────────┤ │ 0 │ 'stash' │ 'AccountId32' │ 'AccountId' │ │ 1 │ 'numSlashingSpans' │ 'u32' │ 'u32' │ └─────────┴────────────────────┴───────────────┴─────────────┘

staking.forceNewEraAlways

docs
@ Force there to be a new era at the end of sessions indefinitely. @ @ The dispatch origin must be Root. @ @ # Warning @ @ The election process starts multiple blocks before the end of the era. @ If this is called just before a new era is triggered, the election process may not @ have enough blocks to get a result. @ @ # <weight> @ - Weight: O(1) @ - Write: ForceEra @ # </weight>
args
┌─────────┐ │ (index) │ ├─────────┤ └─────────┘

staking.cancelDeferredSlash

docs
@ 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. @ @ # <weight> @ Complexity: O(U + S) @ with U unapplied slashes weighted with U=1000 @ and S is the number of slash indices to be canceled. @ - Read: Unapplied Slashes @ - Write: Unapplied Slashes @ # </weight>
args
┌─────────┬────────────────┬────────────┬────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼────────────────┼────────────┼────────────┤ │ 0 │ 'era' │ 'u32' │ 'EraIndex' │ │ 1 │ 'slashIndices' │ 'Vec<u32>' │ 'Vec<u32>' │ └─────────┴────────────────┴────────────┴────────────┘

staking.payoutStakers

docs
@ 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. @ @ # <weight> @ - Time complexity: at most O(MaxNominatorRewardedPerValidator). @ - Contains a limited number of reads and writes. @ ----------- @ N is the Number of payouts for the validator (including the validator) @ Weight: @ - Reward Destination Staked: O(N) @ - Reward Destination Controller (Creating): O(N) @ @ NOTE: weights are assuming that payouts are made to alive stash account (Staked). @ Paying even a dead controller is cheaper weight-wise. We don't do any refunds here. @ # </weight>
args
┌─────────┬──────────────────┬───────────────┬─────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼──────────────────┼───────────────┼─────────────┤ │ 0 │ 'validatorStash' │ 'AccountId32' │ 'AccountId' │ │ 1 │ 'era' │ 'u32' │ 'EraIndex' │ └─────────┴──────────────────┴───────────────┴─────────────┘

staking.rebond

docs
@ Rebond a portion of the stash scheduled to be unlocked. @ @ The dispatch origin must be signed by the controller. @ @ # <weight> @ - Time complexity: O(L), where L is unlocking chunks @ - Bounded by `MAX_UNLOCKING_CHUNKS`. @ - Storage changes: Can't increase storage, only decrease it. @ # </weight>
args
┌─────────┬─────────┬─────────────────┬─────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼─────────┼─────────────────┼─────────────┤ │ 0 │ 'value' │ 'Compact<u128>' │ 'BalanceOf' │ └─────────┴─────────┴─────────────────┴─────────────┘

staking.setHistoryDepth

docs
@ 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. @ @ # <weight> @ - E: Number of history depths removed, i.e. 10 -> 7 = 3 @ - Weight: O(E) @ - DB Weight: @ - Reads: Current Era, History Depth @ - Writes: History Depth @ - Clear Prefix Each: Era Stakers, EraStakersClipped, ErasValidatorPrefs @ - Writes Each: ErasValidatorReward, ErasRewardPoints, ErasTotalStake, @ ErasStartSessionIndex @ # </weight>
args
┌─────────┬───────────────────┬────────────────┬────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼───────────────────┼────────────────┼────────────┤ │ 0 │ 'newHistoryDepth' │ 'Compact<u32>' │ 'EraIndex' │ │ 1 │ 'eraItemsDeleted' │ 'Compact<u32>' │ 'u32' │ └─────────┴───────────────────┴────────────────┴────────────┘

staking.reapStash

docs
@ Remove all data structures concerning a staker/stash once it is at a state where it can @ be considered `dust` in the staking system. The requirements are: @ @ 1. the `total_balance` of the stash is below existential deposit. @ 2. or, the `ledger.total` of the stash is below existential deposit. @ @ The former can happen in cases like a slash; the latter when a fully unbonded account @ is still receiving staking rewards in `RewardDestination::Staked`. @ @ It can be called by anyone, as long as `stash` meets the above requirements. @ @ Refunds the transaction fees upon successful execution.
args
┌─────────┬────────────────────┬───────────────┬─────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼────────────────────┼───────────────┼─────────────┤ │ 0 │ 'stash' │ 'AccountId32' │ 'AccountId' │ │ 1 │ 'numSlashingSpans' │ 'u32' │ 'u32' │ └─────────┴────────────────────┴───────────────┴─────────────┘

staking.kick

docs
@ Remove the given nominations from the calling validator. @ @ 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. @ @ - `who`: A list of nominator stash accounts who are nominating this validator which @ should no longer be nominating this validator. @ @ Note: Making this call only makes sense if you first set the validator preferences to @ block any further nominations.
args
┌─────────┬───────┬─────────────────────┬─────────────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼───────┼─────────────────────┼─────────────────────┤ │ 0 │ 'who' │ 'Vec<MultiAddress>' │ 'Vec<LookupSource>' │ └─────────┴───────┴─────────────────────┴─────────────────────┘

staking.setStakingLimits

docs
@ Update the various staking limits this pallet. @ @ * `min_nominator_bond`: The minimum active bond needed to be a nominator. @ * `min_validator_bond`: The minimum active bond needed to be a validator. @ * `max_nominator_count`: The max number of users who can be a nominator at once. When @ set to `None`, no limit is enforced. @ * `max_validator_count`: The max number of users who can be a validator at once. When @ set to `None`, no limit is enforced. @ @ Origin must be Root to call this function. @ @ NOTE: Existing nominators and validators will not be affected by this update. @ to kick people under the new limits, `chill_other` should be called.
args
┌─────────┬─────────────────────┬───────────────────┬───────────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼─────────────────────┼───────────────────┼───────────────────┤ │ 0 │ 'minNominatorBond' │ 'u128' │ 'BalanceOf' │ │ 1 │ 'minValidatorBond' │ 'u128' │ 'BalanceOf' │ │ 2 │ 'maxNominatorCount' │ 'Option<u32>' │ 'Option<u32>' │ │ 3 │ 'maxValidatorCount' │ 'Option<u32>' │ 'Option<u32>' │ │ 4 │ 'threshold' │ 'Option<Percent>' │ 'Option<Percent>' │ └─────────┴─────────────────────┴───────────────────┴───────────────────┘

staking.chillOther

docs
@ Declare a `controller` to stop participating as either a validator or nominator. @ @ Effects will be felt at the beginning of the next era. @ @ The dispatch origin for this call must be _Signed_, but can be called by anyone. @ @ If the caller is the same as the controller being targeted, then no further checks are @ enforced, and this function behaves just like `chill`. @ @ If the caller is different than the controller being targeted, the following conditions @ must be met: @ * A `ChillThreshold` must be set and checked which defines how close to the max @ nominators or validators we must reach before users can start chilling one-another. @ * A `MaxNominatorCount` and `MaxValidatorCount` must be set which is used to determine @ how close we are to the threshold. @ * A `MinNominatorBond` and `MinValidatorBond` must be set and checked, which determines @ if this is a person that should be chilled because they have not met the threshold @ bond required. @ @ This can be helpful if bond requirements are updated, and we need to remove old users @ who do not satisfy these requirements.
args
┌─────────┬──────────────┬───────────────┬─────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼──────────────┼───────────────┼─────────────┤ │ 0 │ 'controller' │ 'AccountId32' │ 'AccountId' │ └─────────┴──────────────┴───────────────┴─────────────┘

sudo:

sudo.sudo

docs
@ Authenticates the sudo key and dispatches a function call with `Root` origin. @ @ The dispatch origin for this call must be _Signed_. @ @ # <weight> @ - O(1). @ - Limited storage reads. @ - One DB write (event). @ - Weight of derivative `call` execution + 10,000. @ # </weight>
args
┌─────────┬────────┬────────┬──────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼────────┼────────┼──────────┤ │ 0 │ 'call' │ 'Call' │ 'Call' │ └─────────┴────────┴────────┴──────────┘

sudo.sudoUncheckedWeight

docs
@ 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_. @ @ # <weight> @ - O(1). @ - The weight of this call is defined by the caller. @ # </weight>
args
┌─────────┬──────────┬────────┬──────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼──────────┼────────┼──────────┤ │ 0 │ 'call' │ 'Call' │ 'Call' │ │ 1 │ 'weight' │ 'u64' │ 'Weight' │ └─────────┴──────────┴────────┴──────────┘

sudo.setKey

docs
@ 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_. @ @ # <weight> @ - O(1). @ - Limited storage reads. @ - One DB change. @ # </weight>
args
┌─────────┬───────┬────────────────┬────────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼───────┼────────────────┼────────────────┤ │ 0 │ 'new' │ 'MultiAddress' │ 'LookupSource' │ └─────────┴───────┴────────────────┴────────────────┘

sudo.sudoAs

docs
@ 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_. @ @ # <weight> @ - O(1). @ - Limited storage reads. @ - One DB write (event). @ - Weight of derivative `call` execution + 10,000. @ # </weight>
args
┌─────────┬────────┬────────────────┬────────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼────────┼────────────────┼────────────────┤ │ 0 │ 'who' │ 'MultiAddress' │ 'LookupSource' │ │ 1 │ 'call' │ 'Call' │ 'Call' │ └─────────┴────────┴────────────────┴────────────────┘

system:

system.fillBlock

docs
@ A dispatch that will fill the block weight up to the given ratio.
args
┌─────────┬─────────┬───────────┬───────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼─────────┼───────────┼───────────┤ │ 0 │ 'ratio' │ 'Perbill' │ 'Perbill' │ └─────────┴─────────┴───────────┴───────────┘

system.remark

docs
@ Make some on-chain remark. @ @ # <weight> @ - `O(1)` @ # </weight>
args
┌─────────┬──────────┬─────────┬──────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼──────────┼─────────┼──────────┤ │ 0 │ 'remark' │ 'Bytes' │ 'Bytes' │ └─────────┴──────────┴─────────┴──────────┘

system.setHeapPages

docs
@ Set the number of pages in the WebAssembly environment's heap.
args
┌─────────┬─────────┬───────┬──────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼─────────┼───────┼──────────┤ │ 0 │ 'pages' │ 'u64' │ 'u64' │ └─────────┴─────────┴───────┴──────────┘

system.setCode

docs
@ Set the new runtime code. @ @ # <weight> @ - `O(C + S)` where `C` length of `code` and `S` complexity of `can_set_code` @ - 1 call to `can_set_code`: `O(S)` (calls `sp_io::misc::runtime_version` which is @ expensive). @ - 1 storage write (codec `O(C)`). @ - 1 digest item. @ - 1 event. @ The weight of this function is dependent on the runtime, but generally this is very @ expensive. We will treat this as a full block. @ # </weight>
args
┌─────────┬────────┬─────────┬──────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼────────┼─────────┼──────────┤ │ 0 │ 'code' │ 'Bytes' │ 'Bytes' │ └─────────┴────────┴─────────┴──────────┘

system.setCodeWithoutChecks

docs
@ Set the new runtime code without doing any checks of the given `code`. @ @ # <weight> @ - `O(C)` where `C` length of `code` @ - 1 storage write (codec `O(C)`). @ - 1 digest item. @ - 1 event. @ The weight of this function is dependent on the runtime. We will treat this as a full @ block. # </weight>
args
┌─────────┬────────┬─────────┬──────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼────────┼─────────┼──────────┤ │ 0 │ 'code' │ 'Bytes' │ 'Bytes' │ └─────────┴────────┴─────────┴──────────┘

system.setStorage

docs
@ Set some items of storage.
args
┌─────────┬─────────┬──────────────────────┬─────────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼─────────┼──────────────────────┼─────────────────┤ │ 0 │ 'items' │ 'Vec<(Bytes,Bytes)>' │ 'Vec<KeyValue>' │ └─────────┴─────────┴──────────────────────┴─────────────────┘

system.killStorage

docs
@ Kill some items from storage.
args
┌─────────┬────────┬──────────────┬────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼────────┼──────────────┼────────────┤ │ 0 │ 'keys' │ 'Vec<Bytes>' │ 'Vec<Key>' │ └─────────┴────────┴──────────────┴────────────┘

system.killPrefix

docs
@ 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.
args
┌─────────┬───────────┬─────────┬──────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼───────────┼─────────┼──────────┤ │ 0 │ 'prefix' │ 'Bytes' │ 'Key' │ │ 1 │ 'subkeys' │ 'u32' │ 'u32' │ └─────────┴───────────┴─────────┴──────────┘

system.remarkWithEvent

docs
@ Make some on-chain remark and emit event. @ @ # <weight> @ - `O(b)` where b is the length of the remark. @ - 1 event. @ # </weight>
args
┌─────────┬──────────┬─────────┬──────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼──────────┼─────────┼──────────┤ │ 0 │ 'remark' │ 'Bytes' │ 'Bytes' │ └─────────┴──────────┴─────────┴──────────┘

technicalCommittee:

technicalCommittee.setMembers

docs
@ 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. @ @ # <weight> @ ## Weight @ - `O(MP + N)` where: @ - `M` old-members-count (code- and governance-bounded) @ - `N` new-members-count (code- and governance-bounded) @ - `P` proposals-count (code-bounded) @ - DB: @ - 1 storage mutation (codec `O(M)` read, `O(N)` write) for reading and writing the @ members @ - 1 storage read (codec `O(P)`) for reading the proposals @ - `P` storage mutations (codec `O(M)`) for updating the votes for each proposal @ - 1 storage write (codec `O(1)`) for deleting the old `prime` and setting the new one @ # </weight>
args
┌─────────┬──────────────┬───────────────────────┬─────────────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼──────────────┼───────────────────────┼─────────────────────┤ │ 0 │ 'newMembers' │ 'Vec<AccountId32>' │ 'Vec<AccountId>' │ │ 1 │ 'prime' │ 'Option<AccountId32>' │ 'Option<AccountId>' │ │ 2 │ 'oldCount' │ 'u32' │ 'MemberCount' │ └─────────┴──────────────┴───────────────────────┴─────────────────────┘

technicalCommittee.execute

docs
@ Dispatch a proposal from a member using the `Member` origin. @ @ Origin must be a member of the collective. @ @ # <weight> @ ## Weight @ - `O(M + P)` where `M` members-count (code-bounded) and `P` complexity of dispatching @ `proposal` @ - DB: 1 read (codec `O(M)`) + DB access of `proposal` @ - 1 event @ # </weight>
args
┌─────────┬───────────────┬────────────────┬────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼───────────────┼────────────────┼────────────┤ │ 0 │ 'proposal' │ 'Call' │ 'Proposal' │ │ 1 │ 'lengthBound' │ 'Compact<u32>' │ 'u32' │ └─────────┴───────────────┴────────────────┴────────────┘

technicalCommittee.propose

docs
@ 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. @ @ # <weight> @ ## Weight @ - `O(B + M + P1)` or `O(B + M + P2)` where: @ - `B` is `proposal` size in bytes (length-fee-bounded) @ - `M` is members-count (code- and governance-bounded) @ - branching is influenced by `threshold` where: @ - `P1` is proposal execution complexity (`threshold < 2`) @ - `P2` is proposals-count (code-bounded) (`threshold >= 2`) @ - DB: @ - 1 storage read `is_member` (codec `O(M)`) @ - 1 storage read `ProposalOf::contains_key` (codec `O(1)`) @ - DB accesses influenced by `threshold`: @ - EITHER storage accesses done by `proposal` (`threshold < 2`) @ - OR proposal insertion (`threshold <= 2`) @ - 1 storage mutation `Proposals` (codec `O(P2)`) @ - 1 storage mutation `ProposalCount` (codec `O(1)`) @ - 1 storage write `ProposalOf` (codec `O(B)`) @ - 1 storage write `Voting` (codec `O(M)`) @ - 1 event @ # </weight>
args
┌─────────┬───────────────┬────────────────┬───────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼───────────────┼────────────────┼───────────────┤ │ 0 │ 'threshold' │ 'Compact<u32>' │ 'MemberCount' │ │ 1 │ 'proposal' │ 'Call' │ 'Proposal' │ │ 2 │ 'lengthBound' │ 'Compact<u32>' │ 'u32' │ └─────────┴───────────────┴────────────────┴───────────────┘

technicalCommittee.vote

docs
@ 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. @ # <weight> @ ## Weight @ - `O(M)` where `M` is members-count (code- and governance-bounded) @ - DB: @ - 1 storage read `Members` (codec `O(M)`) @ - 1 storage mutation `Voting` (codec `O(M)`) @ - 1 event @ # </weight>
args
┌─────────┬────────────┬────────────────┬─────────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼────────────┼────────────────┼─────────────────┤ │ 0 │ 'proposal' │ 'H256' │ 'Hash' │ │ 1 │ 'index' │ 'Compact<u32>' │ 'ProposalIndex' │ │ 2 │ 'approve' │ 'bool' │ 'bool' │ └─────────┴────────────┴────────────────┴─────────────────┘

technicalCommittee.close

docs
@ 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. @ @ # <weight> @ ## Weight @ - `O(B + M + P1 + P2)` where: @ - `B` is `proposal` size in bytes (length-fee-bounded) @ - `M` is members-count (code- and governance-bounded) @ - `P1` is the complexity of `proposal` preimage. @ - `P2` is proposal-count (code-bounded) @ - DB: @ - 2 storage reads (`Members`: codec `O(M)`, `Prime`: codec `O(1)`) @ - 3 mutations (`Voting`: codec `O(M)`, `ProposalOf`: codec `O(B)`, `Proposals`: codec @ `O(P2)`) @ - any mutations done while executing `proposal` (`P1`) @ - up to 3 events @ # </weight>
args
┌─────────┬───────────────────────┬────────────────┬─────────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼───────────────────────┼────────────────┼─────────────────┤ │ 0 │ 'proposalHash' │ 'H256' │ 'Hash' │ │ 1 │ 'index' │ 'Compact<u32>' │ 'ProposalIndex' │ │ 2 │ 'proposalWeightBound' │ 'Compact<u64>' │ 'Weight' │ │ 3 │ 'lengthBound' │ 'Compact<u32>' │ 'u32' │ └─────────┴───────────────────────┴────────────────┴─────────────────┘

technicalCommittee.disapproveProposal

docs
@ 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. @ @ # <weight> @ Complexity: O(P) where P is the number of max proposals @ DB Weight: @ * Reads: Proposals @ * Writes: Voting, Proposals, ProposalOf @ # </weight>
args
┌─────────┬────────────────┬────────┬──────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼────────────────┼────────┼──────────┤ │ 0 │ 'proposalHash' │ 'H256' │ 'Hash' │ └─────────┴────────────────┴────────┴──────────┘

template:

template.doSomething

docs
@ An example dispatchable that takes a singles value as a parameter, writes the value to @ storage and emits an event. This function must be dispatched by a signed extrinsic.
args
┌─────────┬─────────────┬───────┬──────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼─────────────┼───────┼──────────┤ │ 0 │ 'something' │ 'u32' │ 'u32' │ └─────────┴─────────────┴───────┴──────────┘

template.causeError

docs
@ An example dispatchable that may throw a custom error.
args
┌─────────┐ │ (index) │ ├─────────┤ └─────────┘

timestamp:

timestamp.set

docs
@ 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`. @ @ # <weight> @ - `O(1)` (Note that implementations of `OnTimestampSet` must also be `O(1)`) @ - 1 storage read and 1 storage mutation (codec `O(1)`). (because of `DidUpdate::take` in @ `on_finalize`) @ - 1 event handler `on_timestamp_set`. Must be `O(1)`. @ # </weight>
args
┌─────────┬───────┬────────────────┬──────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼───────┼────────────────┼──────────┤ │ 0 │ 'now' │ 'Compact<u64>' │ 'Moment' │ └─────────┴───────┴────────────────┴──────────┘

tips:

tips.reportAwesome

docs
@ 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. @ @ # <weight> @ - Complexity: `O(R)` where `R` length of `reason`. @ - encoding and hashing of 'reason' @ - DbReads: `Reasons`, `Tips` @ - DbWrites: `Reasons`, `Tips` @ # </weight>
args
┌─────────┬──────────┬───────────────┬─────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼──────────┼───────────────┼─────────────┤ │ 0 │ 'reason' │ 'Bytes' │ 'Bytes' │ │ 1 │ 'who' │ 'AccountId32' │ 'AccountId' │ └─────────┴──────────┴───────────────┴─────────────┘

tips.retractTip

docs
@ 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. @ @ # <weight> @ - Complexity: `O(1)` @ - Depends on the length of `T::Hash` which is fixed. @ - DbReads: `Tips`, `origin account` @ - DbWrites: `Reasons`, `Tips`, `origin account` @ # </weight>
args
┌─────────┬────────┬────────┬──────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼────────┼────────┼──────────┤ │ 0 │ 'hash' │ 'H256' │ 'Hash' │ └─────────┴────────┴────────┴──────────┘

tips.tipNew

docs
@ 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. @ @ # <weight> @ - Complexity: `O(R + T)` where `R` length of `reason`, `T` is the number of tippers. @ - `O(T)`: decoding `Tipper` vec of length `T`. `T` is charged as upper bound given by @ `ContainsLengthBound`. The actual cost depends on the implementation of @ `T::Tippers`. @ - `O(R)`: hashing and encoding of reason of length `R` @ - DbReads: `Tippers`, `Reasons` @ - DbWrites: `Reasons`, `Tips` @ # </weight>
args
┌─────────┬────────────┬─────────────────┬─────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼────────────┼─────────────────┼─────────────┤ │ 0 │ 'reason' │ 'Bytes' │ 'Bytes' │ │ 1 │ 'who' │ 'AccountId32' │ 'AccountId' │ │ 2 │ 'tipValue' │ 'Compact<u128>' │ 'BalanceOf' │ └─────────┴────────────┴─────────────────┴─────────────┘

tips.tip

docs
@ 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. @ @ # <weight> @ - Complexity: `O(T)` where `T` is the number of tippers. decoding `Tipper` vec of length @ `T`, insert tip and check closing, `T` is charged as upper bound given by @ `ContainsLengthBound`. The actual cost depends on the implementation of `T::Tippers`. @ @ Actually weight could be lower as it depends on how many tips are in `OpenTip` but it @ is weighted as if almost full i.e of length `T-1`. @ - DbReads: `Tippers`, `Tips` @ - DbWrites: `Tips` @ # </weight>
args
┌─────────┬────────────┬─────────────────┬─────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼────────────┼─────────────────┼─────────────┤ │ 0 │ 'hash' │ 'H256' │ 'Hash' │ │ 1 │ 'tipValue' │ 'Compact<u128>' │ 'BalanceOf' │ └─────────┴────────────┴─────────────────┴─────────────┘

tips.closeTip

docs
@ 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. @ @ # <weight> @ - Complexity: `O(T)` where `T` is the number of tippers. decoding `Tipper` vec of length @ `T`. `T` is charged as upper bound given by `ContainsLengthBound`. The actual cost @ depends on the implementation of `T::Tippers`. @ - DbReads: `Tips`, `Tippers`, `tip finder` @ - DbWrites: `Reasons`, `Tips`, `Tippers`, `tip finder` @ # </weight>
args
┌─────────┬────────┬────────┬──────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼────────┼────────┼──────────┤ │ 0 │ 'hash' │ 'H256' │ 'Hash' │ └─────────┴────────┴────────┴──────────┘

tips.slashTip

docs
@ 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. @ @ # <weight> @ `T` is charged as upper bound given by `ContainsLengthBound`. @ The actual cost depends on the implementation of `T::Tippers`. @ # </weight>
args
┌─────────┬────────┬────────┬──────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼────────┼────────┼──────────┤ │ 0 │ 'hash' │ 'H256' │ 'Hash' │ └─────────┴────────┴────────┴──────────┘

treasury:

treasury.proposeSpend

docs
@ 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. @ @ # <weight> @ - Complexity: O(1) @ - DbReads: `ProposalCount`, `origin account` @ - DbWrites: `ProposalCount`, `Proposals`, `origin account` @ # </weight>
args
┌─────────┬───────────────┬─────────────────┬────────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼───────────────┼─────────────────┼────────────────┤ │ 0 │ 'value' │ 'Compact<u128>' │ 'BalanceOf' │ │ 1 │ 'beneficiary' │ 'MultiAddress' │ 'LookupSource' │ └─────────┴───────────────┴─────────────────┴────────────────┘

treasury.rejectProposal

docs
@ Reject a proposed spend. The original deposit will be slashed. @ @ May only be called from `T::RejectOrigin`. @ @ # <weight> @ - Complexity: O(1) @ - DbReads: `Proposals`, `rejected proposer account` @ - DbWrites: `Proposals`, `rejected proposer account` @ # </weight>
args
┌─────────┬──────────────┬────────────────┬─────────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼──────────────┼────────────────┼─────────────────┤ │ 0 │ 'proposalId' │ 'Compact<u32>' │ 'ProposalIndex' │ └─────────┴──────────────┴────────────────┴─────────────────┘

treasury.approveProposal

docs
@ 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`. @ @ # <weight> @ - Complexity: O(1). @ - DbReads: `Proposals`, `Approvals` @ - DbWrite: `Approvals` @ # </weight>
args
┌─────────┬──────────────┬────────────────┬─────────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼──────────────┼────────────────┼─────────────────┤ │ 0 │ 'proposalId' │ 'Compact<u32>' │ 'ProposalIndex' │ └─────────┴──────────────┴────────────────┴─────────────────┘

utility:

utility.batch

docs
@ 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`). @ @ # <weight> @ - Complexity: O(C) where C is the number of calls to be batched. @ # </weight> @ @ 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.
args
┌─────────┬─────────┬─────────────┬─────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼─────────┼─────────────┼─────────────┤ │ 0 │ 'calls' │ 'Vec<Call>' │ 'Vec<Call>' │ └─────────┴─────────┴─────────────┴─────────────┘

utility.asDerivative

docs
@ 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_.
args
┌─────────┬─────────┬────────┬──────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼─────────┼────────┼──────────┤ │ 0 │ 'index' │ 'u16' │ 'u16' │ │ 1 │ 'call' │ 'Call' │ 'Call' │ └─────────┴─────────┴────────┴──────────┘

utility.batchAll

docs
@ 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`). @ @ # <weight> @ - Complexity: O(C) where C is the number of calls to be batched. @ # </weight>
args
┌─────────┬─────────┬─────────────┬─────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼─────────┼─────────────┼─────────────┤ │ 0 │ 'calls' │ 'Vec<Call>' │ 'Vec<Call>' │ └─────────┴─────────┴─────────────┴─────────────┘

utility.dispatchAs

docs
@ Dispatches a function call with a provided origin. @ @ The dispatch origin for this call must be _Root_. @ @ # <weight> @ - O(1). @ - Limited storage reads. @ - One DB write (event). @ - Weight of derivative `call` execution + T::WeightInfo::dispatch_as(). @ # </weight>
args
┌─────────┬────────────┬───────────────────────────┬─────────────────┐ │ (index) │ name │ type │ typeName │ ├─────────┼────────────┼───────────────────────────┼─────────────────┤ │ 0 │ 'asOrigin' │ 'NodeRuntimeOriginCaller' │ 'PalletsOrigin' │ │ 1 │ 'call' │ 'Call' │ 'Call' │ └─────────┴────────────┴───────────────────────────┴─────────────────┘