Skip to content

Instantly share code, notes, and snippets.

@insipx

insipx/meta_block_1768321.json

Created April 9, 2020 14:10
Show Gist options
  • Star 0 You must be signed in to star a gist
  • Fork 0 You must be signed in to fork a gist
  • Save insipx/db5e49c0160b1f1bd421a3c34fefdf48 to your computer and use it in GitHub Desktop.
Save insipx/db5e49c0160b1f1bd421a3c34fefdf48 to your computer and use it in GitHub Desktop.
Download ZIP
Full Metadata for block 1768321 on Kusama
Raw
meta_block_1768321.json
[
1635018093,
{
"V11": {
"modules": [
{
"name": "System",
"storage": {
"prefix": "System",
"entries": [
{
"name": "Account",
"modifier": "Default",
"ty": {
"Map": {
"hasher": "Blake2_128Concat",
"key": "T::AccountId",
"value": "AccountInfo<T::Index, T::AccountData>",
"unused": false
}
},
"default": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"documentation": [
" The full account information for a particular account ID."
]
},
{
"name": "ExtrinsicCount",
"modifier": "Optional",
"ty": {
"Plain": "u32"
},
"default": [
0
],
"documentation": [
" Total extrinsics count for the current block."
]
},
{
"name": "AllExtrinsicsWeight",
"modifier": "Optional",
"ty": { "Plain": "Weight" }, "default": [
0
],
"documentation": [
" Total weight for all extrinsics put together, for the current block."
]
},
{
"name": "AllExtrinsicsLen",
"modifier": "Optional",
"ty": {
"Plain": "u32"
},
"default": [
0
],
"documentation": [
" Total length (in bytes) for all extrinsics put together, for the current block."
]
},
{
"name": "BlockHash",
"modifier": "Default",
"ty": {
"Map": {
"hasher": "Twox64Concat",
"key": "T::BlockNumber",
"value": "T::Hash",
"unused": false
}
},
"default": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"documentation": [
" Map of block numbers to block hashes."
]
},
{
"name": "ExtrinsicData",
"modifier": "Default",
"ty": {
"Map": {
"hasher": "Twox64Concat",
"key": "u32",
"value": "Vec<u8>",
"unused": false
}
},
"default": [
0
],
"documentation": [
" Extrinsics data for the current block (maps an extrinsic's index to its data)."
]
},
{
"name": "Number",
"modifier": "Default",
"ty": {
"Plain": "T::BlockNumber"
},
"default": [
0,
0,
0,
0
],
"documentation": [
" The current block number being processed. Set by `execute_block`."
]
},
{
"name": "ParentHash",
"modifier": "Default",
"ty": {
"Plain": "T::Hash"
},
"default": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"documentation": [
" Hash of the previous block."
]
},
{
"name": "ExtrinsicsRoot",
"modifier": "Default",
"ty": {
"Plain": "T::Hash"
},
"default": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"documentation": [
" Extrinsics root of the current block, also part of the block header."
]
},
{
"name": "Digest",
"modifier": "Default",
"ty": {
"Plain": "DigestOf<T>"
},
"default": [
0
],
"documentation": [
" Digest of the current block, also part of the block header."
]
},
{
"name": "Events",
"modifier": "Default",
"ty": {
"Plain": "Vec<EventRecord<T::Event, T::Hash>>"
},
"default": [
0
],
"documentation": [
" Events deposited for the current block."
]
},
{
"name": "EventCount",
"modifier": "Default",
"ty": {
"Plain": "EventIndex"
},
"default": [
0,
0,
0,
0
],
"documentation": [
" The number of events in the `Events<T>` list."
]
},
{
"name": "EventTopics",
"modifier": "Default",
"ty": {
"Map": {
"hasher": "Blake2_128Concat",
"key": "T::Hash",
"value": "Vec<(T::BlockNumber, EventIndex)>",
"unused": false
}
},
"default": [
0
],
"documentation": [
" Mapping between a topic (represented by T::Hash) and a vector of indexes",
" of events in the `<Events<T>>` list.",
"",
" All topic vectors have deterministic storage locations depending on the topic. This",
" allows light-clients to leverage the changes trie storage tracking mechanism and",
" in case of changes fetch the list of events of interest.",
"",
" The value has the type `(T::BlockNumber, EventIndex)` because if we used only just",
" the `EventIndex` then in case if the topic has the same contents on the next block",
" no notification will be triggered thus the event might be lost."
]
},
{
"name": "LastRuntimeUpgrade",
"modifier": "Optional",
"ty": {
"Plain": "LastRuntimeUpgradeInfo"
},
"default": [
0
],
"documentation": [
" Stores the `spec_version` and `spec_name` of when the last runtime upgrade happened."
]
},
{
"name": "ExecutionPhase",
"modifier": "Optional",
"ty": {
"Plain": "Phase"
},
"default": [
0
],
"documentation": [
" The execution phase of the block."
]
}
]
},
"calls": [
{
"name": "fill_block",
"arguments": [
{
"name": "_ratio",
"ty": "Perbill"
}
],
"documentation": [
" A dispatch that will fill the block weight up to the given ratio."
]
},
{
"name": "remark",
"arguments": [
{
"name": "_remark",
"ty": "Vec<u8>"
}
],
"documentation": [
" Make some on-chain remark."
]
},
{
"name": "set_heap_pages",
"arguments": [
{
"name": "pages",
"ty": "u64"
}
],
"documentation": [
" Set the number of pages in the WebAssembly environment's heap."
]
},
{
"name": "set_code",
"arguments": [
{
"name": "code",
"ty": "Vec<u8>"
}
],
"documentation": [
" Set the new runtime code."
]
},
{
"name": "set_code_without_checks",
"arguments": [
{
"name": "code",
"ty": "Vec<u8>"
}
],
"documentation": [
" Set the new runtime code without doing any checks of the given `code`."
]
},
{
"name": "set_changes_trie_config",
"arguments": [
{
"name": "changes_trie_config",
"ty": "Option<ChangesTrieConfiguration>"
}
],
"documentation": [
" Set the new changes trie configuration."
]
},
{
"name": "set_storage",
"arguments": [
{
"name": "items",
"ty": "Vec<KeyValue>"
}
],
"documentation": [
" Set some items of storage."
]
},
{
"name": "kill_storage",
"arguments": [
{
"name": "keys",
"ty": "Vec<Key>"
}
],
"documentation": [
" Kill some items from storage."
]
},
{
"name": "kill_prefix",
"arguments": [
{
"name": "prefix",
"ty": "Key"
}
],
"documentation": [
" Kill all storage items with a key that starts with the given prefix."
]
},
{
"name": "suicide",
"arguments": [],
"documentation": [
" Kill the sending account, assuming there are no references outstanding and the composite",
" data is equal to its default value."
]
}
],
"event": [
{
"name": "ExtrinsicSuccess",
"arguments": [
"DispatchInfo"
],
"documentation": [
" An extrinsic completed successfully."
]
},
{
"name": "ExtrinsicFailed",
"arguments": [
"DispatchError",
"DispatchInfo"
],
"documentation": [
" An extrinsic failed."
]
},
{
"name": "CodeUpdated",
"arguments": [],
"documentation": [
" `:code` was updated."
]
},
{
"name": "NewAccount",
"arguments": [
"AccountId"
],
"documentation": [
" A new account was created."
]
},
{
"name": "KilledAccount",
"arguments": [
"AccountId"
],
"documentation": [
" An account was reaped."
]
}
],
"constants": [],
"errors": [
{
"name": "InvalidSpecName",
"documentation": [
" The name of specification does not match between the current runtime",
" and the new runtime."
]
},
{
"name": "SpecVersionNeedsToIncrease",
"documentation": [
" The specification version is not allowed to decrease between the current runtime",
" and the new runtime."
]
},
{
"name": "FailedToExtractRuntimeVersion",
"documentation": [
" Failed to extract the runtime version from the new runtime.",
"",
" Either calling `Core_version` or decoding `RuntimeVersion` failed."
]
},
{
"name": "NonDefaultComposite",
"documentation": [
" Suicide called when the account has non-default composite data."
]
},
{
"name": "NonZeroRefCount",
"documentation": [
" There is a non-zero reference count preventing the account from being purged."
]
}
]
},
{
"name": "RandomnessCollectiveFlip",
"storage": {
"prefix": "RandomnessCollectiveFlip",
"entries": [
{
"name": "RandomMaterial",
"modifier": "Default",
"ty": {
"Plain": "Vec<T::Hash>"
},
"default": [
0
],
"documentation": [
" Series of block headers from the last 81 blocks that acts as random seed material. This",
" is arranged as a ring buffer with `block_number % 81` being the index into the `Vec` of",
" the oldest hash."
]
}
]
},
"calls": null,
"event": null,
"constants": [],
"errors": []
},
{
"name": "Babe",
"storage": {
"prefix": "Babe",
"entries": [
{
"name": "EpochIndex",
"modifier": "Default",
"ty": {
"Plain": "u64"
},
"default": [
0,
0,
0,
0,
0,
0,
0,
0
],
"documentation": [
" Current epoch index."
]
},
{
"name": "Authorities",
"modifier": "Default",
"ty": {
"Plain": "Vec<(AuthorityId, BabeAuthorityWeight)>"
},
"default": [
0
],
"documentation": [
" Current epoch authorities."
]
},
{
"name": "GenesisSlot",
"modifier": "Default",
"ty": {
"Plain": "u64"
},
"default": [
0,
0,
0,
0,
0,
0,
0,
0
],
"documentation": [
" The slot at which the first epoch actually started. This is 0",
" until the first block of the chain."
]
},
{
"name": "CurrentSlot",
"modifier": "Default",
"ty": {
"Plain": "u64"
},
"default": [
0,
0,
0,
0,
0,
0,
0,
0
],
"documentation": [
" Current slot number."
]
},
{
"name": "Randomness",
"modifier": "Default",
"ty": {
"Plain": "[u8; 32]"
},
"default": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"documentation": [
" The epoch randomness for the *current* epoch.",
"",
" # Security",
"",
" This MUST NOT be used for gambling, as it can be influenced by a",
" malicious validator in the short term. It MAY be used in many",
" cryptographic protocols, however, so long as one remembers that this",
" (like everything else on-chain) it is public. For example, it can be",
" used where a number is needed that cannot have been chosen by an",
" adversary, for purposes such as public-coin zero-knowledge proofs."
]
},
{
"name": "NextRandomness",
"modifier": "Default",
"ty": {
"Plain": "[u8; 32]"
},
"default": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"documentation": [
" Next epoch randomness."
]
},
{
"name": "SegmentIndex",
"modifier": "Default",
"ty": {
"Plain": "u32"
},
"default": [
0,
0,
0,
0
],
"documentation": [
" Randomness under construction.",
"",
" We make a tradeoff between storage accesses and list length.",
" We store the under-construction randomness in segments of up to",
" `UNDER_CONSTRUCTION_SEGMENT_LENGTH`.",
"",
" Once a segment reaches this length, we begin the next one.",
" We reset all segments and return to `0` at the beginning of every",
" epoch."
]
},
{
"name": "UnderConstruction",
"modifier": "Default",
"ty": {
"Map": {
"hasher": "Twox64Concat",
"key": "u32",
"value": "Vec<[u8; 32]>",
"unused": false
}
},
"default": [
0
],
"documentation": []
},
{
"name": "Initialized",
"modifier": "Optional",
"ty": {
"Plain": "MaybeVrf"
},
"default": [
0
],
"documentation": [
" Temporary value (cleared at block finalization) which is `Some`",
" if per-block initialization has already been called for current block."
]
}
]
},
"calls": [],
"event": null,
"constants": [
{
"name": "EpochDuration",
"ty": "u64",
"value": [
88,
2,
0,
0,
0,
0,
0,
0
],
"documentation": [
" The number of **slots** that an epoch takes. We couple sessions to",
" epochs, i.e. we start a new session once the new epoch begins."
]
},
{
"name": "ExpectedBlockTime",
"ty": "T::Moment",
"value": [
112,
23,
0,
0,
0,
0,
0,
0
],
"documentation": [
" The expected average block time at which BABE should be creating",
" blocks. Since BABE is probabilistic it is not trivial to figure out",
" what the expected average block time should be based on the slot",
" duration and the security parameter `c` (where `1 - c` represents",
" the probability of a slot being empty)."
]
}
],
"errors": []
},
{
"name": "Timestamp",
"storage": {
"prefix": "Timestamp",
"entries": [
{
"name": "Now",
"modifier": "Default",
"ty": {
"Plain": "T::Moment"
},
"default": [
0,
0,
0,
0,
0,
0,
0,
0
],
"documentation": [
" Current time for the current block."
]
},
{
"name": "DidUpdate",
"modifier": "Default",
"ty": {
"Plain": "bool"
},
"default": [
0
],
"documentation": [
" Did the timestamp get updated in this block?"
]
}
]
},
"calls": [
{
"name": "set",
"arguments": [
{
"name": "now",
"ty": "Compact<T::Moment>"
}
],
"documentation": [
" 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`."
]
}
],
"event": null,
"constants": [
{
"name": "MinimumPeriod",
"ty": "T::Moment",
"value": [
184,
11,
0,
0,
0,
0,
0,
0
],
"documentation": [
" The minimum period between blocks. Beware that this is different to the *expected* period",
" that the block production apparatus provides. Your chosen consensus system will generally",
" work with this to determine a sensible block time. e.g. For Aura, it will be double this",
" period on default settings."
]
}
],
"errors": []
},
{
"name": "Indices",
"storage": {
"prefix": "Indices",
"entries": [
{
"name": "Accounts",
"modifier": "Optional",
"ty": {
"Map": {
"hasher": "Blake2_128Concat",
"key": "T::AccountIndex",
"value": "(T::AccountId, BalanceOf<T>)",
"unused": false
}
},
"default": [
0
],
"documentation": [
" The lookup from index to account."
]
}
]
},
"calls": [
{
"name": "claim",
"arguments": [
{
"name": "index",
"ty": "T::AccountIndex"
}
],
"documentation": [
" 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.",
" # </weight>"
]
},
{
"name": "transfer",
"arguments": [
{
"name": "new",
"ty": "T::AccountId"
},
{
"name": "index",
"ty": "T::AccountIndex"
}
],
"documentation": [
" 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.",
" # </weight>"
]
},
{
"name": "free",
"arguments": [
{
"name": "index",
"ty": "T::AccountIndex"
}
],
"documentation": [
" 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.",
" # </weight>"
]
},
{
"name": "force_transfer",
"arguments": [
{
"name": "new",
"ty": "T::AccountId"
},
{
"name": "index",
"ty": "T::AccountIndex"
}
],
"documentation": [
" 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.",
"",
" Emits `IndexAssigned` if successful.",
"",
" # <weight>",
" - `O(1)`.",
" - One storage mutation (codec `O(1)`).",
" - Up to one reserve operation.",
" - One event.",
" # </weight>"
]
}
],
"event": [
{
"name": "IndexAssigned",
"arguments": [
"AccountId",
"AccountIndex"
],
"documentation": [
" A account index was assigned."
]
},
{
"name": "IndexFreed",
"arguments": [
"AccountIndex"
],
"documentation": [
" A account index has been freed up (unassigned)."
]
}
],
"constants": [],
"errors": []
},
{
"name": "Balances",
"storage": {
"prefix": "Balances",
"entries": [
{
"name": "TotalIssuance",
"modifier": "Default",
"ty": {
"Plain": "T::Balance"
},
"default": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"documentation": [
" The total units issued in the system."
]
},
{
"name": "Account",
"modifier": "Default",
"ty": {
"Map": {
"hasher": "Blake2_128Concat",
"key": "T::AccountId",
"value": "AccountData<T::Balance>",
"unused": false
}
},
"default": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"documentation": [
" The balance of an account.",
"",
" NOTE: THIS MAY NEVER BE IN EXISTENCE AND YET HAVE A `total().is_zero()`. If the total",
" is ever zero, then the entry *MUST* be removed.",
"",
" NOTE: This is only used in the case that this module is used to store balances."
]
},
{
"name": "Locks",
"modifier": "Default",
"ty": {
"Map": {
"hasher": "Blake2_128Concat",
"key": "T::AccountId",
"value": "Vec<BalanceLock<T::Balance>>",
"unused": false
}
},
"default": [
0
],
"documentation": [
" Any liquidity locks on some account balances.",
" NOTE: Should only be accessed when setting, changing and freeing a lock."
]
},
{
"name": "StorageVersion",
"modifier": "Default",
"ty": {
"Plain": "Releases"
},
"default": [
0
],
"documentation": [
" Storage version of the pallet.",
"",
" This is set to v2.0.0 for new networks."
]
}
]
},
"calls": [
{
"name": "transfer",
"arguments": [
{
"name": "dest",
"ty": "<T::Lookup as StaticLookup>::Source"
},
{
"name": "value",
"ty": "Compact<T::Balance>"
}
],
"documentation": [
" 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.",
"",
" # </weight>"
]
},
{
"name": "set_balance",
"arguments": [
{
"name": "who",
"ty": "<T::Lookup as StaticLookup>::Source"
},
{
"name": "new_free",
"ty": "Compact<T::Balance>"
},
{
"name": "new_reserved",
"ty": "Compact<T::Balance>"
}
],
"documentation": [
" 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`.",
"",
" # <weight>",
" - Independent of the arguments.",
" - Contains a limited number of reads and writes.",
" # </weight>"
]
},
{
"name": "force_transfer",
"arguments": [
{
"name": "source",
"ty": "<T::Lookup as StaticLookup>::Source"
},
{
"name": "dest",
"ty": "<T::Lookup as StaticLookup>::Source"
},
{
"name": "value",
"ty": "Compact<T::Balance>"
}
],
"documentation": [
" Exactly as `transfer`, except the origin must be root and the source account may be",
" specified."
]
},
{
"name": "transfer_keep_alive",
"arguments": [
{
"name": "dest",
"ty": "<T::Lookup as StaticLookup>::Source"
},
{
"name": "value",
"ty": "Compact<T::Balance>"
}
],
"documentation": [
" 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.Module.html#method.transfer"
]
}
],
"event": [
{
"name": "Endowed",
"arguments": [
"AccountId",
"Balance"
],
"documentation": [
" An account was created with some free balance."
]
},
{
"name": "DustLost",
"arguments": [
"AccountId",
"Balance"
],
"documentation": [
" An account was removed whose balance was non-zero but below ExistentialDeposit,",
" resulting in an outright loss."
]
},
{
"name": "Transfer",
"arguments": [
"AccountId",
"AccountId",
"Balance"
],
"documentation": [
" Transfer succeeded (from, to, value)."
]
},
{
"name": "BalanceSet",
"arguments": [
"AccountId",
"Balance",
"Balance"
],
"documentation": [
" A balance was set by root (who, free, reserved)."
]
},
{
"name": "Deposit",
"arguments": [
"AccountId",
"Balance"
],
"documentation": [
" Some amount was deposited (e.g. for transaction fees)."
]
}
],
"constants": [
{
"name": "ExistentialDeposit",
"ty": "T::Balance",
"value": [
0,
228,
11,
84,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"documentation": [
" The minimum amount required to keep an account open."
]
}
],
"errors": [
{
"name": "VestingBalance",
"documentation": [
" Vesting balance too high to send value"
]
},
{
"name": "LiquidityRestrictions",
"documentation": [
" Account liquidity restrictions prevent withdrawal"
]
},
{
"name": "Overflow",
"documentation": [
" Got an overflow after adding"
]
},
{
"name": "InsufficientBalance",
"documentation": [
" Balance too low to send value"
]
},
{
"name": "ExistentialDeposit",
"documentation": [
" Value too low to create account due to existential deposit"
]
},
{
"name": "KeepAlive",
"documentation": [
" Transfer/payment would kill account"
]
},
{
"name": "ExistingVestingSchedule",
"documentation": [
" A vesting schedule already exists for this account"
]
},
{
"name": "DeadAccount",
"documentation": [
" Beneficiary account must pre-exist"
]
}
]
},
{
"name": "TransactionPayment",
"storage": {
"prefix": "TransactionPayment",
"entries": [
{
"name": "NextFeeMultiplier",
"modifier": "Default",
"ty": {
"Plain": "Multiplier"
},
"default": [
0,
0,
0,
0,
0,
0,
0,
0
],
"documentation": []
}
]
},
"calls": null,
"event": null,
"constants": [
{
"name": "TransactionBaseFee",
"ty": "BalanceOf<T>",
"value": [
0,
228,
11,
84,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"documentation": [
" The fee to be paid for making a transaction; the base."
]
},
{
"name": "TransactionByteFee",
"ty": "BalanceOf<T>",
"value": [
0,
225,
245,
5,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"documentation": [
" The fee to be paid for making a transaction; the per-byte portion."
]
}
],
"errors": []
},
{
"name": "Authorship",
"storage": {
"prefix": "Authorship",
"entries": [
{
"name": "Uncles",
"modifier": "Default",
"ty": {
"Plain": "Vec<UncleEntryItem<T::BlockNumber, T::Hash, T::AccountId>>"
},
"default": [
0
],
"documentation": [
" Uncles"
]
},
{
"name": "Author",
"modifier": "Optional",
"ty": {
"Plain": "T::AccountId"
},
"default": [
0
],
"documentation": [
" Author of current block."
]
},
{
"name": "DidSetUncles",
"modifier": "Default",
"ty": {
"Plain": "bool"
},
"default": [
0
],
"documentation": [
" Whether uncles were already set in this block."
]
}
]
},
"calls": [
{
"name": "set_uncles",
"arguments": [
{
"name": "new_uncles",
"ty": "Vec<T::Header>"
}
],
"documentation": [
" Provide a set of uncles."
]
}
],
"event": null,
"constants": [],
"errors": [
{
"name": "InvalidUncleParent",
"documentation": [
" The uncle parent not in the chain."
]
},
{
"name": "UnclesAlreadySet",
"documentation": [
" Uncles already set in the block."
]
},
{
"name": "TooManyUncles",
"documentation": [
" Too many uncles."
]
},
{
"name": "GenesisUncle",
"documentation": [
" The uncle is genesis."
]
},
{
"name": "TooHighUncle",
"documentation": [
" The uncle is too high in chain."
]
},
{
"name": "UncleAlreadyIncluded",
"documentation": [
" The uncle is already included."
]
},
{
"name": "OldUncle",
"documentation": [
" The uncle isn't recent enough to be included."
]
}
]
},
{
"name": "Staking",
"storage": {
"prefix": "Staking",
"entries": [
{
"name": "HistoryDepth",
"modifier": "Default",
"ty": {
"Plain": "u32"
},
"default": [
84,
0,
0,
0
],
"documentation": [
" Number of era to keep in history.",
"",
" Information is kept for eras in `[current_era - history_depth; current_era]",
"",
" Must be more than the number of era delayed by session otherwise.",
" i.e. active era must always be in history.",
" i.e. `active_era > current_era - history_depth` must be guaranteed."
]
},
{
"name": "ValidatorCount",
"modifier": "Default",
"ty": {
"Plain": "u32"
},
"default": [
0,
0,
0,
0
],
"documentation": [
" The ideal number of staking participants."
]
},
{
"name": "MinimumValidatorCount",
"modifier": "Default",
"ty": {
"Plain": "u32"
},
"default": [
4,
0,
0,
0
],
"documentation": [
" Minimum number of staking participants before emergency conditions are imposed."
]
},
{
"name": "Invulnerables",
"modifier": "Default",
"ty": {
"Plain": "Vec<T::AccountId>"
},
"default": [
0
],
"documentation": [
" Any validators that may never be slashed or forcibly kicked. It's a Vec since they're",
" easy to initialize and the performance hit is minimal (we expect no more than four",
" invulnerables) and restricted to testnets."
]
},
{
"name": "Bonded",
"modifier": "Optional",
"ty": {
"Map": {
"hasher": "Twox64Concat",
"key": "T::AccountId",
"value": "T::AccountId",
"unused": false
}
},
"default": [
0
],
"documentation": [
" Map from all locked \"stash\" accounts to the controller account."
]
},
{
"name": "Ledger",
"modifier": "Optional",
"ty": {
"Map": {
"hasher": "Blake2_128Concat",
"key": "T::AccountId",
"value": "StakingLedger<T::AccountId, BalanceOf<T>>",
"unused": false
}
},
"default": [
0
],
"documentation": [
" Map from all (unlocked) \"controller\" accounts to the info regarding the staking."
]
},
{
"name": "Payee",
"modifier": "Default",
"ty": {
"Map": {
"hasher": "Twox64Concat",
"key": "T::AccountId",
"value": "RewardDestination",
"unused": false
}
},
"default": [
0
],
"documentation": [
" Where the reward payment should be made. Keyed by stash."
]
},
{
"name": "Validators",
"modifier": "Default",
"ty": {
"Map": {
"hasher": "Twox64Concat",
"key": "T::AccountId",
"value": "ValidatorPrefs",
"unused": false
}
},
"default": [
0
],
"documentation": [
" The map from (wannabe) validator stash key to the preferences of that validator."
]
},
{
"name": "Nominators",
"modifier": "Optional",
"ty": {
"Map": {
"hasher": "Twox64Concat",
"key": "T::AccountId",
"value": "Nominations<T::AccountId>",
"unused": false
}
},
"default": [
0
],
"documentation": [
" The map from nominator stash key to the set of stash keys of all validators to nominate."
]
},
{
"name": "CurrentEra",
"modifier": "Optional",
"ty": {
"Plain": "EraIndex"
},
"default": [
0
],
"documentation": [
" The current era index.",
"",
" This is the latest planned era, depending on how session module queues the validator",
" set, it might be active or not."
]
},
{
"name": "ActiveEra",
"modifier": "Optional",
"ty": {
"Plain": "ActiveEraInfo<MomentOf<T>>"
},
"default": [
0
],
"documentation": [
" The active era information, it holds index and start.",
"",
" The active era is the era currently rewarded.",
" Validator set of this era must be equal to `SessionInterface::validators`."
]
},
{
"name": "ErasStartSessionIndex",
"modifier": "Optional",
"ty": {
"Map": {
"hasher": "Twox64Concat",
"key": "EraIndex",
"value": "SessionIndex",
"unused": false
}
},
"default": [
0
],
"documentation": [
" The session index at which the era start for the last `HISTORY_DEPTH` eras"
]
},
{
"name": "ErasStakers",
"modifier": "Default",
"ty": {
"DoubleMap": {
"hasher": "Twox64Concat",
"key1": "EraIndex",
"key2": "T::AccountId",
"value": "Exposure<T::AccountId, BalanceOf<T>>",
"key2_hasher": "Twox64Concat"
}
},
"default": [
0,
0,
0
],
"documentation": [
" Exposure of validator at era.",
"",
" This is keyed first by the era index to allow bulk deletion and then the stash account.",
"",
" Is it removed after `HISTORY_DEPTH` eras.",
" If stakers hasn't been set or has been removed then empty exposure is returned."
]
},
{
"name": "ErasStakersClipped",
"modifier": "Default",
"ty": {
"DoubleMap": {
"hasher": "Twox64Concat",
"key1": "EraIndex",
"key2": "T::AccountId",
"value": "Exposure<T::AccountId, BalanceOf<T>>",
"key2_hasher": "Twox64Concat"
}
},
"default": [
0,
0,
0
],
"documentation": [
" Clipped Exposure of validator at era.",
"",
" This is similar to [`ErasStakers`] but number of nominators exposed is reduce to the",
" `T::MaxNominatorRewardedPerValidator` biggest stakers.",
" (Note: the field `total` and `own` of the exposure remains unchanged).",
" This is used to limit the i/o cost for the nominator payout.",
"",
" This is keyed fist by the era index to allow bulk deletion and then the stash account.",
"",
" Is it removed after `HISTORY_DEPTH` eras.",
" If stakers hasn't been set or has been removed then empty exposure is returned."
]
},
{
"name": "ErasValidatorPrefs",
"modifier": "Default",
"ty": {
"DoubleMap": {
"hasher": "Twox64Concat",
"key1": "EraIndex",
"key2": "T::AccountId",
"value": "ValidatorPrefs",
"key2_hasher": "Twox64Concat"
}
},
"default": [
0
],
"documentation": [
" Similarly to `ErasStakers` this holds the preferences of validators.",
"",
" This is keyed first by the era index to allow bulk deletion and then the stash account.",
"",
" Is it removed after `HISTORY_DEPTH` eras."
]
},
{
"name": "ErasValidatorReward",
"modifier": "Optional",
"ty": {
"Map": {
"hasher": "Twox64Concat",
"key": "EraIndex",
"value": "BalanceOf<T>",
"unused": false
}
},
"default": [
0
],
"documentation": [
" The total validator era payout for the last `HISTORY_DEPTH` eras.",
"",
" Eras that haven't finished yet or has been removed doesn't have reward."
]
},
{
"name": "ErasRewardPoints",
"modifier": "Default",
"ty": {
"Map": {
"hasher": "Twox64Concat",
"key": "EraIndex",
"value": "EraRewardPoints<T::AccountId>",
"unused": false
}
},
"default": [
0,
0,
0,
0,
0
],
"documentation": [
" Rewards for the last `HISTORY_DEPTH` eras.",
" If reward hasn't been set or has been removed then 0 reward is returned."
]
},
{
"name": "ErasTotalStake",
"modifier": "Default",
"ty": {
"Map": {
"hasher": "Twox64Concat",
"key": "EraIndex",
"value": "BalanceOf<T>",
"unused": false
}
},
"default": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"documentation": [
" The total amount staked for the last `HISTORY_DEPTH` eras.",
" If total hasn't been set or has been removed then 0 stake is returned."
]
},
{
"name": "ForceEra",
"modifier": "Default",
"ty": {
"Plain": "Forcing"
},
"default": [
0
],
"documentation": [
" True if the next session change will be a new era regardless of index."
]
},
{
"name": "SlashRewardFraction",
"modifier": "Default",
"ty": {
"Plain": "Perbill"
},
"default": [
0,
0,
0,
0
],
"documentation": [
" The percentage of the slash that is distributed to reporters.",
"",
" The rest of the slashed value is handled by the `Slash`."
]
},
{
"name": "CanceledSlashPayout",
"modifier": "Default",
"ty": {
"Plain": "BalanceOf<T>"
},
"default": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"documentation": [
" The amount of currency given to reporters of a slash event which was",
" canceled by extraordinary circumstances (e.g. governance)."
]
},
{
"name": "UnappliedSlashes",
"modifier": "Default",
"ty": {
"Map": {
"hasher": "Twox64Concat",
"key": "EraIndex",
"value": "Vec<UnappliedSlash<T::AccountId, BalanceOf<T>>>",
"unused": false
}
},
"default": [
0
],
"documentation": [
" All unapplied slashes that are queued for later."
]
},
{
"name": "BondedEras",
"modifier": "Default",
"ty": {
"Plain": "Vec<(EraIndex, SessionIndex)>"
},
"default": [
0
],
"documentation": [
" A mapping from still-bonded eras to the first session index of that era.",
"",
" Must contains information for eras for the range:",
" `[active_era - bounding_duration; active_era]`"
]
},
{
"name": "ValidatorSlashInEra",
"modifier": "Optional",
"ty": {
"DoubleMap": {
"hasher": "Twox64Concat",
"key1": "EraIndex",
"key2": "T::AccountId",
"value": "(Perbill, BalanceOf<T>)",
"key2_hasher": "Twox64Concat"
}
},
"default": [
0
],
"documentation": [
" All slashing events on validators, mapped by era to the highest slash proportion",
" and slash value of the era."
]
},
{
"name": "NominatorSlashInEra",
"modifier": "Optional",
"ty": {
"DoubleMap": {
"hasher": "Twox64Concat",
"key1": "EraIndex",
"key2": "T::AccountId",
"value": "BalanceOf<T>",
"key2_hasher": "Twox64Concat"
}
},
"default": [
0
],
"documentation": [
" All slashing events on nominators, mapped by era to the highest slash value of the era."
]
},
{
"name": "SlashingSpans",
"modifier": "Optional",
"ty": {
"Map": {
"hasher": "Twox64Concat",
"key": "T::AccountId",
"value": "slashing::SlashingSpans",
"unused": false
}
},
"default": [
0
],
"documentation": [
" Slashing spans for stash accounts."
]
},
{
"name": "SpanSlash",
"modifier": "Default",
"ty": {
"Map": {
"hasher": "Twox64Concat",
"key": "(T::AccountId, slashing::SpanIndex)",
"value": "slashing::SpanRecord<BalanceOf<T>>",
"unused": false
}
},
"default": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"documentation": [
" Records information about the maximum slash of a stash within a slashing span,",
" as well as how much reward has been paid out."
]
},
{
"name": "EarliestUnappliedSlash",
"modifier": "Optional",
"ty": {
"Plain": "EraIndex"
},
"default": [
0
],
"documentation": [
" The earliest era for which we have a pending, unapplied slash."
]
},
{
"name": "StorageVersion",
"modifier": "Default",
"ty": {
"Plain": "Releases"
},
"default": [
1
],
"documentation": [
" Storage version of the pallet.",
"",
" This is set to v2.0.0 for new networks."
]
}
]
},
"calls": [
{
"name": "bond",
"arguments": [
{
"name": "controller",
"ty": "<T::Lookup as StaticLookup>::Source"
},
{
"name": "value",
"ty": "Compact<BalanceOf<T>>"
},
{
"name": "payee",
"ty": "RewardDestination"
}
],
"documentation": [
" 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>"
]
},
{
"name": "bond_extra",
"arguments": [
{
"name": "max_additional",
"ty": "Compact<BalanceOf<T>>"
}
],
"documentation": [
" Add some extra amount that have appeared in the stash `free_balance` into the balance up",
" for staking.",
"",
" Use this if there are additional funds in your stash account that you wish to bond.",
" Unlike [`bond`] or [`unbond`] this function does not impose any limitation on the amount",
" that can be added.",
"",
" The dispatch origin for this call must be _Signed_ by the stash, not the controller.",
"",
" Emits `Bonded`.",
"",
" # <weight>",
" - Independent of the arguments. Insignificant complexity.",
" - O(1).",
" - One DB entry.",
" # </weight>"
]
},
{
"name": "unbond",
"arguments": [
{
"name": "value",
"ty": "Compact<BalanceOf<T>>"
}
],
"documentation": [
" Schedule a portion of the stash to be unlocked ready for transfer out after the bond",
" period ends. If this leaves an amount actively bonded less than",
" T::Currency::minimum_balance(), then it is increased to the full amount.",
"",
" Once the unlock period is done, you can call `withdraw_unbonded` to actually move",
" the funds out of management ready for transfer.",
"",
" No more than a limited number of unlocking chunks (see `MAX_UNLOCKING_CHUNKS`)",
" can co-exists at the same time. In that case, [`Call::withdraw_unbonded`] need",
" to be called first to remove some of the chunks (if possible).",
"",
" The dispatch origin for this call must be _Signed_ by the controller, not the stash.",
"",
" Emits `Unbonded`.",
"",
" See also [`Call::withdraw_unbonded`].",
"",
" # <weight>",
" - Independent of the arguments. Limited but potentially exploitable complexity.",
" - Contains a limited number of reads.",
" - Each call (requires the remainder of the bonded balance to be above `minimum_balance`)",
" will cause a new entry to be inserted into a vector (`Ledger.unlocking`) kept in storage.",
" The only way to clean the aforementioned storage item is also user-controlled via",
" `withdraw_unbonded`.",
" - One DB entry.",
" </weight>"
]
},
{
"name": "withdraw_unbonded",
"arguments": [],
"documentation": [
" Remove any unlocked chunks from the `unlocking` queue from our management.",
"",
" This essentially frees up that balance to be used by the stash account to do",
" whatever it wants.",
"",
" The dispatch origin for this call must be _Signed_ by the controller, not the stash.",
"",
" Emits `Withdrawn`.",
"",
" See also [`Call::unbond`].",
"",
" # <weight>",
" - Could be dependent on the `origin` argument and how much `unlocking` chunks exist.",
" It implies `consolidate_unlocked` which loops over `Ledger.unlocking`, which is",
" indirectly user-controlled. See [`unbond`] for more detail.",
" - Contains a limited number of reads, yet the size of which could be large based on `ledger`.",
" - Writes are limited to the `origin` account key.",
" # </weight>"
]
},
{
"name": "validate",
"arguments": [
{
"name": "prefs",
"ty": "ValidatorPrefs"
}
],
"documentation": [
" 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.",
"",
" # <weight>",
" - Independent of the arguments. Insignificant complexity.",
" - Contains a limited number of reads.",
" - Writes are limited to the `origin` account key.",
" # </weight>"
]
},
{
"name": "nominate",
"arguments": [
{
"name": "targets",
"ty": "Vec<<T::Lookup as StaticLookup>::Source>"
}
],
"documentation": [
" 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`,",
" which is capped at `MAX_NOMINATIONS`.",
" - Both the reads and writes follow a similar pattern.",
" # </weight>"
]
},
{
"name": "chill",
"arguments": [],
"documentation": [
" 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>"
]
},
{
"name": "set_payee",
"arguments": [
{
"name": "payee",
"ty": "RewardDestination"
}
],
"documentation": [
" (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>"
]
},
{
"name": "set_controller",
"arguments": [
{
"name": "controller",
"ty": "<T::Lookup as StaticLookup>::Source"
}
],
"documentation": [
" (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>"
]
},
{
"name": "set_validator_count",
"arguments": [
{
"name": "new",
"ty": "Compact<u32>"
}
],
"documentation": [
" The ideal number of validators."
]
},
{
"name": "force_no_eras",
"arguments": [],
"documentation": [
" Force there to be no new eras indefinitely.",
"",
" # <weight>",
" - No arguments.",
" # </weight>"
]
},
{
"name": "force_new_era",
"arguments": [],
"documentation": [
" 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.",
"",
" # <weight>",
" - No arguments.",
" # </weight>"
]
},
{
"name": "set_invulnerables",
"arguments": [
{
"name": "validators",
"ty": "Vec<T::AccountId>"
}
],
"documentation": [
" Set the validators who cannot be slashed (if any)."
]
},
{
"name": "force_unstake",
"arguments": [
{
"name": "stash",
"ty": "T::AccountId"
}
],
"documentation": [
" Force a current staker to become completely unstaked, immediately."
]
},
{
"name": "force_new_era_always",
"arguments": [],
"documentation": [
" Force there to be a new era at the end of sessions indefinitely.",
"",
" # <weight>",
" - One storage write",
" # </weight>"
]
},
{
"name": "cancel_deferred_slash",
"arguments": [
{
"name": "era",
"ty": "EraIndex"
},
{
"name": "slash_indices",
"ty": "Vec<u32>"
}
],
"documentation": [
" Cancel enactment of a deferred slash. Can be called by either the root origin or",
" the `T::SlashCancelOrigin`.",
" passing the era and indices of the slashes for that era to kill.",
"",
" # <weight>",
" - One storage write.",
" # </weight>"
]
},
{
"name": "payout_nominator",
"arguments": [
{
"name": "era",
"ty": "EraIndex"
},
{
"name": "validators",
"ty": "Vec<(T::AccountId, u32)>"
}
],
"documentation": [
" Make one nominator's payout for one era.",
"",
" - `who` is the controller account of the nominator to pay out.",
" - `era` may not be lower than one following the most recently paid era. If it is higher,",
" then it indicates an instruction to skip the payout of all previous eras.",
" - `validators` is the list of all validators that `who` had exposure to during `era`,",
" alongside the index of `who` in the clipped exposure of the validator.",
" I.e. each element is a tuple of",
" `(validator, index of `who` in clipped exposure of validator)`.",
" If it is incomplete, then less than the full reward will be paid out.",
" It must not exceed `MAX_NOMINATIONS`.",
"",
" WARNING: once an era is payed for a validator such validator can't claim the payout of",
" previous era.",
"",
" WARNING: Incorrect arguments here can result in loss of payout. Be very careful.",
"",
" # <weight>",
" - Number of storage read of `O(validators)`; `validators` is the argument of the call,",
" and is bounded by `MAX_NOMINATIONS`.",
" - Each storage read is `O(N)` size and decode complexity; `N` is the maximum",
" nominations that can be given to a single validator.",
" - Computation complexity: `O(MAX_NOMINATIONS * logN)`; `MAX_NOMINATIONS` is the",
" maximum number of validators that may be nominated by a single nominator, it is",
" bounded only economically (all nominators are required to place a minimum stake).",
" # </weight>"
]
},
{
"name": "payout_validator",
"arguments": [
{
"name": "era",
"ty": "EraIndex"
}
],
"documentation": [
" Make one validator's payout for one era.",
"",
" - `who` is the controller account of the validator to pay out.",
" - `era` may not be lower than one following the most recently paid era. If it is higher,",
" then it indicates an instruction to skip the payout of all previous eras.",
"",
" WARNING: once an era is payed for a validator such validator can't claim the payout of",
" previous era.",
"",
" WARNING: Incorrect arguments here can result in loss of payout. Be very careful.",
"",
" # <weight>",
" - Time complexity: O(1).",
" - Contains a limited number of reads and writes.",
" # </weight>"
]
},
{
"name": "rebond",
"arguments": [
{
"name": "value",
"ty": "Compact<BalanceOf<T>>"
}
],
"documentation": [
" Rebond a portion of the stash scheduled to be unlocked.",
"",
" # <weight>",
" - Time complexity: O(1). Bounded by `MAX_UNLOCKING_CHUNKS`.",
" - Storage changes: Can't increase storage, only decrease it.",
" # </weight>"
]
},
{
"name": "set_history_depth",
"arguments": [
{
"name": "new_history_depth",
"ty": "Compact<EraIndex>"
}
],
"documentation": [
" Set history_depth value.",
"",
" Origin must be root."
]
},
{
"name": "reap_stash",
"arguments": [
{
"name": "stash",
"ty": "T::AccountId"
}
],
"documentation": [
" Remove all data structure concerning a staker/stash once its balance is zero.",
" This is essentially equivalent to `withdraw_unbonded` except it can be called by anyone",
" and the target `stash` must have no funds left.",
"",
" This can be called from any origin.",
"",
" - `stash`: The stash account to reap. Its balance must be zero."
]
}
],
"event": [
{
"name": "Reward",
"arguments": [
"AccountId",
"Balance"
],
"documentation": [
" The staker has been rewarded by this amount. AccountId is controller account."
]
},
{
"name": "Slash",
"arguments": [
"AccountId",
"Balance"
],
"documentation": [
" One validator (and its nominators) has been slashed by the given amount."
]
},
{
"name": "OldSlashingReportDiscarded",
"arguments": [
"SessionIndex"
],
"documentation": [
" An old slashing report from a prior era was discarded because it could",
" not be processed."
]
},
{
"name": "Bonded",
"arguments": [
"AccountId",
"Balance"
],
"documentation": [
" An account has bonded this amount.",
"",
" NOTE: This event is only emitted when funds are bonded via a dispatchable. Notably,",
" it will not be emitted for staking rewards when they are added to stake."
]
},
{
"name": "Unbonded",
"arguments": [
"AccountId",
"Balance"
],
"documentation": [
" An account has unbonded this amount."
]
},
{
"name": "Withdrawn",
"arguments": [
"AccountId",
"Balance"
],
"documentation": [
" An account has called `withdraw_unbonded` and removed unbonding chunks worth `Balance`",
" from the unlocking queue."
]
}
],
"constants": [
{
"name": "SessionsPerEra",
"ty": "SessionIndex",
"value": [
6,
0,
0,
0
],
"documentation": [
" Number of sessions per era."
]
},
{
"name": "BondingDuration",
"ty": "EraIndex",
"value": [
28,
0,
0,
0
],
"documentation": [
" Number of eras that staked funds must remain bonded for."
]
}
],
"errors": [
{
"name": "NotController",
"documentation": [
" Not a controller account."
]
},
{
"name": "NotStash",
"documentation": [
" Not a stash account."
]
},
{
"name": "AlreadyBonded",
"documentation": [
" Stash is already bonded."
]
},
{
"name": "AlreadyPaired",
"documentation": [
" Controller is already paired."
]
},
{
"name": "EmptyTargets",
"documentation": [
" Targets cannot be empty."
]
},
{
"name": "DuplicateIndex",
"documentation": [
" Duplicate index."
]
},
{
"name": "InvalidSlashIndex",
"documentation": [
" Slash record index out of bounds."
]
},
{
"name": "InsufficientValue",
"documentation": [
" Can not bond with value less than minimum balance."
]
},
{
"name": "NoMoreChunks",
"documentation": [
" Can not schedule more unlock chunks."
]
},
{
"name": "NoUnlockChunk",
"documentation": [
" Can not rebond without unlocking chunks."
]
},
{
"name": "FundedTarget",
"documentation": [
" Attempting to target a stash that still has funds."
]
},
{
"name": "InvalidEraToReward",
"documentation": [
" Invalid era to reward."
]
},
{
"name": "InvalidNumberOfNominations",
"documentation": [
" Invalid number of nominations."
]
},
{
"name": "NotSortedAndUnique",
"documentation": [
" Items are not sorted and unique."
]
}
]
},
{
"name": "Offences",
"storage": {
"prefix": "Offences",
"entries": [
{
"name": "Reports",
"modifier": "Optional",
"ty": {
"Map": {
"hasher": "Twox64Concat",
"key": "ReportIdOf<T>",
"value": "OffenceDetails<T::AccountId, T::IdentificationTuple>",
"unused": false
}
},
"default": [
0
],
"documentation": [
" The primary structure that holds all offence records keyed by report identifiers."
]
},
{
"name": "ConcurrentReportsIndex",
"modifier": "Default",
"ty": {
"DoubleMap": {
"hasher": "Twox64Concat",
"key1": "Kind",
"key2": "OpaqueTimeSlot",
"value": "Vec<ReportIdOf<T>>",
"key2_hasher": "Twox64Concat"
}
},
"default": [
0
],
"documentation": [
" A vector of reports of the same kind that happened at the same time slot."
]
},
{
"name": "ReportsByKindIndex",
"modifier": "Default",
"ty": {
"Map": {
"hasher": "Twox64Concat",
"key": "Kind",
"value": "Vec<u8>",
"unused": false
}
},
"default": [
0
],
"documentation": [
" Enumerates all reports of a kind along with the time they happened.",
"",
" All reports are sorted by the time of offence.",
"",
" Note that the actual type of this mapping is `Vec<u8>`, this is because values of",
" different types are not supported at the moment so we are doing the manual serialization."
]
}
]
},
"calls": [],
"event": [
{
"name": "Offence",
"arguments": [
"Kind",
"OpaqueTimeSlot"
],
"documentation": [
" There is an offence reported of the given `kind` happened at the `session_index` and",
" (kind-specific) time slot. This event is not deposited for duplicate slashes."
]
}
],
"constants": [],
"errors": []
},
{
"name": "Session",
"storage": {
"prefix": "Session",
"entries": [
{
"name": "Validators",
"modifier": "Default",
"ty": {
"Plain": "Vec<T::ValidatorId>"
},
"default": [
0
],
"documentation": [
" The current set of validators."
]
},
{
"name": "CurrentIndex",
"modifier": "Default",
"ty": {
"Plain": "SessionIndex"
},
"default": [
0,
0,
0,
0
],
"documentation": [
" Current index of the session."
]
},
{
"name": "QueuedChanged",
"modifier": "Default",
"ty": {
"Plain": "bool"
},
"default": [
0
],
"documentation": [
" True if the underlying economic identities or weighting behind the validators",
" has changed in the queued validator set."
]
},
{
"name": "QueuedKeys",
"modifier": "Default",
"ty": {
"Plain": "Vec<(T::ValidatorId, T::Keys)>"
},
"default": [
0
],
"documentation": [
" The queued keys for the next session. When the next session begins, these keys",
" will be used to determine the validator's session keys."
]
},
{
"name": "DisabledValidators",
"modifier": "Default",
"ty": {
"Plain": "Vec<u32>"
},
"default": [
0
],
"documentation": [
" Indices of disabled validators.",
"",
" The set is cleared when `on_session_ending` returns a new set of identities."
]
},
{
"name": "NextKeys",
"modifier": "Optional",
"ty": {
"Map": {
"hasher": "Twox64Concat",
"key": "T::ValidatorId",
"value": "T::Keys",
"unused": false
}
},
"default": [
0
],
"documentation": [
" The next session keys for a validator."
]
},
{
"name": "KeyOwner",
"modifier": "Optional",
"ty": {
"Map": {
"hasher": "Twox64Concat",
"key": "(KeyTypeId, Vec<u8>)",
"value": "T::ValidatorId",
"unused": false
}
},
"default": [
0
],
"documentation": [
" The owner of a key. The key is the `KeyTypeId` + the encoded key."
]
}
]
},
"calls": [
{
"name": "set_keys",
"arguments": [
{
"name": "keys",
"ty": "T::Keys"
},
{
"name": "proof",
"ty": "Vec<u8>"
}
],
"documentation": [
" 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>",
" - O(log n) in number of accounts.",
" - One extra DB entry.",
" - Increases system account refs by one on success iff there were previously no keys set.",
" In this case, purge_keys will need to be called before the account can be removed.",
" # </weight>"
]
},
{
"name": "purge_keys",
"arguments": [],
"documentation": [
" 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.",
"",
" # <weight>",
" - O(N) in number of key types.",
" - Removes N + 1 DB entries.",
" - Reduces system account refs by one on success.",
" # </weight>"
]
}
],
"event": [
{
"name": "NewSession",
"arguments": [
"SessionIndex"
],
"documentation": [
" New session has happened. Note that the argument is the session index, not the block",
" number as the type might suggest."
]
}
],
"constants": [],
"errors": [
{
"name": "InvalidProof",
"documentation": [
" Invalid ownership proof."
]
},
{
"name": "NoAssociatedValidatorId",
"documentation": [
" No associated validator ID for account."
]
},
{
"name": "DuplicatedKey",
"documentation": [
" Registered duplicate key."
]
},
{
"name": "NoKeys",
"documentation": [
" No keys are associated with this account."
]
}
]
},
{
"name": "FinalityTracker",
"storage": {
"prefix": "FinalityTracker",
"entries": [
{
"name": "RecentHints",
"modifier": "Default",
"ty": {
"Plain": "Vec<T::BlockNumber>"
},
"default": [
0
],
"documentation": [
" Recent hints."
]
},
{
"name": "OrderedHints",
"modifier": "Default",
"ty": {
"Plain": "Vec<T::BlockNumber>"
},
"default": [
0
],
"documentation": [
" Ordered recent hints."
]
},
{
"name": "Median",
"modifier": "Default",
"ty": {
"Plain": "T::BlockNumber"
},
"default": [
0,
0,
0,
0
],
"documentation": [
" The median."
]
},
{
"name": "Update",
"modifier": "Optional",
"ty": {
"Plain": "T::BlockNumber"
},
"default": [
0
],
"documentation": [
" Final hint to apply in the block. `None` means \"same as parent\"."
]
},
{
"name": "Initialized",
"modifier": "Default",
"ty": {
"Plain": "bool"
},
"default": [
0
],
"documentation": []
}
]
},
"calls": [
{
"name": "final_hint",
"arguments": [
{
"name": "hint",
"ty": "Compact<T::BlockNumber>"
}
],
"documentation": [
" Hint that the author of this block thinks the best finalized",
" block is the given number."
]
}
],
"event": null,
"constants": [
{
"name": "WindowSize",
"ty": "T::BlockNumber",
"value": [
101,
0,
0,
0
],
"documentation": [
" The number of recent samples to keep from this chain. Default is 101."
]
},
{
"name": "ReportLatency",
"ty": "T::BlockNumber",
"value": [
232,
3,
0,
0
],
"documentation": [
" The delay after which point things become suspicious. Default is 1000."
]
}
],
"errors": [
{
"name": "AlreadyUpdated",
"documentation": [
" Final hint must be updated only once in the block"
]
},
{
"name": "BadHint",
"documentation": [
" Finalized height above block number"
]
}
]
},
{
"name": "Grandpa",
"storage": {
"prefix": "GrandpaFinality",
"entries": [
{
"name": "State",
"modifier": "Default",
"ty": {
"Plain": "StoredState<T::BlockNumber>"
},
"default": [
0
],
"documentation": [
" State of the current authority set."
]
},
{
"name": "PendingChange",
"modifier": "Optional",
"ty": {
"Plain": "StoredPendingChange<T::BlockNumber>"
},
"default": [
0
],
"documentation": [
" Pending change: (signaled at, scheduled change)."
]
},
{
"name": "NextForced",
"modifier": "Optional",
"ty": {
"Plain": "T::BlockNumber"
},
"default": [
0
],
"documentation": [
" next block number where we can force a change."
]
},
{
"name": "Stalled",
"modifier": "Optional",
"ty": {
"Plain": "(T::BlockNumber, T::BlockNumber)"
},
"default": [
0
],
"documentation": [
" `true` if we are currently stalled."
]
},
{
"name": "CurrentSetId",
"modifier": "Default",
"ty": {
"Plain": "SetId"
},
"default": [
0,
0,
0,
0,
0,
0,
0,
0
],
"documentation": [
" The number of changes (both in terms of keys and underlying economic responsibilities)",
" in the \"set\" of Grandpa validators from genesis."
]
},
{
"name": "SetIdSession",
"modifier": "Optional",
"ty": {
"Map": {
"hasher": "Twox64Concat",
"key": "SetId",
"value": "SessionIndex",
"unused": false
}
},
"default": [
0
],
"documentation": [
" A mapping from grandpa set ID to the index of the *most recent* session for which its",
" members were responsible."
]
}
]
},
"calls": [
{
"name": "report_misbehavior",
"arguments": [
{
"name": "_report",
"ty": "Vec<u8>"
}
],
"documentation": [
" Report some misbehavior."
]
}
],
"event": [
{
"name": "NewAuthorities",
"arguments": [
"AuthorityList"
],
"documentation": [
" New authority set has been applied."
]
},
{
"name": "Paused",
"arguments": [],
"documentation": [
" Current authority set has been paused."
]
},
{
"name": "Resumed",
"arguments": [],
"documentation": [
" Current authority set has been resumed."
]
}
],
"constants": [],
"errors": [
{
"name": "PauseFailed",
"documentation": [
" Attempt to signal GRANDPA pause when the authority set isn't live",
" (either paused or already pending pause)."
]
},
{
"name": "ResumeFailed",
"documentation": [
" Attempt to signal GRANDPA resume when the authority set isn't paused",
" (either live or already pending resume)."
]
},
{
"name": "ChangePending",
"documentation": [
" Attempt to signal GRANDPA change with one already pending."
]
},
{
"name": "TooSoon",
"documentation": [
" Cannot signal forced change so soon after last."
]
}
]
},
{
"name": "ImOnline",
"storage": {
"prefix": "ImOnline",
"entries": [
{
"name": "HeartbeatAfter",
"modifier": "Default",
"ty": {
"Plain": "T::BlockNumber"
},
"default": [
0,
0,
0,
0
],
"documentation": [
" The block number after which it's ok to send heartbeats in current session.",
"",
" At the beginning of each session we set this to a value that should",
" fall roughly in the middle of the session duration.",
" The idea is to first wait for the validators to produce a block",
" in the current session, so that the heartbeat later on will not be necessary."
]
},
{
"name": "Keys",
"modifier": "Default",
"ty": {
"Plain": "Vec<T::AuthorityId>"
},
"default": [
0
],
"documentation": [
" The current set of keys that may issue a heartbeat."
]
},
{
"name": "ReceivedHeartbeats",
"modifier": "Optional",
"ty": {
"DoubleMap": {
"hasher": "Twox64Concat",
"key1": "SessionIndex",
"key2": "AuthIndex",
"value": "Vec<u8>",
"key2_hasher": "Twox64Concat"
}
},
"default": [
0
],
"documentation": [
" For each session index, we keep a mapping of `AuthIndex` to",
" `offchain::OpaqueNetworkState`."
]
},
{
"name": "AuthoredBlocks",
"modifier": "Default",
"ty": {
"DoubleMap": {
"hasher": "Twox64Concat",
"key1": "SessionIndex",
"key2": "T::ValidatorId",
"value": "u32",
"key2_hasher": "Twox64Concat"
}
},
"default": [
0,
0,
0,
0
],
"documentation": [
" For each session index, we keep a mapping of `T::ValidatorId` to the",
" number of blocks authored by the given authority."
]
}
]
},
"calls": [
{
"name": "heartbeat",
"arguments": [
{
"name": "heartbeat",
"ty": "Heartbeat<T::BlockNumber>"
},
{
"name": "_signature",
"ty": "<T::AuthorityId as RuntimeAppPublic>::Signature"
}
],
"documentation": []
}
],
"event": [
{
"name": "HeartbeatReceived",
"arguments": [
"AuthorityId"
],
"documentation": [
" A new heartbeat was received from `AuthorityId`"
]
},
{
"name": "AllGood",
"arguments": [],
"documentation": [
" At the end of the session, no offence was committed."
]
},
{
"name": "SomeOffline",
"arguments": [
"Vec<IdentificationTuple>"
],
"documentation": [
" At the end of the session, at least once validator was found to be offline."
]
}
],
"constants": [],
"errors": [
{
"name": "InvalidKey",
"documentation": [
" Non existent public key."
]
},
{
"name": "DuplicatedHeartbeat",
"documentation": [
" Duplicated heartbeat."
]
}
]
},
{
"name": "AuthorityDiscovery",
"storage": null,
"calls": [],
"event": null,
"constants": [],
"errors": []
},
{
"name": "Democracy",
"storage": {
"prefix": "Democracy",
"entries": [
{
"name": "PublicPropCount",
"modifier": "Default",
"ty": {
"Plain": "PropIndex"
},
"default": [
0,
0,
0,
0
],
"documentation": [
" The number of (public) proposals that have been made so far."
]
},
{
"name": "PublicProps",
"modifier": "Default",
"ty": {
"Plain": "Vec<(PropIndex, T::Hash, T::AccountId)>"
},
"default": [
0
],
"documentation": [
" The public proposals. Unsorted. The second item is the proposal's hash."
]
},
{
"name": "DepositOf",
"modifier": "Optional",
"ty": {
"Map": {
"hasher": "Twox64Concat",
"key": "PropIndex",
"value": "(BalanceOf<T>, Vec<T::AccountId>)",
"unused": false
}
},
"default": [
0
],
"documentation": [
" Those who have locked a deposit."
]
},
{
"name": "Preimages",
"modifier": "Optional",
"ty": {
"Map": {
"hasher": "Identity",
"key": "T::Hash",
"value": "(Vec<u8>, T::AccountId, BalanceOf<T>, T::BlockNumber)",
"unused": false
}
},
"default": [
0
],
"documentation": [
" Map of hashes to the proposal preimage, along with who registered it and their deposit.",
" The block number is the block at which it was deposited."
]
},
{
"name": "ReferendumCount",
"modifier": "Default",
"ty": {
"Plain": "ReferendumIndex"
},
"default": [
0,
0,
0,
0
],
"documentation": [
" The next free referendum index, aka the number of referenda started so far."
]
},
{
"name": "LowestUnbaked",
"modifier": "Default",
"ty": {
"Plain": "ReferendumIndex"
},
"default": [
0,
0,
0,
0
],
"documentation": [
" The lowest referendum index representing an unbaked referendum. Equal to",
" `ReferendumCount` if there isn't a unbaked referendum."
]
},
{
"name": "ReferendumInfoOf",
"modifier": "Optional",
"ty": {
"Map": {
"hasher": "Twox64Concat",
"key": "ReferendumIndex",
"value": "ReferendumInfo<T::BlockNumber, T::Hash, BalanceOf<T>>",
"unused": false
}
},
"default": [
0
],
"documentation": [
" Information concerning any given referendum."
]
},
{
"name": "DispatchQueue",
"modifier": "Default",
"ty": {
"Plain": "Vec<(T::BlockNumber, T::Hash, ReferendumIndex)>"
},
"default": [
0
],
"documentation": [
" Queue of successful referenda to be dispatched. Stored ordered by block number."
]
},
{
"name": "VotingOf",
"modifier": "Default",
"ty": {
"Map": {
"hasher": "Twox64Concat",
"key": "T::AccountId",
"value": "Voting<BalanceOf<T>, T::AccountId, T::BlockNumber>",
"unused": false
}
},
"default": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"documentation": [
" All votes for a particular voter. We store the balance for the number of votes that we",
" have recorded. The second item is the total amount of delegations, that will be added."
]
},
{
"name": "Proxy",
"modifier": "Optional",
"ty": {
"Map": {
"hasher": "Twox64Concat",
"key": "T::AccountId",
"value": "ProxyState<T::AccountId>",
"unused": false
}
},
"default": [
0
],
"documentation": [
" Who is able to vote for whom. Value is the fund-holding account, key is the",
" vote-transaction-sending account."
]
},
{
"name": "Locks",
"modifier": "Optional",
"ty": {
"Map": {
"hasher": "Twox64Concat",
"key": "T::AccountId",
"value": "T::BlockNumber",
"unused": false
}
},
"default": [
0
],
"documentation": [
" Accounts for which there are locks in action which may be removed at some point in the",
" future. The value is the block number at which the lock expires and may be removed."
]
},
{
"name": "LastTabledWasExternal",
"modifier": "Default",
"ty": {
"Plain": "bool"
},
"default": [
0
],
"documentation": [
" True if the last referendum tabled was submitted externally. False if it was a public",
" proposal."
]
},
{
"name": "NextExternal",
"modifier": "Optional",
"ty": {
"Plain": "(T::Hash, VoteThreshold)"
},
"default": [
0
],
"documentation": [
" The referendum to be tabled whenever it would be valid to table an external proposal.",
" This happens when a referendum needs to be tabled and one of two conditions are met:",
" - `LastTabledWasExternal` is `false`; or",
" - `PublicProps` is empty."
]
},
{
"name": "Blacklist",
"modifier": "Optional",
"ty": {
"Map": {
"hasher": "Identity",
"key": "T::Hash",
"value": "(T::BlockNumber, Vec<T::AccountId>)",
"unused": false
}
},
"default": [
0
],
"documentation": [
" A record of who vetoed what. Maps proposal hash to a possible existent block number",
" (until when it may not be resubmitted) and who vetoed it."
]
},
{
"name": "Cancellations",
"modifier": "Default",
"ty": {
"Map": {
"hasher": "Identity",
"key": "T::Hash",
"value": "bool",
"unused": false
}
},
"default": [
0
],
"documentation": [
" Record of all proposals that have been subject to emergency cancellation."
]
}
]
},
"calls": [
{
"name": "propose",
"arguments": [
{
"name": "proposal_hash",
"ty": "T::Hash"
},
{
"name": "value",
"ty": "Compact<BalanceOf<T>>"
}
],
"documentation": [
" 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(1)`.",
" - Two DB changes, one DB entry.",
" # </weight>"
]
},
{
"name": "second",
"arguments": [
{
"name": "proposal",
"ty": "Compact<PropIndex>"
}
],
"documentation": [
" 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.",
"",
" # <weight>",
" - `O(1)`.",
" - One DB entry.",
" # </weight>"
]
},
{
"name": "vote",
"arguments": [
{
"name": "ref_index",
"ty": "Compact<ReferendumIndex>"
},
{
"name": "vote",
"ty": "AccountVote<BalanceOf<T>>"
}
],
"documentation": [
" 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(1)`.",
" - One DB change, one DB entry.",
" # </weight>"
]
},
{
"name": "proxy_vote",
"arguments": [
{
"name": "ref_index",
"ty": "Compact<ReferendumIndex>"
},
{
"name": "vote",
"ty": "AccountVote<BalanceOf<T>>"
}
],
"documentation": [
" Vote in a referendum on behalf of a stash. 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 proxy vote for.",
" - `vote`: The vote configuration.",
"",
" # <weight>",
" - `O(1)`.",
" - One DB change, one DB entry.",
" # </weight>"
]
},
{
"name": "emergency_cancel",
"arguments": [
{
"name": "ref_index",
"ty": "ReferendumIndex"
}
],
"documentation": [
" 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>",
" - Depends on size of storage vec `VotersFor` for this referendum.",
" # </weight>"
]
},
{
"name": "external_propose",
"arguments": [
{
"name": "proposal_hash",
"ty": "T::Hash"
}
],
"documentation": [
" 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(1)`.",
" - One DB change.",
" # </weight>"
]
},
{
"name": "external_propose_majority",
"arguments": [
{
"name": "proposal_hash",
"ty": "T::Hash"
}
],
"documentation": [
" 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)`.",
" - One DB change.",
" # </weight>"
]
},
{
"name": "external_propose_default",
"arguments": [
{
"name": "proposal_hash",
"ty": "T::Hash"
}
],
"documentation": [
" 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)`.",
" - One DB change.",
" # </weight>"
]
},
{
"name": "fast_track",
"arguments": [
{
"name": "proposal_hash",
"ty": "T::Hash"
},
{
"name": "voting_period",
"ty": "T::BlockNumber"
},
{
"name": "delay",
"ty": "T::BlockNumber"
}
],
"documentation": [
" 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>",
" - One DB clear.",
" - One DB change.",
" - One extra DB entry.",
" # </weight>"
]
},
{
"name": "veto_external",
"arguments": [
{
"name": "proposal_hash",
"ty": "T::Hash"
}
],
"documentation": [
" 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>",
" - Two DB entries.",
" - One DB clear.",
" - Performs a binary search on `existing_vetoers` which should not",
" be very large.",
" # </weight>"
]
},
{
"name": "cancel_referendum",
"arguments": [
{
"name": "ref_index",
"ty": "Compact<ReferendumIndex>"
}
],
"documentation": [
" Remove a referendum.",
"",
" The dispatch origin of this call must be _Root_.",
"",
" - `ref_index`: The index of the referendum to cancel.",
"",
" # <weight>",
" - `O(1)`.",
" # </weight>"
]
},
{
"name": "cancel_queued",
"arguments": [
{
"name": "which",
"ty": "ReferendumIndex"
}
],
"documentation": [
" Cancel a proposal queued for enactment.",
"",
" The dispatch origin of this call must be _Root_.",
"",
" - `which`: The index of the referendum to cancel.",
"",
" # <weight>",
" - One DB change.",
" # </weight>"
]
},
{
"name": "activate_proxy",
"arguments": [
{
"name": "proxy",
"ty": "T::AccountId"
}
],
"documentation": [
" Specify a proxy that is already open to us. Called by the stash.",
"",
" NOTE: Used to be called `set_proxy`.",
"",
" The dispatch origin of this call must be _Signed_.",
"",
" - `proxy`: The account that will be activated as proxy.",
"",
" # <weight>",
" - One extra DB entry.",
" # </weight>"
]
},
{
"name": "close_proxy",
"arguments": [],
"documentation": [
" Clear the proxy. Called by the proxy.",
"",
" NOTE: Used to be called `resign_proxy`.",
"",
" The dispatch origin of this call must be _Signed_.",
"",
" # <weight>",
" - One DB clear.",
" # </weight>"
]
},
{
"name": "deactivate_proxy",
"arguments": [
{
"name": "proxy",
"ty": "T::AccountId"
}
],
"documentation": [
" Deactivate the proxy, but leave open to this account. Called by the stash.",
"",
" The proxy must already be active.",
"",
" NOTE: Used to be called `remove_proxy`.",
"",
" The dispatch origin of this call must be _Signed_.",
"",
" - `proxy`: The account that will be deactivated as proxy.",
"",
" # <weight>",
" - One DB clear.",
" # </weight>"
]
},
{
"name": "delegate",
"arguments": [
{
"name": "to",
"ty": "T::AccountId"
},
{
"name": "conviction",
"ty": "Conviction"
},
{
"name": "balance",
"ty": "BalanceOf<T>"
}
],
"documentation": [
" 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>",
" # </weight>"
]
},
{
"name": "undelegate",
"arguments": [],
"documentation": [
" 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(1).",
" # </weight>"
]
},
{
"name": "clear_public_proposals",
"arguments": [],
"documentation": [
" Clears all public proposals.",
"",
" The dispatch origin of this call must be _Root_.",
"",
" # <weight>",
" - `O(1)`.",
" - One DB clear.",
" # </weight>"
]
},
{
"name": "note_preimage",
"arguments": [
{
"name": "encoded_proposal",
"ty": "Vec<u8>"
}
],
"documentation": [
" 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>",
" - Dependent on the size of `encoded_proposal` but protected by a",
" required deposit.",
" # </weight>"
]
},
{
"name": "note_imminent_preimage",
"arguments": [
{
"name": "encoded_proposal",
"ty": "Vec<u8>"
}
],
"documentation": [
" Register the preimage for an upcoming proposal. This requires the proposal to be",
" in the dispatch queue. No deposit is needed.",
"",
" The dispatch origin of this call must be _Signed_.",
"",
" - `encoded_proposal`: The preimage of a proposal.",
"",
" Emits `PreimageNoted`.",
"",
" # <weight>",
" - Dependent on the size of `encoded_proposal`.",
" # </weight>"
]
},
{
"name": "reap_preimage",
"arguments": [
{
"name": "proposal_hash",
"ty": "T::Hash"
}
],
"documentation": [
" 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.",
"",
" 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>",
" - One DB clear.",
" # </weight>"
]
},
{
"name": "unlock",
"arguments": [
{
"name": "target",
"ty": "T::AccountId"
}
],
"documentation": [
" 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(1)`.",
" # </weight>"
]
},
{
"name": "open_proxy",
"arguments": [
{
"name": "target",
"ty": "T::AccountId"
}
],
"documentation": [
" Become a proxy.",
"",
" This must be called prior to a later `activate_proxy`.",
"",
" Origin must be a Signed.",
"",
" - `target`: The account whose votes will later be proxied.",
"",
" `close_proxy` must be called before the account can be destroyed.",
"",
" # <weight>",
" - One extra DB entry.",
" # </weight>"
]
},
{
"name": "remove_vote",
"arguments": [
{
"name": "index",
"ty": "ReferendumIndex"
}
],
"documentation": [
" 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>"
]
},
{
"name": "remove_other_vote",
"arguments": [
{
"name": "target",
"ty": "T::AccountId"
},
{
"name": "index",
"ty": "ReferendumIndex"
}
],
"documentation": [
" 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>"
]
},
{
"name": "proxy_delegate",
"arguments": [
{
"name": "to",
"ty": "T::AccountId"
},
{
"name": "conviction",
"ty": "Conviction"
},
{
"name": "balance",
"ty": "BalanceOf<T>"
}
],
"documentation": [
" Delegate the voting power (with some given conviction) of a proxied 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 have",
" been set as the proxy account for `target`.",
"",
" - `target`: The account whole voting power shall be delegated and whose balance locked.",
" This 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>",
" # </weight>"
]
},
{
"name": "proxy_undelegate",
"arguments": [],
"documentation": [
" Undelegate the voting power of a proxied 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 a",
" proxy for some other account which is currently delegating.",
"",
" Emits `Undelegated`.",
"",
" # <weight>",
" - O(1).",
" # </weight>"
]
},
{
"name": "proxy_remove_vote",
"arguments": [
{
"name": "index",
"ty": "ReferendumIndex"
}
],
"documentation": [
" Remove a proxied vote for a referendum.",
"",
" Exactly equivalent to `remove_vote` except that it operates on the account that the",
" sender is a proxy for.",
"",
" The dispatch origin of this call must be _Signed_ and the signing account must be a",
" proxy for some other account which has a registered vote for the referendum of `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>"
]
}
],
"event": [
{
"name": "Proposed",
"arguments": [
"PropIndex",
"Balance"
],
"documentation": [
" A motion has been proposed by a public account."
]
},
{
"name": "Tabled",
"arguments": [
"PropIndex",
"Balance",
"Vec<AccountId>"
],
"documentation": [
" A public proposal has been tabled for referendum vote."
]
},
{
"name": "ExternalTabled",
"arguments": [],
"documentation": [
" An external proposal has been tabled."
]
},
{
"name": "Started",
"arguments": [
"ReferendumIndex",
"VoteThreshold"
],
"documentation": [
" A referendum has begun."
]
},
{
"name": "Passed",
"arguments": [
"ReferendumIndex"
],
"documentation": [
" A proposal has been approved by referendum."
]
},
{
"name": "NotPassed",
"arguments": [
"ReferendumIndex"
],
"documentation": [
" A proposal has been rejected by referendum."
]
},
{
"name": "Cancelled",
"arguments": [
"ReferendumIndex"
],
"documentation": [
" A referendum has been cancelled."
]
},
{
"name": "Executed",
"arguments": [
"ReferendumIndex",
"bool"
],
"documentation": [
" A proposal has been enacted."
]
},
{
"name": "Delegated",
"arguments": [
"AccountId",
"AccountId"
],
"documentation": [
" An account has delegated their vote to another account."
]
},
{
"name": "Undelegated",
"arguments": [
"AccountId"
],
"documentation": [
" An account has cancelled a previous delegation operation."
]
},
{
"name": "Vetoed",
"arguments": [
"AccountId",
"Hash",
"BlockNumber"
],
"documentation": [
" An external proposal has been vetoed."
]
},
{
"name": "PreimageNoted",
"arguments": [
"Hash",
"AccountId",
"Balance"
],
"documentation": [
" A proposal's preimage was noted, and the deposit taken."
]
},
{
"name": "PreimageUsed",
"arguments": [
"Hash",
"AccountId",
"Balance"
],
"documentation": [
" A proposal preimage was removed and used (the deposit was returned)."
]
},
{
"name": "PreimageInvalid",
"arguments": [
"Hash",
"ReferendumIndex"
],
"documentation": [
" A proposal could not be executed because its preimage was invalid."
]
},
{
"name": "PreimageMissing",
"arguments": [
"Hash",
"ReferendumIndex"
],
"documentation": [
" A proposal could not be executed because its preimage was missing."
]
},
{
"name": "PreimageReaped",
"arguments": [
"Hash",
"AccountId",
"Balance",
"AccountId"
],
"documentation": [
" A registered preimage was removed and the deposit collected by the reaper (last item)."
]
},
{
"name": "Unlocked",
"arguments": [
"AccountId"
],
"documentation": [
" An account has been unlocked successfully."
]
}
],
"constants": [
{
"name": "EnactmentPeriod",
"ty": "T::BlockNumber",
"value": [
0,
194,
1,
0
],
"documentation": [
" The minimum period of locking and the period between a proposal being approved and enacted.",
"",
" It should generally be a little more than the unstake period to ensure that",
" voting stakers have an opportunity to remove themselves from the system in the case where",
" they are on the losing side of a vote."
]
},
{
"name": "LaunchPeriod",
"ty": "T::BlockNumber",
"value": [
192,
137,
1,
0
],
"documentation": [
" How often (in blocks) new public referenda are launched."
]
},
{
"name": "VotingPeriod",
"ty": "T::BlockNumber",
"value": [
192,
137,
1,
0
],
"documentation": [
" How often (in blocks) to check for new votes."
]
},
{
"name": "MinimumDeposit",
"ty": "BalanceOf<T>",
"value": [
0,
16,
165,
212,
232,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"documentation": [
" The minimum amount to be used as a deposit for a public referendum proposal."
]
},
{
"name": "FastTrackVotingPeriod",
"ty": "T::BlockNumber",
"value": [
8,
7,
0,
0
],
"documentation": [
" Minimum voting period allowed for an emergency referendum."
]
},
{
"name": "CooloffPeriod",
"ty": "T::BlockNumber",
"value": [
192,
137,
1,
0
],
"documentation": [
" Period in blocks where an external proposal may not be re-submitted after being vetoed."
]
},
{
"name": "PreimageByteDeposit",
"ty": "BalanceOf<T>",
"value": [
0,
225,
245,
5,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"documentation": [
" The amount of balance that must be deposited per byte of preimage stored."
]
}
],
"errors": [
{
"name": "ValueLow",
"documentation": [
" Value too low"
]
},
{
"name": "ProposalMissing",
"documentation": [
" Proposal does not exist"
]
},
{
"name": "NotProxy",
"documentation": [
" Not a proxy"
]
},
{
"name": "BadIndex",
"documentation": [
" Unknown index"
]
},
{
"name": "AlreadyCanceled",
"documentation": [
" Cannot cancel the same proposal twice"
]
},
{
"name": "DuplicateProposal",
"documentation": [
" Proposal already made"
]
},
{
"name": "ProposalBlacklisted",
"documentation": [
" Proposal still blacklisted"
]
},
{
"name": "NotSimpleMajority",
"documentation": [
" Next external proposal not simple majority"
]
},
{
"name": "InvalidHash",
"documentation": [
" Invalid hash"
]
},
{
"name": "NoProposal",
"documentation": [
" No external proposal"
]
},
{
"name": "AlreadyVetoed",
"documentation": [
" Identity may not veto a proposal twice"
]
},
{
"name": "AlreadyProxy",
"documentation": [
" Already a proxy"
]
},
{
"name": "WrongProxy",
"documentation": [
" Wrong proxy"
]
},
{
"name": "NotDelegated",
"documentation": [
" Not delegated"
]
},
{
"name": "DuplicatePreimage",
"documentation": [
" Preimage already noted"
]
},
{
"name": "NotImminent",
"documentation": [
" Not imminent"
]
},
{
"name": "TooEarly",
"documentation": [
" Too early"
]
},
{
"name": "Imminent",
"documentation": [
" Imminent"
]
},
{
"name": "PreimageMissing",
"documentation": [
" Preimage not found"
]
},
{
"name": "ReferendumInvalid",
"documentation": [
" Vote given for invalid referendum"
]
},
{
"name": "PreimageInvalid",
"documentation": [
" Invalid preimage"
]
},
{
"name": "NoneWaiting",
"documentation": [
" No proposals waiting"
]
},
{
"name": "NotLocked",
"documentation": [
" The target account does not have a lock."
]
},
{
"name": "NotExpired",
"documentation": [
" The lock on the account to be unlocked has not yet expired."
]
},
{
"name": "NotOpen",
"documentation": [
" A proxy-pairing was attempted to an account that was not open."
]
},
{
"name": "WrongOpen",
"documentation": [
" A proxy-pairing was attempted to an account that was open to another account."
]
},
{
"name": "NotActive",
"documentation": [
" A proxy-de-pairing was attempted to an account that was not active."
]
},
{
"name": "NotVoter",
"documentation": [
" The given account did not vote on the referendum."
]
},
{
"name": "NoPermission",
"documentation": [
" The actor has no permission to conduct the action."
]
},
{
"name": "AlreadyDelegating",
"documentation": [
" The account is already delegating."
]
},
{
"name": "Overflow",
"documentation": [
" An unexpected integer overflow occurred."
]
},
{
"name": "Underflow",
"documentation": [
" An unexpected integer underflow occurred."
]
},
{
"name": "InsufficientFunds",
"documentation": [
" Too high a balance was provided that the account cannot afford."
]
},
{
"name": "NotDelegating",
"documentation": [
" The account is not currently delegating."
]
},
{
"name": "VotesExist",
"documentation": [
" The account currently has votes attached to it and the operation cannot succeed until",
" these are removed, either through `unvote` or `reap_vote`."
]
},
{
"name": "InstantNotAllowed",
"documentation": [
" The instant referendum origin is currently disallowed."
]
},
{
"name": "Nonsense",
"documentation": [
" Delegation to oneself makes no sense."
]
}
]
},
{
"name": "Council",
"storage": {
"prefix": "Instance1Collective",
"entries": [
{
"name": "Proposals",
"modifier": "Default",
"ty": {
"Plain": "Vec<T::Hash>"
},
"default": [
0
],
"documentation": [
" The hashes of the active proposals."
]
},
{
"name": "ProposalOf",
"modifier": "Optional",
"ty": {
"Map": {
"hasher": "Identity",
"key": "T::Hash",
"value": "<T as Trait<I>>::Proposal",
"unused": false
}
},
"default": [
0
],
"documentation": [
" Actual proposal for a given hash, if it's current."
]
},
{
"name": "Voting",
"modifier": "Optional",
"ty": {
"Map": {
"hasher": "Identity",
"key": "T::Hash",
"value": "Votes<T::AccountId, T::BlockNumber>",
"unused": false
}
},
"default": [
0
],
"documentation": [
" Votes on a given proposal, if it is ongoing."
]
},
{
"name": "ProposalCount",
"modifier": "Default",
"ty": {
"Plain": "u32"
},
"default": [
0,
0,
0,
0
],
"documentation": [
" Proposals so far."
]
},
{
"name": "Members",
"modifier": "Default",
"ty": {
"Plain": "Vec<T::AccountId>"
},
"default": [
0
],
"documentation": [
" The current members of the collective. This is stored sorted (just by value)."
]
},
{
"name": "Prime",
"modifier": "Optional",
"ty": {
"Plain": "T::AccountId"
},
"default": [
0
],
"documentation": [
" The member who provides the default vote for any other members that do not vote before",
" the timeout. If None, then no member has that privilege."
]
}
]
},
"calls": [
{
"name": "set_members",
"arguments": [
{
"name": "new_members",
"ty": "Vec<T::AccountId>"
},
{
"name": "prime",
"ty": "Option<T::AccountId>"
}
],
"documentation": [
" Set the collective's membership.",
"",
" - `new_members`: The new member list. Be nice to the chain and",
" - `prime`: The prime member whose vote sets the default.",
"",
" Requires root origin."
]
},
{
"name": "execute",
"arguments": [
{
"name": "proposal",
"ty": "Box<<T as Trait<I>>::Proposal>"
}
],
"documentation": [
" Dispatch a proposal from a member using the `Member` origin.",
"",
" Origin must be a member of the collective."
]
},
{
"name": "propose",
"arguments": [
{
"name": "threshold",
"ty": "Compact<MemberCount>"
},
{
"name": "proposal",
"ty": "Box<<T as Trait<I>>::Proposal>"
}
],
"documentation": [
" # <weight>",
" - Bounded storage reads and writes.",
" - Argument `threshold` has bearing on weight.",
" # </weight>"
]
},
{
"name": "vote",
"arguments": [
{
"name": "proposal",
"ty": "T::Hash"
},
{
"name": "index",
"ty": "Compact<ProposalIndex>"
},
{
"name": "approve",
"ty": "bool"
}
],
"documentation": [
" # <weight>",
" - Bounded storage read and writes.",
" - Will be slightly heavier if the proposal is approved / disapproved after the vote.",
" # </weight>"
]
},
{
"name": "close",
"arguments": [
{
"name": "proposal",
"ty": "T::Hash"
},
{
"name": "index",
"ty": "Compact<ProposalIndex>"
}
],
"documentation": [
" May be called by any signed account after the voting duration has ended in order to",
" finish voting and close the proposal.",
"",
" Abstentions are counted as rejections unless there is a prime member set and the prime",
" member cast an approval.",
"",
" - the weight of `proposal` preimage.",
" - up to three events deposited.",
" - one read, two removals, one mutation. (plus three static reads.)",
" - computation and i/o `O(P + L + M)` where:",
" - `M` is number of members,",
" - `P` is number of active proposals,",
" - `L` is the encoded length of `proposal` preimage."
]
}
],
"event": [
{
"name": "Proposed",
"arguments": [
"AccountId",
"ProposalIndex",
"Hash",
"MemberCount"
],
"documentation": [
" A motion (given hash) has been proposed (by given account) with a threshold (given",
" `MemberCount`)."
]
},
{
"name": "Voted",
"arguments": [
"AccountId",
"Hash",
"bool",
"MemberCount",
"MemberCount"
],
"documentation": [
" A motion (given hash) has been voted on by given account, leaving",
" a tally (yes votes and no votes given respectively as `MemberCount`)."
]
},
{
"name": "Approved",
"arguments": [
"Hash"
],
"documentation": [
" A motion was approved by the required threshold."
]
},
{
"name": "Disapproved",
"arguments": [
"Hash"
],
"documentation": [
" A motion was not approved by the required threshold."
]
},
{
"name": "Executed",
"arguments": [
"Hash",
"bool"
],
"documentation": [
" A motion was executed; `bool` is true if returned without error."
]
},
{
"name": "MemberExecuted",
"arguments": [
"Hash",
"bool"
],
"documentation": [
" A single member did some action; `bool` is true if returned without error."
]
},
{
"name": "Closed",
"arguments": [
"Hash",
"MemberCount",
"MemberCount"
],
"documentation": [
" A proposal was closed after its duration was up."
]
}
],
"constants": [],
"errors": [
{
"name": "NotMember",
"documentation": [
" Account is not a member"
]
},
{
"name": "DuplicateProposal",
"documentation": [
" Duplicate proposals not allowed"
]
},
{
"name": "ProposalMissing",
"documentation": [
" Proposal must exist"
]
},
{
"name": "WrongIndex",
"documentation": [
" Mismatched index"
]
},
{
"name": "DuplicateVote",
"documentation": [
" Duplicate vote ignored"
]
},
{
"name": "AlreadyInitialized",
"documentation": [
" Members are already initialized!"
]
},
{
"name": "TooEarly",
"documentation": [
" The close call is made too early, before the end of the voting."
]
}
]
},
{
"name": "TechnicalCommittee",
"storage": {
"prefix": "Instance2Collective",
"entries": [
{
"name": "Proposals",
"modifier": "Default",
"ty": {
"Plain": "Vec<T::Hash>"
},
"default": [
0
],
"documentation": [
" The hashes of the active proposals."
]
},
{
"name": "ProposalOf",
"modifier": "Optional",
"ty": {
"Map": {
"hasher": "Identity",
"key": "T::Hash",
"value": "<T as Trait<I>>::Proposal",
"unused": false
}
},
"default": [
0
],
"documentation": [
" Actual proposal for a given hash, if it's current."
]
},
{
"name": "Voting",
"modifier": "Optional",
"ty": {
"Map": {
"hasher": "Identity",
"key": "T::Hash",
"value": "Votes<T::AccountId, T::BlockNumber>",
"unused": false
}
},
"default": [
0
],
"documentation": [
" Votes on a given proposal, if it is ongoing."
]
},
{
"name": "ProposalCount",
"modifier": "Default",
"ty": {
"Plain": "u32"
},
"default": [
0,
0,
0,
0
],
"documentation": [
" Proposals so far."
]
},
{
"name": "Members",
"modifier": "Default",
"ty": {
"Plain": "Vec<T::AccountId>"
},
"default": [
0
],
"documentation": [
" The current members of the collective. This is stored sorted (just by value)."
]
},
{
"name": "Prime",
"modifier": "Optional",
"ty": {
"Plain": "T::AccountId"
},
"default": [
0
],
"documentation": [
" The member who provides the default vote for any other members that do not vote before",
" the timeout. If None, then no member has that privilege."
]
}
]
},
"calls": [
{
"name": "set_members",
"arguments": [
{
"name": "new_members",
"ty": "Vec<T::AccountId>"
},
{
"name": "prime",
"ty": "Option<T::AccountId>"
}
],
"documentation": [
" Set the collective's membership.",
"",
" - `new_members`: The new member list. Be nice to the chain and",
" - `prime`: The prime member whose vote sets the default.",
"",
" Requires root origin."
]
},
{
"name": "execute",
"arguments": [
{
"name": "proposal",
"ty": "Box<<T as Trait<I>>::Proposal>"
}
],
"documentation": [
" Dispatch a proposal from a member using the `Member` origin.",
"",
" Origin must be a member of the collective."
]
},
{
"name": "propose",
"arguments": [
{
"name": "threshold",
"ty": "Compact<MemberCount>"
},
{
"name": "proposal",
"ty": "Box<<T as Trait<I>>::Proposal>"
}
],
"documentation": [
" # <weight>",
" - Bounded storage reads and writes.",
" - Argument `threshold` has bearing on weight.",
" # </weight>"
]
},
{
"name": "vote",
"arguments": [
{
"name": "proposal",
"ty": "T::Hash"
},
{
"name": "index",
"ty": "Compact<ProposalIndex>"
},
{
"name": "approve",
"ty": "bool"
}
],
"documentation": [
" # <weight>",
" - Bounded storage read and writes.",
" - Will be slightly heavier if the proposal is approved / disapproved after the vote.",
" # </weight>"
]
},
{
"name": "close",
"arguments": [
{
"name": "proposal",
"ty": "T::Hash"
},
{
"name": "index",
"ty": "Compact<ProposalIndex>"
}
],
"documentation": [
" May be called by any signed account after the voting duration has ended in order to",
" finish voting and close the proposal.",
"",
" Abstentions are counted as rejections unless there is a prime member set and the prime",
" member cast an approval.",
"",
" - the weight of `proposal` preimage.",
" - up to three events deposited.",
" - one read, two removals, one mutation. (plus three static reads.)",
" - computation and i/o `O(P + L + M)` where:",
" - `M` is number of members,",
" - `P` is number of active proposals,",
" - `L` is the encoded length of `proposal` preimage."
]
}
],
"event": [
{
"name": "Proposed",
"arguments": [
"AccountId",
"ProposalIndex",
"Hash",
"MemberCount"
],
"documentation": [
" A motion (given hash) has been proposed (by given account) with a threshold (given",
" `MemberCount`)."
]
},
{
"name": "Voted",
"arguments": [
"AccountId",
"Hash",
"bool",
"MemberCount",
"MemberCount"
],
"documentation": [
" A motion (given hash) has been voted on by given account, leaving",
" a tally (yes votes and no votes given respectively as `MemberCount`)."
]
},
{
"name": "Approved",
"arguments": [
"Hash"
],
"documentation": [
" A motion was approved by the required threshold."
]
},
{
"name": "Disapproved",
"arguments": [
"Hash"
],
"documentation": [
" A motion was not approved by the required threshold."
]
},
{
"name": "Executed",
"arguments": [
"Hash",
"bool"
],
"documentation": [
" A motion was executed; `bool` is true if returned without error."
]
},
{
"name": "MemberExecuted",
"arguments": [
"Hash",
"bool"
],
"documentation": [
" A single member did some action; `bool` is true if returned without error."
]
},
{
"name": "Closed",
"arguments": [
"Hash",
"MemberCount",
"MemberCount"
],
"documentation": [
" A proposal was closed after its duration was up."
]
}
],
"constants": [],
"errors": [
{
"name": "NotMember",
"documentation": [
" Account is not a member"
]
},
{
"name": "DuplicateProposal",
"documentation": [
" Duplicate proposals not allowed"
]
},
{
"name": "ProposalMissing",
"documentation": [
" Proposal must exist"
]
},
{
"name": "WrongIndex",
"documentation": [
" Mismatched index"
]
},
{
"name": "DuplicateVote",
"documentation": [
" Duplicate vote ignored"
]
},
{
"name": "AlreadyInitialized",
"documentation": [
" Members are already initialized!"
]
},
{
"name": "TooEarly",
"documentation": [
" The close call is made too early, before the end of the voting."
]
}
]
},
{
"name": "ElectionsPhragmen",
"storage": {
"prefix": "PhragmenElection",
"entries": [
{
"name": "Members",
"modifier": "Default",
"ty": {
"Plain": "Vec<(T::AccountId, BalanceOf<T>)>"
},
"default": [
0
],
"documentation": [
" The current elected membership. Sorted based on account id."
]
},
{
"name": "RunnersUp",
"modifier": "Default",
"ty": {
"Plain": "Vec<(T::AccountId, BalanceOf<T>)>"
},
"default": [
0
],
"documentation": [
" The current runners_up. Sorted based on low to high merit (worse to best runner)."
]
},
{
"name": "ElectionRounds",
"modifier": "Default",
"ty": {
"Plain": "u32"
},
"default": [
0,
0,
0,
0
],
"documentation": [
" The total number of vote rounds that have happened, excluding the upcoming one."
]
},
{
"name": "VotesOf",
"modifier": "Default",
"ty": {
"Map": {
"hasher": "Twox64Concat",
"key": "T::AccountId",
"value": "Vec<T::AccountId>",
"unused": false
}
},
"default": [
0
],
"documentation": [
" Votes of a particular voter, with the round index of the votes."
]
},
{
"name": "StakeOf",
"modifier": "Default",
"ty": {
"Map": {
"hasher": "Twox64Concat",
"key": "T::AccountId",
"value": "BalanceOf<T>",
"unused": false
}
},
"default": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"documentation": [
" Locked stake of a voter."
]
},
{
"name": "Candidates",
"modifier": "Default",
"ty": {
"Plain": "Vec<T::AccountId>"
},
"default": [
0
],
"documentation": [
" The present candidate list. Sorted based on account-id. A current member or a runner can",
" never enter this vector and is always implicitly assumed to be a candidate."
]
}
]
},
"calls": [
{
"name": "vote",
"arguments": [
{
"name": "votes",
"ty": "Vec<T::AccountId>"
},
{
"name": "value",
"ty": "Compact<BalanceOf<T>>"
}
],
"documentation": [
" Vote for a set of candidates for the upcoming round of election.",
"",
" The `votes` should:",
" - not be empty.",
" - be less than the number of candidates.",
"",
" Upon voting, `value` units of `who`'s balance is locked and a bond amount is reserved.",
" It is the responsibility of the caller to not place all of their balance into the lock",
" and keep some for further transactions.",
"",
" # <weight>",
" #### State",
" Reads: O(1)",
" Writes: O(V) given `V` votes. V is bounded by 16.",
" # </weight>"
]
},
{
"name": "remove_voter",
"arguments": [],
"documentation": [
" Remove `origin` as a voter. This removes the lock and returns the bond.",
"",
" # <weight>",
" #### State",
" Reads: O(1)",
" Writes: O(1)",
" # </weight>"
]
},
{
"name": "report_defunct_voter",
"arguments": [
{
"name": "target",
"ty": "<T::Lookup as StaticLookup>::Source"
}
],
"documentation": [
" Report `target` for being an defunct voter. In case of a valid report, the reporter is",
" rewarded by the bond amount of `target`. Otherwise, the reporter itself is removed and",
" their bond is slashed.",
"",
" A defunct voter is defined to be:",
" - a voter whose current submitted votes are all invalid. i.e. all of them are no",
" longer a candidate nor an active member.",
"",
" # <weight>",
" #### State",
" Reads: O(NLogM) given M current candidates and N votes for `target`.",
" Writes: O(1)",
" # </weight>"
]
},
{
"name": "submit_candidacy",
"arguments": [],
"documentation": [
" Submit oneself for candidacy.",
"",
" A candidate will either:",
" - Lose at the end of the term and forfeit their deposit.",
" - Win and become a member. Members will eventually get their stash back.",
" - Become a runner-up. Runners-ups are reserved members in case one gets forcefully",
" removed.",
"",
" # <weight>",
" #### State",
" Reads: O(LogN) Given N candidates.",
" Writes: O(1)",
" # </weight>"
]
},
{
"name": "renounce_candidacy",
"arguments": [],
"documentation": [
" 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 bond is",
" unreserved, returned and origin is removed as a candidate.",
" - `origin` is a current runner up. In this case, the bond is unreserved, returned and",
" origin is removed as a runner.",
" - `origin` is a current member. In this case, the bond is unreserved and origin is",
" removed as a member, consequently not being a candidate for the next round anymore.",
" Similar to [`remove_voter`], if replacement runners exists, they are immediately used."
]
},
{
"name": "remove_member",
"arguments": [
{
"name": "who",
"ty": "<T::Lookup as StaticLookup>::Source"
}
],
"documentation": [
" 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 round is started.",
"",
" Note that this does not affect the designated block number of the next election.",
"",
" # <weight>",
" #### State",
" Reads: O(do_phragmen)",
" Writes: O(do_phragmen)",
" # </weight>"
]
}
],
"event": [
{
"name": "NewTerm",
"arguments": [
"Vec<(AccountId, Balance)>"
],
"documentation": [
" A new term with new members. This indicates that enough candidates existed, not that",
" enough have has been elected. The inner value must be examined for this purpose."
]
},
{
"name": "EmptyTerm",
"arguments": [],
"documentation": [
" No (or not enough) candidates existed for this round."
]
},
{
"name": "MemberKicked",
"arguments": [
"AccountId"
],
"documentation": [
" A member has been removed. This should always be followed by either `NewTerm` ot",
" `EmptyTerm`."
]
},
{
"name": "MemberRenounced",
"arguments": [
"AccountId"
],
"documentation": [
" A member has renounced their candidacy."
]
},
{
"name": "VoterReported",
"arguments": [
"AccountId",
"AccountId",
"bool"
],
"documentation": [
" A voter (first element) was reported (byt the second element) with the the report being",
" successful or not (third element)."
]
}
],
"constants": [
{
"name": "CandidacyBond",
"ty": "BalanceOf<T>",
"value": [
0,
16,
165,
212,
232,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"documentation": []
},
{
"name": "VotingBond",
"ty": "BalanceOf<T>",
"value": [
0,
116,
59,
164,
11,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"documentation": []
},
{
"name": "DesiredMembers",
"ty": "u32",
"value": [
13,
0,
0,
0
],
"documentation": []
},
{
"name": "DesiredRunnersUp",
"ty": "u32",
"value": [
7,
0,
0,
0
],
"documentation": []
},
{
"name": "TermDuration",
"ty": "T::BlockNumber",
"value": [
64,
56,
0,
0
],
"documentation": []
}
],
"errors": [
{
"name": "UnableToVote",
"documentation": [
" Cannot vote when no candidates or members exist."
]
},
{
"name": "NoVotes",
"documentation": [
" Must vote for at least one candidate."
]
},
{
"name": "TooManyVotes",
"documentation": [
" Cannot vote more than candidates."
]
},
{
"name": "MaximumVotesExceeded",
"documentation": [
" Cannot vote more than maximum allowed."
]
},
{
"name": "LowBalance",
"documentation": [
" Cannot vote with stake less than minimum balance."
]
},
{
"name": "UnableToPayBond",
"documentation": [
" Voter can not pay voting bond."
]
},
{
"name": "MustBeVoter",
"documentation": [
" Must be a voter."
]
},
{
"name": "ReportSelf",
"documentation": [
" Cannot report self."
]
},
{
"name": "DuplicatedCandidate",
"documentation": [
" Duplicated candidate submission."
]
},
{
"name": "MemberSubmit",
"documentation": [
" Member cannot re-submit candidacy."
]
},
{
"name": "RunnerSubmit",
"documentation": [
" Runner cannot re-submit candidacy."
]
},
{
"name": "InsufficientCandidateFunds",
"documentation": [
" Candidate does not have enough funds."
]
},
{
"name": "InvalidOrigin",
"documentation": [
" Origin is not a candidate, member or a runner up."
]
},
{
"name": "NotMember",
"documentation": [
" Not a member."
]
}
]
},
{
"name": "TechnicalMembership",
"storage": {
"prefix": "Instance1Membership",
"entries": [
{
"name": "Members",
"modifier": "Default",
"ty": {
"Plain": "Vec<T::AccountId>"
},
"default": [
0
],
"documentation": [
" The current membership, stored as an ordered Vec."
]
},
{
"name": "Prime",
"modifier": "Optional",
"ty": {
"Plain": "T::AccountId"
},
"default": [
0
],
"documentation": [
" The current prime member, if one exists."
]
}
]
},
"calls": [
{
"name": "add_member",
"arguments": [
{
"name": "who",
"ty": "T::AccountId"
}
],
"documentation": [
" Add a member `who` to the set.",
"",
" May only be called from `AddOrigin` or root."
]
},
{
"name": "remove_member",
"arguments": [
{
"name": "who",
"ty": "T::AccountId"
}
],
"documentation": [
" Remove a member `who` from the set.",
"",
" May only be called from `RemoveOrigin` or root."
]
},
{
"name": "swap_member",
"arguments": [
{
"name": "remove",
"ty": "T::AccountId"
},
{
"name": "add",
"ty": "T::AccountId"
}
],
"documentation": [
" Swap out one member `remove` for another `add`.",
"",
" May only be called from `SwapOrigin` or root.",
"",
" Prime membership is *not* passed from `remove` to `add`, if extant."
]
},
{
"name": "reset_members",
"arguments": [
{
"name": "members",
"ty": "Vec<T::AccountId>"
}
],
"documentation": [
" Change the membership to a new set, disregarding the existing membership. Be nice and",
" pass `members` pre-sorted.",
"",
" May only be called from `ResetOrigin` or root."
]
},
{
"name": "change_key",
"arguments": [
{
"name": "new",
"ty": "T::AccountId"
}
],
"documentation": [
" Swap out the sending member for some other key `new`.",
"",
" May only be called from `Signed` origin of a current member.",
"",
" Prime membership is passed from the origin account to `new`, if extant."
]
},
{
"name": "set_prime",
"arguments": [
{
"name": "who",
"ty": "T::AccountId"
}
],
"documentation": [
" Set the prime member. Must be a current member."
]
},
{
"name": "clear_prime",
"arguments": [],
"documentation": [
" Remove the prime member if it exists."
]
}
],
"event": [
{
"name": "MemberAdded",
"arguments": [],
"documentation": [
" The given member was added; see the transaction for who."
]
},
{
"name": "MemberRemoved",
"arguments": [],
"documentation": [
" The given member was removed; see the transaction for who."
]
},
{
"name": "MembersSwapped",
"arguments": [],
"documentation": [
" Two members were swapped; see the transaction for who."
]
},
{
"name": "MembersReset",
"arguments": [],
"documentation": [
" The membership was reset; see the transaction for who the new set is."
]
},
{
"name": "KeyChanged",
"arguments": [],
"documentation": [
" One of the members' keys changed."
]
},
{
"name": "Dummy",
"arguments": [
"sp_std::marker::PhantomData<(AccountId, Event)>"
],
"documentation": [
" Phantom member, never used."
]
}
],
"constants": [],
"errors": []
},
{
"name": "Treasury",
"storage": {
"prefix": "Treasury",
"entries": [
{
"name": "ProposalCount",
"modifier": "Default",
"ty": {
"Plain": "ProposalIndex"
},
"default": [
0,
0,
0,
0
],
"documentation": [
" Number of proposals that have been made."
]
},
{
"name": "Proposals",
"modifier": "Optional",
"ty": {
"Map": {
"hasher": "Twox64Concat",
"key": "ProposalIndex",
"value": "Proposal<T::AccountId, BalanceOf<T>>",
"unused": false
}
},
"default": [
0
],
"documentation": [
" Proposals that have been made."
]
},
{
"name": "Approvals",
"modifier": "Default",
"ty": {
"Plain": "Vec<ProposalIndex>"
},
"default": [
0
],
"documentation": [
" Proposal indices that have been approved but not yet awarded."
]
},
{
"name": "Tips",
"modifier": "Optional",
"ty": {
"Map": {
"hasher": "Twox64Concat",
"key": "T::Hash",
"value": "OpenTip<T::AccountId, BalanceOf<T>, T::BlockNumber, T::Hash>",
"unused": false
}
},
"default": [
0
],
"documentation": [
" Tips that are not yet completed. Keyed by the hash of `(reason, who)` from the value.",
" This has the insecure enumerable hash function since the key itself is already",
" guaranteed to be a secure hash."
]
},
{
"name": "Reasons",
"modifier": "Optional",
"ty": {
"Map": {
"hasher": "Identity",
"key": "T::Hash",
"value": "Vec<u8>",
"unused": false
}
},
"default": [
0
],
"documentation": [
" Simple preimage lookup from the reason's hash to the original data. Again, has an",
" insecure enumerable hash since the key is guaranteed to be the result of a secure hash."
]
}
]
},
"calls": [
{
"name": "propose_spend",
"arguments": [
{
"name": "value",
"ty": "Compact<BalanceOf<T>>"
},
{
"name": "beneficiary",
"ty": "<T::Lookup as StaticLookup>::Source"
}
],
"documentation": [
" 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>",
" - O(1).",
" - Limited storage reads.",
" - One DB change, one extra DB entry.",
" # </weight>"
]
},
{
"name": "reject_proposal",
"arguments": [
{
"name": "proposal_id",
"ty": "Compact<ProposalIndex>"
}
],
"documentation": [
" Reject a proposed spend. The original deposit will be slashed.",
"",
" # <weight>",
" - O(1).",
" - Limited storage reads.",
" - One DB clear.",
" # </weight>"
]
},
{
"name": "approve_proposal",
"arguments": [
{
"name": "proposal_id",
"ty": "Compact<ProposalIndex>"
}
],
"documentation": [
" Approve a proposal. At a later time, the proposal will be allocated to the beneficiary",
" and the original deposit will be returned.",
"",
" # <weight>",
" - O(1).",
" - Limited storage reads.",
" - One DB change.",
" # </weight>"
]
},
{
"name": "report_awesome",
"arguments": [
{
"name": "reason",
"ty": "Vec<u8>"
},
{
"name": "who",
"ty": "T::AccountId"
}
],
"documentation": [
" 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",
" `TipReportDepositPerByte` 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>",
" - `O(R)` where `R` length of `reason`.",
" - One balance operation.",
" - One storage mutation (codec `O(R)`).",
" - One event.",
" # </weight>"
]
},
{
"name": "retract_tip",
"arguments": [
{
"name": "hash",
"ty": "T::Hash"
}
],
"documentation": [
" 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>",
" - `O(T)`",
" - One balance operation.",
" - Two storage removals (one read, codec `O(T)`).",
" - One event.",
" # </weight>"
]
},
{
"name": "tip_new",
"arguments": [
{
"name": "reason",
"ty": "Vec<u8>"
},
{
"name": "who",
"ty": "T::AccountId"
},
{
"name": "tip_value",
"ty": "BalanceOf<T>"
}
],
"documentation": [
" 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>",
" - `O(R + T)` where `R` length of `reason`, `T` is the number of tippers. `T` is",
" naturally capped as a membership set, `R` is limited through transaction-size.",
" - Two storage insertions (codecs `O(R)`, `O(T)`), one read `O(1)`.",
" - One event.",
" # </weight>"
]
},
{
"name": "tip",
"arguments": [
{
"name": "hash",
"ty": "T::Hash"
},
{
"name": "tip_value",
"ty": "BalanceOf<T>"
}
],
"documentation": [
" 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>",
" - `O(T)`",
" - One storage mutation (codec `O(T)`), one storage read `O(1)`.",
" - Up to one event.",
" # </weight>"
]
},
{
"name": "close_tip",
"arguments": [
{
"name": "hash",
"ty": "T::Hash"
}
],
"documentation": [
" 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>",
" - `O(T)`",
" - One storage retrieval (codec `O(T)`) and two removals.",
" - Up to three balance operations.",
" # </weight>"
]
}
],
"event": [
{
"name": "Proposed",
"arguments": [
"ProposalIndex"
],
"documentation": [
" New proposal."
]
},
{
"name": "Spending",
"arguments": [
"Balance"
],
"documentation": [
" We have ended a spend period and will now allocate funds."
]
},
{
"name": "Awarded",
"arguments": [
"ProposalIndex",
"Balance",
"AccountId"
],
"documentation": [
" Some funds have been allocated."
]
},
{
"name": "Rejected",
"arguments": [
"ProposalIndex",
"Balance"
],
"documentation": [
" A proposal was rejected; funds were slashed."
]
},
{
"name": "Burnt",
"arguments": [
"Balance"
],
"documentation": [
" Some of our funds have been burnt."
]
},
{
"name": "Rollover",
"arguments": [
"Balance"
],
"documentation": [
" Spending has finished; this is the amount that rolls over until next spend."
]
},
{
"name": "Deposit",
"arguments": [
"Balance"
],
"documentation": [
" Some funds have been deposited."
]
},
{
"name": "NewTip",
"arguments": [
"Hash"
],
"documentation": [
" A new tip suggestion has been opened."
]
},
{
"name": "TipClosing",
"arguments": [
"Hash"
],
"documentation": [
" A tip suggestion has reached threshold and is closing."
]
},
{
"name": "TipClosed",
"arguments": [
"Hash",
"AccountId",
"Balance"
],
"documentation": [
" A tip suggestion has been closed."
]
},
{
"name": "TipRetracted",
"arguments": [
"Hash"
],
"documentation": [
" A tip suggestion has been retracted."
]
}
],
"constants": [
{
"name": "ProposalBond",
"ty": "Permill",
"value": [
80,
195,
0,
0
],
"documentation": [
" Fraction of a proposal's value that should be bonded in order to place the proposal.",
" An accepted proposal gets these back. A rejected proposal does not."
]
},
{
"name": "ProposalBondMinimum",
"ty": "BalanceOf<T>",
"value": [
0,
64,
229,
156,
48,
18,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"documentation": [
" Minimum amount of funds that should be placed in a deposit for making a proposal."
]
},
{
"name": "SpendPeriod",
"ty": "T::BlockNumber",
"value": [
128,
81,
1,
0
],
"documentation": [
" Period between successive spends."
]
},
{
"name": "Burn",
"ty": "Permill",
"value": [
0,
0,
0,
0
],
"documentation": [
" Percentage of spare funds (if any) that are burnt per spend period."
]
},
{
"name": "TipCountdown",
"ty": "T::BlockNumber",
"value": [
64,
56,
0,
0
],
"documentation": [
" The period for which a tip remains open after is has achieved threshold tippers."
]
},
{
"name": "TipFindersFee",
"ty": "Percent",
"value": [
20
],
"documentation": [
" The amount of the final tip which goes to the original reporter of the tip."
]
},
{
"name": "TipReportDepositBase",
"ty": "BalanceOf<T>",
"value": [
0,
16,
165,
212,
232,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"documentation": [
" The amount held on deposit for placing a tip report."
]
},
{
"name": "TipReportDepositPerByte",
"ty": "BalanceOf<T>",
"value": [
0,
228,
11,
84,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"documentation": [
" The amount held on deposit per byte within the tip report reason."
]
}
],
"errors": [
{
"name": "InsufficientProposersBalance",
"documentation": [
" Proposer's balance is too low."
]
},
{
"name": "InvalidProposalIndex",
"documentation": [
" No proposal at that index."
]
},
{
"name": "ReasonTooBig",
"documentation": [
" The reason given is just too big."
]
},
{
"name": "AlreadyKnown",
"documentation": [
" The tip was already found/started."
]
},
{
"name": "UnknownTip",
"documentation": [
" The tip hash is unknown."
]
},
{
"name": "NotFinder",
"documentation": [
" The account attempting to retract the tip is not the finder of the tip."
]
},
{
"name": "StillOpen",
"documentation": [
" The tip cannot be claimed/closed because there are not enough tippers yet."
]
},
{
"name": "Premature",
"documentation": [
" The tip cannot be claimed/closed because it's still in the countdown period."
]
}
]
},
{
"name": "Claims",
"storage": {
"prefix": "Claims",
"entries": [
{
"name": "Claims",
"modifier": "Optional",
"ty": {
"Map": {
"hasher": "Identity",
"key": "EthereumAddress",
"value": "BalanceOf<T>",
"unused": false
}
},
"default": [
0
],
"documentation": []
},
{
"name": "Total",
"modifier": "Default",
"ty": {
"Plain": "BalanceOf<T>"
},
"default": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"documentation": []
},
{
"name": "Vesting",
"modifier": "Optional",
"ty": {
"Map": {
"hasher": "Identity",
"key": "EthereumAddress",
"value": "(BalanceOf<T>, BalanceOf<T>, T::BlockNumber)",
"unused": false
}
},
"default": [
0
],
"documentation": [
" Vesting schedule for a claim.",
" First balance is the total amount that should be held for vesting.",
" Second balance is how much should be unlocked per block.",
" The block number is when the vesting should start."
]
}
]
},
"calls": [
{
"name": "claim",
"arguments": [
{
"name": "dest",
"ty": "T::AccountId"
},
{
"name": "ethereum_signature",
"ty": "EcdsaSignature"
}
],
"documentation": [
" Make a claim to collect your DOTs.",
"",
" The dispatch origin for this call must be _None_.",
"",
" Unsigned Validation:",
" A call to claim is deemed valid if the signature provided matches",
" the expected signed message of:",
"",
" > Ethereum Signed Message:",
" > (configured prefix string)(address)",
"",
" and `address` matches the `dest` account.",
"",
" Parameters:",
" - `dest`: The destination account to payout the claim.",
" - `ethereum_signature`: The signature of an ethereum signed message",
" matching the format described above.",
"",
" <weight>",
" The weight of this call is invariant over the input parameters.",
" - One `eth_recover` operation which involves a keccak hash and a",
" ecdsa recover.",
" - Three storage reads to check if a claim exists for the user, to",
" get the current pot size, to see if there exists a vesting schedule.",
" - Up to one storage write for adding a new vesting schedule.",
" - One `deposit_creating` Currency call.",
" - One storage write to update the total.",
" - Two storage removals for vesting and claims information.",
" - One deposit event.",
"",
" Total Complexity: O(1)",
" </weight>"
]
},
{
"name": "mint_claim",
"arguments": [
{
"name": "who",
"ty": "EthereumAddress"
},
{
"name": "value",
"ty": "BalanceOf<T>"
},
{
"name": "vesting_schedule",
"ty": "Option<(BalanceOf<T>, BalanceOf<T>, T::BlockNumber)>"
}
],
"documentation": [
" Mint a new claim to collect DOTs.",
"",
" The dispatch origin for this call must be _Root_.",
"",
" Parameters:",
" - `who`: The Ethereum address allowed to collect this claim.",
" - `value`: The number of DOTs that will be claimed.",
" - `vesting_schedule`: An optional vesting schedule for these DOTs.",
"",
" <weight>",
" The weight of this call is invariant over the input parameters.",
" - One storage mutate to increase the total claims available.",
" - One storage write to add a new claim.",
" - Up to one storage write to add a new vesting schedule.",
"",
" Total Complexity: O(1)",
" </weight>"
]
}
],
"event": [
{
"name": "Claimed",
"arguments": [
"AccountId",
"EthereumAddress",
"Balance"
],
"documentation": [
" Someone claimed some DOTs."
]
}
],
"constants": [
{
"name": "Prefix",
"ty": "&[u8]",
"value": [
124,
80,
97,
121,
32,
75,
83,
77,
115,
32,
116,
111,
32,
116,
104,
101,
32,
75,
117,
115,
97,
109,
97,
32,
97,
99,
99,
111,
117,
110,
116,
58
],
"documentation": [
" The Prefix that is used in signed Ethereum messages for this network"
]
}
],
"errors": [
{
"name": "InvalidEthereumSignature",
"documentation": [
" Invalid Ethereum signature."
]
},
{
"name": "SignerHasNoClaim",
"documentation": [
" Ethereum address has no claim."
]
},
{
"name": "DestinationVesting",
"documentation": [
" The destination is already vesting and cannot be the target of a further claim."
]
},
{
"name": "PotUnderflow",
"documentation": [
" There's not enough in the pot to pay out some unvested amount. Generally implies a logic",
" error."
]
}
]
},
{
"name": "Parachains",
"storage": {
"prefix": "Parachains",
"entries": [
{
"name": "Authorities",
"modifier": "Default",
"ty": {
"Plain": "Vec<ValidatorId>"
},
"default": [
0
],
"documentation": [
" All authorities' keys at the moment."
]
},
{
"name": "Code",
"modifier": "Optional",
"ty": {
"Map": {
"hasher": "Twox64Concat",
"key": "ParaId",
"value": "Vec<u8>",
"unused": false
}
},
"default": [
0
],
"documentation": [
" The parachains registered at present."
]
},
{
"name": "Heads",
"modifier": "Optional",
"ty": {
"Map": {
"hasher": "Twox64Concat",
"key": "ParaId",
"value": "Vec<u8>",
"unused": false
}
},
"default": [
0
],
"documentation": [
" The heads of the parachains registered at present."
]
},
{
"name": "RelayDispatchQueue",
"modifier": "Default",
"ty": {
"Map": {
"hasher": "Twox64Concat",
"key": "ParaId",
"value": "Vec<UpwardMessage>",
"unused": false
}
},
"default": [
0
],
"documentation": [
" Messages ready to be dispatched onto the relay chain. It is subject to",
" `MAX_MESSAGE_COUNT` and `WATERMARK_MESSAGE_SIZE`."
]
},
{
"name": "RelayDispatchQueueSize",
"modifier": "Default",
"ty": {
"Map": {
"hasher": "Twox64Concat",
"key": "ParaId",
"value": "(u32, u32)",
"unused": false
}
},
"default": [
0,
0,
0,
0,
0,
0,
0,
0
],
"documentation": [
" Size of the dispatch queues. Separated from actual data in order to avoid costly",
" decoding when checking receipt validity. First item in tuple is the count of messages",
"\tsecond if the total length (in bytes) of the message payloads."
]
},
{
"name": "NeedsDispatch",
"modifier": "Default",
"ty": {
"Plain": "Vec<ParaId>"
},
"default": [
0
],
"documentation": [
" The ordered list of ParaIds that have a `RelayDispatchQueue` entry."
]
},
{
"name": "DidUpdate",
"modifier": "Optional",
"ty": {
"Plain": "Vec<ParaId>"
},
"default": [
0
],
"documentation": [
" `Some` if the parachain heads get updated in this block, along with the parachain IDs",
" that did update. Ordered in the same way as `registrar::Active` (i.e. by ParaId).",
"",
" `None` if not yet updated."
]
}
]
},
"calls": [
{
"name": "set_heads",
"arguments": [
{
"name": "heads",
"ty": "Vec<AttestedCandidate>"
}
],
"documentation": [
" Provide candidate receipts for parachains, in ascending order by id."
]
}
],
"event": null,
"constants": [],
"errors": [
{
"name": "TooManyHeadUpdates",
"documentation": [
" Parachain heads must be updated only once in the block."
]
},
{
"name": "TooManyParaCandidates",
"documentation": [
" Too many parachain candidates."
]
},
{
"name": "HeadsOutOfOrder",
"documentation": [
" Proposed heads must be ascending order by parachain ID without duplicate."
]
},
{
"name": "UnregisteredPara",
"documentation": [
" Candidate is for an unregistered parachain."
]
},
{
"name": "InvalidCollator",
"documentation": [
" Invalid collator."
]
},
{
"name": "QueueFull",
"documentation": [
" The message queue is full. Messages will be added when there is space."
]
},
{
"name": "InvalidMessageOrigin",
"documentation": [
" The message origin is invalid."
]
},
{
"name": "NoValidatorGroup",
"documentation": [
" No validator group for parachain."
]
},
{
"name": "NotEnoughValidityVotes",
"documentation": [
" Not enough validity votes for candidate."
]
},
{
"name": "VotesExceedsAuthorities",
"documentation": [
" The number of attestations exceeds the number of authorities."
]
},
{
"name": "WrongValidatorAttesting",
"documentation": [
" Attesting validator not on this chain's validation duty."
]
},
{
"name": "InvalidSignature",
"documentation": [
" Invalid signature from attester."
]
},
{
"name": "UntaggedVotes",
"documentation": [
" Extra untagged validity votes along with candidate."
]
},
{
"name": "ParentMismatch",
"documentation": [
" Wrong parent head for parachain receipt."
]
},
{
"name": "HeadDataTooLarge",
"documentation": [
" Head data was too large."
]
},
{
"name": "CannotPayFees",
"documentation": [
" Para does not have enough balance to pay fees."
]
},
{
"name": "UnexpectedRelayParent",
"documentation": [
" Unexpected relay-parent for a candidate receipt."
]
}
]
},
{
"name": "Attestations",
"storage": {
"prefix": "Attestations",
"entries": [
{
"name": "RecentParaBlocks",
"modifier": "Optional",
"ty": {
"Map": {
"hasher": "Twox64Concat",
"key": "T::BlockNumber",
"value": "IncludedBlocks<T>",
"unused": false
}
},
"default": [
0
],
"documentation": [
" A mapping from modular block number (n % AttestationPeriod)",
" to session index and the list of candidate hashes."
]
},
{
"name": "ParaBlockAttestations",
"modifier": "Optional",
"ty": {
"DoubleMap": {
"hasher": "Twox64Concat",
"key1": "T::BlockNumber",
"key2": "Hash",
"value": "BlockAttestations<T>",
"key2_hasher": "Identity"
}
},
"default": [
0
],
"documentation": [
" Attestations on a recent parachain block."
]
},
{
"name": "DidUpdate",
"modifier": "Default",
"ty": {
"Plain": "bool"
},
"default": [
0
],
"documentation": []
}
]
},
"calls": [
{
"name": "more_attestations",
"arguments": [
{
"name": "_more",
"ty": "MoreAttestations"
}
],
"documentation": [
" Provide candidate receipts for parachains, in ascending order by id."
]
}
],
"event": null,
"constants": [],
"errors": [
{
"name": "TooManyAttestations",
"documentation": [
" More attestations can be added only once in a block."
]
}
]
},
{
"name": "Slots",
"storage": {
"prefix": "Slots",
"entries": [
{
"name": "AuctionCounter",
"modifier": "Default",
"ty": {
"Plain": "AuctionIndex"
},
"default": [
0,
0,
0,
0
],
"documentation": [
" The number of auctions that have been started so far."
]
},
{
"name": "ManagedIds",
"modifier": "Default",
"ty": {
"Plain": "Vec<ParaId>"
},
"default": [
0
],
"documentation": [
" Ordered list of all `ParaId` values that are managed by this module. This includes",
" chains that are not yet deployed (but have won an auction in the future)."
]
},
{
"name": "Deposits",
"modifier": "Default",
"ty": {
"Map": {
"hasher": "Twox64Concat",
"key": "ParaId",
"value": "Vec<BalanceOf<T>>",
"unused": false
}
},
"default": [
0
],
"documentation": [
" Various amounts on deposit for each parachain. An entry in `ManagedIds` implies a non-",
" default entry here.",
"",
" The actual amount locked on its behalf at any time is the maximum item in this list. The",
" first item in the list is the amount locked for the current Lease Period. Following",
" items are for the subsequent lease periods.",
"",
" The default value (an empty list) implies that the parachain no longer exists (or never",
" existed) as far as this module is concerned.",
"",
" If a parachain doesn't exist *yet* but is scheduled to exist in the future, then it",
" will be left-padded with one or more zeroes to denote the fact that nothing is held on",
" deposit for the non-existent chain currently, but is held at some point in the future."
]
},
{
"name": "AuctionInfo",
"modifier": "Optional",
"ty": {
"Plain": "(LeasePeriodOf<T>, T::BlockNumber)"
},
"default": [
0
],
"documentation": [
" Information relating to the current auction, if there is one.",
"",
" The first item in the tuple is the lease period index that the first of the four",
" contiguous lease periods on auction is for. The second is the block number when the",
" auction will \"begin to end\", i.e. the first block of the Ending Period of the auction."
]
},
{
"name": "Winning",
"modifier": "Optional",
"ty": {
"Map": {
"hasher": "Twox64Concat",
"key": "T::BlockNumber",
"value": "WinningData<T>",
"unused": false
}
},
"default": [
0
],
"documentation": [
" The winning bids for each of the 10 ranges at each block in the final Ending Period of",
" the current auction. The map's key is the 0-based index into the Ending Period. The",
" first block of the ending period is 0; the last is `EndingPeriod - 1`."
]
},
{
"name": "ReservedAmounts",
"modifier": "Optional",
"ty": {
"Map": {
"hasher": "Twox64Concat",
"key": "Bidder<T::AccountId>",
"value": "BalanceOf<T>",
"unused": false
}
},
"default": [
0
],
"documentation": [
" Amounts currently reserved in the accounts of the bidders currently winning",
" (sub-)ranges."
]
},
{
"name": "OnboardQueue",
"modifier": "Default",
"ty": {
"Map": {
"hasher": "Twox64Concat",
"key": "LeasePeriodOf<T>",
"value": "Vec<ParaId>",
"unused": false
}
},
"default": [
0
],
"documentation": [
" The set of Para IDs that have won and need to be on-boarded at an upcoming lease-period.",
" This is cleared out on the first block of the lease period."
]
},
{
"name": "Onboarding",
"modifier": "Optional",
"ty": {
"Map": {
"hasher": "Twox64Concat",
"key": "ParaId",
"value": "(LeasePeriodOf<T>, IncomingParachain<T::AccountId, T::Hash>)",
"unused": false
}
},
"default": [
0
],
"documentation": [
" The actual on-boarding information. Only exists when one of the following is true:",
" - It is before the lease period that the parachain should be on-boarded.",
" - The full on-boarding information has not yet been provided and the parachain is not",
" yet due to be off-boarded."
]
},
{
"name": "Offboarding",
"modifier": "Default",
"ty": {
"Map": {
"hasher": "Twox64Concat",
"key": "ParaId",
"value": "T::AccountId",
"unused": false
}
},
"default": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"documentation": [
" Off-boarding account; currency held on deposit for the parachain gets placed here if the",
" parachain gets off-boarded; i.e. its lease period is up and it isn't renewed."
]
}
]
},
"calls": [
{
"name": "new_auction",
"arguments": [
{
"name": "duration",
"ty": "Compact<T::BlockNumber>"
},
{
"name": "lease_period_index",
"ty": "Compact<LeasePeriodOf<T>>"
}
],
"documentation": [
" Create a new auction.",
"",
" This can only happen when there isn't already an auction in progress and may only be",
" called by the root origin. Accepts the `duration` of this auction and the",
" `lease_period_index` of the initial lease period of the four that are to be auctioned."
]
},
{
"name": "bid",
"arguments": [
{
"name": "sub",
"ty": "Compact<SubId>"
},
{
"name": "auction_index",
"ty": "Compact<AuctionIndex>"
},
{
"name": "first_slot",
"ty": "Compact<LeasePeriodOf<T>>"
},
{
"name": "last_slot",
"ty": "Compact<LeasePeriodOf<T>>"
},
{
"name": "amount",
"ty": "Compact<BalanceOf<T>>"
}
],
"documentation": [
" Make a new bid from an account (including a parachain account) for deploying a new",
" parachain.",
"",
" Multiple simultaneous bids from the same bidder are allowed only as long as all active",
" bids overlap each other (i.e. are mutually exclusive). Bids cannot be redacted.",
"",
" - `sub` is the sub-bidder ID, allowing for multiple competing bids to be made by (and",
" funded by) the same account.",
" - `auction_index` is the index of the auction to bid on. Should just be the present",
" value of `AuctionCounter`.",
" - `first_slot` is the first lease period index of the range to bid on. This is the",
" absolute lease period index value, not an auction-specific offset.",
" - `last_slot` is the last lease period index of the range to bid on. This is the",
" absolute lease period index value, not an auction-specific offset.",
" - `amount` is the amount to bid to be held as deposit for the parachain should the",
" bid win. This amount is held throughout the range."
]
},
{
"name": "bid_renew",
"arguments": [
{
"name": "auction_index",
"ty": "Compact<AuctionIndex>"
},
{
"name": "first_slot",
"ty": "Compact<LeasePeriodOf<T>>"
},
{
"name": "last_slot",
"ty": "Compact<LeasePeriodOf<T>>"
},
{
"name": "amount",
"ty": "Compact<BalanceOf<T>>"
}
],
"documentation": [
" Make a new bid from a parachain account for renewing that (pre-existing) parachain.",
"",
" The origin *must* be a parachain account.",
"",
" Multiple simultaneous bids from the same bidder are allowed only as long as all active",
" bids overlap each other (i.e. are mutually exclusive). Bids cannot be redacted.",
"",
" - `auction_index` is the index of the auction to bid on. Should just be the present",
" value of `AuctionCounter`.",
" - `first_slot` is the first lease period index of the range to bid on. This is the",
" absolute lease period index value, not an auction-specific offset.",
" - `last_slot` is the last lease period index of the range to bid on. This is the",
" absolute lease period index value, not an auction-specific offset.",
" - `amount` is the amount to bid to be held as deposit for the parachain should the",
" bid win. This amount is held throughout the range."
]
},
{
"name": "set_offboarding",
"arguments": [
{
"name": "dest",
"ty": "<T::Lookup as StaticLookup>::Source"
}
],
"documentation": [
" Set the off-boarding information for a parachain.",
"",
" The origin *must* be a parachain account.",
"",
" - `dest` is the destination account to receive the parachain's deposit."
]
},
{
"name": "fix_deploy_data",
"arguments": [
{
"name": "sub",
"ty": "Compact<SubId>"
},
{
"name": "para_id",
"ty": "Compact<ParaId>"
},
{
"name": "code_hash",
"ty": "T::Hash"
},
{
"name": "code_size",
"ty": "u32"
},
{
"name": "initial_head_data",
"ty": "Vec<u8>"
}
],
"documentation": [
" Set the deploy information for a successful bid to deploy a new parachain.",
"",
" - `origin` must be the successful bidder account.",
" - `sub` is the sub-bidder ID of the bidder.",
" - `para_id` is the parachain ID allotted to the winning bidder.",
" - `code_hash` is the hash of the parachain's Wasm validation function.",
" - `initial_head_data` is the parachain's initial head data."
]
},
{
"name": "elaborate_deploy_data",
"arguments": [
{
"name": "para_id",
"ty": "Compact<ParaId>"
},
{
"name": "code",
"ty": "Vec<u8>"
}
],
"documentation": [
" Note a new parachain's code.",
"",
" This must be called after `fix_deploy_data` and `code` must be the preimage of the",
" `code_hash` passed there for the same `para_id`.",
"",
" This may be called before or after the beginning of the parachain's first lease period.",
" If called before then the parachain will become active at the first block of its",
" starting lease period. If after, then it will become active immediately after this call.",
"",
" - `_origin` is irrelevant.",
" - `para_id` is the parachain ID whose code will be elaborated.",
" - `code` is the preimage of the registered `code_hash` of `para_id`."
]
}
],
"event": [
{
"name": "NewLeasePeriod",
"arguments": [
"LeasePeriod"
],
"documentation": [
" A new lease period is beginning."
]
},
{
"name": "AuctionStarted",
"arguments": [
"AuctionIndex",
"LeasePeriod",
"BlockNumber"
],
"documentation": [
" An auction started. Provides its index and the block number where it will begin to",
" close and the first lease period of the quadruplet that is auctioned."
]
},
{
"name": "AuctionClosed",
"arguments": [
"AuctionIndex"
],
"documentation": [
" An auction ended. All funds become unreserved."
]
},
{
"name": "WonDeploy",
"arguments": [
"NewBidder<AccountId>",
"SlotRange",
"ParaId",
"Balance"
],
"documentation": [
" Someone won the right to deploy a parachain. Balance amount is deducted for deposit."
]
},
{
"name": "WonRenewal",
"arguments": [
"ParaId",
"SlotRange",
"Balance",
"Balance"
],
"documentation": [
" An existing parachain won the right to continue.",
" First balance is the extra amount reseved. Second is the total amount reserved."
]
},
{
"name": "Reserved",
"arguments": [
"AccountId",
"Balance",
"Balance"
],
"documentation": [
" Funds were reserved for a winning bid. First balance is the extra amount reserved.",
" Second is the total."
]
},
{
"name": "Unreserved",
"arguments": [
"AccountId",
"Balance"
],
"documentation": [
" Funds were unreserved since bidder is no longer active."
]
}
],
"constants": [],
"errors": [
{
"name": "AuctionInProgress",
"documentation": [
" This auction is already in progress."
]
},
{
"name": "LeasePeriodInPast",
"documentation": [
" The lease period is in the past."
]
},
{
"name": "NotParaOrigin",
"documentation": [
" The origin for this call must be a parachain."
]
},
{
"name": "ParaNotOnboarding",
"documentation": [
" The parachain ID is not onboarding."
]
},
{
"name": "InvalidOrigin",
"documentation": [
" The origin for this call must be the origin who registered the parachain."
]
},
{
"name": "AlreadyRegistered",
"documentation": [
" Parachain is already registered."
]
},
{
"name": "InvalidCode",
"documentation": [
" The code must correspond to the hash."
]
},
{
"name": "UnsetDeployData",
"documentation": [
" Deployment data has not been set for this parachain."
]
},
{
"name": "NonIntersectingRange",
"documentation": [
" The bid must overlap all intersecting ranges."
]
},
{
"name": "NotCurrentAuction",
"documentation": [
" Not a current auction."
]
},
{
"name": "NotAuction",
"documentation": [
" Not an auction."
]
},
{
"name": "CodeTooLarge",
"documentation": [
" Given code size is too large."
]
},
{
"name": "HeadDataTooLarge",
"documentation": [
" Given initial head data is too large."
]
}
]
},
{
"name": "Registrar",
"storage": {
"prefix": "Registrar",
"entries": [
{
"name": "Parachains",
"modifier": "Default",
"ty": {
"Plain": "Vec<ParaId>"
},
"default": [
0
],
"documentation": []
},
{
"name": "ThreadCount",
"modifier": "Default",
"ty": {
"Plain": "u32"
},
"default": [
0,
0,
0,
0
],
"documentation": [
" The number of threads to schedule per block."
]
},
{
"name": "SelectedThreads",
"modifier": "Default",
"ty": {
"Plain": "Vec<Vec<(ParaId, CollatorId)>>"
},
"default": [
0
],
"documentation": [
" An array of the queue of set of threads scheduled for the coming blocks; ordered by",
" ascending para ID. There can be no duplicates of para ID in each list item."
]
},
{
"name": "Active",
"modifier": "Default",
"ty": {
"Plain": "Vec<(ParaId, Option<(CollatorId, Retriable)>)>"
},
"default": [
0
],
"documentation": [
" Parathreads/chains scheduled for execution this block. If the collator ID is set, then",
" a particular collator has already been chosen for the next block, and no other collator",
" may provide the block. In this case we allow the possibility of the combination being",
" retried in a later block, expressed by `Retriable`.",
"",
" Ordered by ParaId."
]
},
{
"name": "NextFreeId",
"modifier": "Default",
"ty": {
"Plain": "ParaId"
},
"default": [
232,
3,
0,
0
],
"documentation": [
" The next unused ParaId value. Start this high in order to keep low numbers for",
" system-level chains."
]
},
{
"name": "PendingSwap",
"modifier": "Optional",
"ty": {
"Map": {
"hasher": "Twox64Concat",
"key": "ParaId",
"value": "ParaId",
"unused": false
}
},
"default": [
0
],
"documentation": [
" Pending swap operations."
]
},
{
"name": "Paras",
"modifier": "Optional",
"ty": {
"Map": {
"hasher": "Twox64Concat",
"key": "ParaId",
"value": "ParaInfo",
"unused": false
}
},
"default": [
0
],
"documentation": [
" Map of all registered parathreads/chains."
]
},
{
"name": "RetryQueue",
"modifier": "Default",
"ty": {
"Plain": "Vec<Vec<(ParaId, CollatorId)>>"
},
"default": [
0
],
"documentation": [
" The current queue for parathreads that should be retried."
]
},
{
"name": "Debtors",
"modifier": "Default",
"ty": {
"Map": {
"hasher": "Twox64Concat",
"key": "ParaId",
"value": "T::AccountId",
"unused": false
}
},
"default": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"documentation": [
" Users who have paid a parathread's deposit"
]
}
]
},
"calls": [
{
"name": "register_para",
"arguments": [
{
"name": "id",
"ty": "Compact<ParaId>"
},
{
"name": "info",
"ty": "ParaInfo"
},
{
"name": "code",
"ty": "Vec<u8>"
},
{
"name": "initial_head_data",
"ty": "Vec<u8>"
}
],
"documentation": [
" Register a parachain with given code. Must be called by root.",
" Fails if given ID is already used.",
"",
" Unlike the `Registrar` trait function of the same name, this",
" checks the code and head data against size limits."
]
},
{
"name": "deregister_para",
"arguments": [
{
"name": "id",
"ty": "Compact<ParaId>"
}
],
"documentation": [
" Deregister a parachain with given id"
]
},
{
"name": "set_thread_count",
"arguments": [
{
"name": "count",
"ty": "u32"
}
],
"documentation": [
" Reset the number of parathreads that can pay to be scheduled in a single block.",
"",
" - `count`: The number of parathreads.",
"",
" Must be called from Root origin."
]
},
{
"name": "register_parathread",
"arguments": [
{
"name": "code",
"ty": "Vec<u8>"
},
{
"name": "initial_head_data",
"ty": "Vec<u8>"
}
],
"documentation": [
" Register a parathread for immediate use.",
"",
" Must be sent from a Signed origin that is able to have ParathreadDeposit reserved.",
" `code` and `initial_head_data` are used to initialize the parathread's state.",
"",
" Unlike `register_para`, this function does check that the maximum code size",
" and head data size are respected, as parathread registration is an atomic",
" action."
]
},
{
"name": "select_parathread",
"arguments": [
{
"name": "_id",
"ty": "Compact<ParaId>"
},
{
"name": "_collator",
"ty": "CollatorId"
},
{
"name": "_head_hash",
"ty": "T::Hash"
}
],
"documentation": [
" Place a bid for a parathread to be progressed in the next block.",
"",
" This is a kind of special transaction that should be heavily prioritized in the",
" transaction pool according to the `value`; only `ThreadCount` of them may be presented",
" in any single block."
]
},
{
"name": "deregister_parathread",
"arguments": [],
"documentation": [
" Deregister a parathread and retrieve the deposit.",
"",
" Must be sent from a `Parachain` origin which is currently a parathread.",
"",
" Ensure that before calling this that any funds you want emptied from the parathread's",
" account is moved out; after this it will be impossible to retrieve them (without",
" governance intervention)."
]
},
{
"name": "swap",
"arguments": [
{
"name": "other",
"ty": "Compact<ParaId>"
}
],
"documentation": [
" Swap a parachain with another parachain or parathread. The origin must be a `Parachain`.",
" The swap will happen only if there is already an opposite swap pending. If there is not,",
" the swap will be stored in the pending swaps map, ready for a later confirmatory swap.",
"",
" The `ParaId`s remain mapped to the same head data and code so external code can rely on",
" `ParaId` to be a long-term identifier of a notional \"parachain\". However, their",
" scheduling info (i.e. whether they're a parathread or parachain), auction information",
" and the auction deposit are switched."
]
}
],
"event": [
{
"name": "ParathreadRegistered",
"arguments": [
"ParaId"
],
"documentation": [
" A parathread was registered; its new ID is supplied."
]
},
{
"name": "ParathreadDeregistered",
"arguments": [
"ParaId"
],
"documentation": [
" The parathread of the supplied ID was de-registered."
]
}
],
"constants": [],
"errors": [
{
"name": "ParaAlreadyExists",
"documentation": [
" Parachain already exists."
]
},
{
"name": "InvalidChainId",
"documentation": [
" Invalid parachain ID."
]
},
{
"name": "InvalidThreadId",
"documentation": [
" Invalid parathread ID."
]
},
{
"name": "CodeTooLarge",
"documentation": [
" Invalid para code size."
]
},
{
"name": "HeadDataTooLarge",
"documentation": [
" Invalid para head data size."
]
}
]
},
{
"name": "Utility",
"storage": {
"prefix": "Utility",
"entries": [
{
"name": "Multisigs",
"modifier": "Optional",
"ty": {
"DoubleMap": {
"hasher": "Twox64Concat",
"key1": "T::AccountId",
"key2": "[u8; 32]",
"value": "Multisig<T::BlockNumber, BalanceOf<T>, T::AccountId>",
"key2_hasher": "Blake2_128Concat"
}
},
"default": [
0
],
"documentation": [
" The set of open multisig operations."
]
}
]
},
"calls": [
{
"name": "batch",
"arguments": [
{
"name": "calls",
"ty": "Vec<<T as Trait>::Call>"
}
],
"documentation": [
" Send a batch of dispatch calls.",
"",
" This will execute until the first one fails and then stop.",
"",
" May be called from any origin.",
"",
" - `calls`: The calls to be dispatched from the same origin.",
"",
" # <weight>",
" - The sum of the weights of the `calls`.",
" - One event.",
" # </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."
]
},
{
"name": "as_sub",
"arguments": [
{
"name": "index",
"ty": "u16"
},
{
"name": "call",
"ty": "Box<<T as Trait>::Call>"
}
],
"documentation": [
" Send a call through an indexed pseudonym of the sender.",
"",
" The dispatch origin for this call must be _Signed_.",
"",
" # <weight>",
" - The weight of the `call` + 10,000.",
" # </weight>"
]
},
{
"name": "as_multi",
"arguments": [
{
"name": "threshold",
"ty": "u16"
},
{
"name": "other_signatories",
"ty": "Vec<T::AccountId>"
},
{
"name": "maybe_timepoint",
"ty": "Option<Timepoint<T::BlockNumber>>"
},
{
"name": "call",
"ty": "Box<<T as Trait>::Call>"
}
],
"documentation": [
" 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: `MultisigDepositBase` will be reserved if this is the first approval, plus",
" `threshold` times `MultisigDepositFactor`. 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",
" `MultisigDepositBase + threshold * MultisigDepositFactor`.",
" # </weight>"
]
},
{
"name": "approve_as_multi",
"arguments": [
{
"name": "threshold",
"ty": "u16"
},
{
"name": "other_signatories",
"ty": "Vec<T::AccountId>"
},
{
"name": "maybe_timepoint",
"ty": "Option<Timepoint<T::BlockNumber>>"
},
{
"name": "call_hash",
"ty": "[u8; 32]"
}
],
"documentation": [
" 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: `MultisigDepositBase` will be reserved if this is the first approval, plus",
" `threshold` times `MultisigDepositFactor`. 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",
" `MultisigDepositBase + threshold * MultisigDepositFactor`.",
" # </weight>"
]
},
{
"name": "cancel_as_multi",
"arguments": [
{
"name": "threshold",
"ty": "u16"
},
{
"name": "other_signatories",
"ty": "Vec<T::AccountId>"
},
{
"name": "timepoint",
"ty": "Timepoint<T::BlockNumber>"
},
{
"name": "call_hash",
"ty": "[u8; 32]"
}
],
"documentation": [
" 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.",
" # </weight>"
]
}
],
"event": [
{
"name": "BatchInterrupted",
"arguments": [
"u32",
"DispatchError"
],
"documentation": [
" Batch of dispatches did not complete fully. Index of first failing dispatch given, as",
" well as the error."
]
},
{
"name": "BatchCompleted",
"arguments": [],
"documentation": [
" Batch of dispatches completed fully with no error."
]
},
{
"name": "NewMultisig",
"arguments": [
"AccountId",
"AccountId"
],
"documentation": [
" A new multisig operation has begun. First param is the account that is approving,",
" second is the multisig account."
]
},
{
"name": "MultisigApproval",
"arguments": [
"AccountId",
"Timepoint<BlockNumber>",
"AccountId"
],
"documentation": [
" A multisig operation has been approved by someone. First param is the account that is",
" approving, third is the multisig account."
]
},
{
"name": "MultisigExecuted",
"arguments": [
"AccountId",
"Timepoint<BlockNumber>",
"AccountId",
"DispatchResult"
],
"documentation": [
" A multisig operation has been executed. First param is the account that is",
" approving, third is the multisig account."
]
},
{
"name": "MultisigCancelled",
"arguments": [
"AccountId",
"Timepoint<BlockNumber>",
"AccountId"
],
"documentation": [
" A multisig operation has been cancelled. First param is the account that is",
" cancelling, third is the multisig account."
]
}
],
"constants": [],
"errors": [
{
"name": "ZeroThreshold",
"documentation": [
" Threshold is too low (zero)."
]
},
{
"name": "AlreadyApproved",
"documentation": [
" Call is already approved by this signatory."
]
},
{
"name": "NoApprovalsNeeded",
"documentation": [
" Call doesn't need any (more) approvals."
]
},
{
"name": "TooFewSignatories",
"documentation": [
" There are too few signatories in the list."
]
},
{
"name": "TooManySignatories",
"documentation": [
" There are too many signatories in the list."
]
},
{
"name": "SignatoriesOutOfOrder",
"documentation": [
" The signatories were provided out of order; they should be ordered."
]
},
{
"name": "SenderInSignatories",
"documentation": [
" The sender was contained in the other signatories; it shouldn't be."
]
},
{
"name": "NotFound",
"documentation": [
" Multisig operation not found when attempting to cancel."
]
},
{
"name": "NotOwner",
"documentation": [
" Only the account that originally created the multisig is able to cancel it."
]
},
{
"name": "NoTimepoint",
"documentation": [
" No timepoint was given, yet the multisig operation is already underway."
]
},
{
"name": "WrongTimepoint",
"documentation": [
" A different timepoint was given to the multisig operation that is underway."
]
},
{
"name": "UnexpectedTimepoint",
"documentation": [
" A timepoint was given, yet no multisig operation is underway."
]
}
]
},
{
"name": "Identity",
"storage": {
"prefix": "Identity",
"entries": [
{
"name": "IdentityOf",
"modifier": "Optional",
"ty": {
"Map": {
"hasher": "Twox64Concat",
"key": "T::AccountId",
"value": "Registration<BalanceOf<T>>",
"unused": false
}
},
"default": [
0
],
"documentation": [
" Information that is pertinent to identify the entity behind an account."
]
},
{
"name": "SuperOf",
"modifier": "Optional",
"ty": {
"Map": {
"hasher": "Blake2_128Concat",
"key": "T::AccountId",
"value": "(T::AccountId, Data)",
"unused": false
}
},
"default": [
0
],
"documentation": [
" The super-identity of an alternative \"sub\" identity together with its name, within that",
" context. If the account is not some other account's sub-identity, then just `None`."
]
},
{
"name": "SubsOf",
"modifier": "Default",
"ty": {
"Map": {
"hasher": "Twox64Concat",
"key": "T::AccountId",
"value": "(BalanceOf<T>, Vec<T::AccountId>)",
"unused": false
}
},
"default": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"documentation": [
" Alternative \"sub\" identities of this account.",
"",
" The first item is the deposit, the second is a vector of the accounts."
]
},
{
"name": "Registrars",
"modifier": "Default",
"ty": {
"Plain": "Vec<Option<RegistrarInfo<BalanceOf<T>, T::AccountId>>>"
},
"default": [
0
],
"documentation": [
" The set of registrars. Not expected to get very big as can only be added through a",
" special origin (likely a council motion).",
"",
" The index into this can be cast to `RegistrarIndex` to get a valid value."
]
}
]
},
"calls": [
{
"name": "add_registrar",
"arguments": [
{
"name": "account",
"ty": "T::AccountId"
}
],
"documentation": [
" Add a registrar to the system.",
"",
" The dispatch origin for this call must be `RegistrarOrigin` or `Root`.",
"",
" - `account`: the account of the registrar.",
"",
" Emits `RegistrarAdded` if successful.",
"",
" # <weight>",
" - `O(R)` where `R` registrar-count (governance-bounded).",
" - One storage mutation (codec `O(R)`).",
" - One event.",
" # </weight>"
]
},
{
"name": "set_identity",
"arguments": [
{
"name": "info",
"ty": "IdentityInfo"
}
],
"documentation": [
" 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_ and the sender must have a registered",
" identity.",
"",
" - `info`: The identity information.",
"",
" Emits `IdentitySet` if successful.",
"",
" # <weight>",
" - `O(X + X' + R)` where `X` additional-field-count (deposit-bounded and code-bounded).",
" - At most two balance operations.",
" - One storage mutation (codec-read `O(X' + R)`, codec-write `O(X + R)`).",
" - One event.",
" # </weight>"
]
},
{
"name": "set_subs",
"arguments": [
{
"name": "subs",
"ty": "Vec<(T::AccountId, Data)>"
}
],
"documentation": [
" 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 sub-accounts.",
"",
" # <weight>",
" - `O(S)` where `S` subs-count (hard- and deposit-bounded).",
" - At most two balance operations.",
" - At most O(2 * S + 1) storage mutations; codec complexity `O(1 * S + S * 1)`);",
" one storage-exists.",
" # </weight>"
]
},
{
"name": "clear_identity",
"arguments": [],
"documentation": [
" Clear an account's identity info and all sub-account 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)`.",
" - One balance-reserve operation.",
" - `S + 2` storage deletions.",
" - One event.",
" # </weight>"
]
},
{
"name": "request_judgement",
"arguments": [
{
"name": "reg_index",
"ty": "Compact<RegistrarIndex>"
},
{
"name": "max_fee",
"ty": "Compact<BalanceOf<T>>"
}
],
"documentation": [
" 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(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>"
]
},
{
"name": "cancel_request",
"arguments": [
{
"name": "reg_index",
"ty": "RegistrarIndex"
}
],
"documentation": [
" 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>"
]
},
{
"name": "set_fee",
"arguments": [
{
"name": "index",
"ty": "Compact<RegistrarIndex>"
},
{
"name": "fee",
"ty": "Compact<BalanceOf<T>>"
}
],
"documentation": [
" 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)`.",
" # </weight>"
]
},
{
"name": "set_account_id",
"arguments": [
{
"name": "index",
"ty": "Compact<RegistrarIndex>"
},
{
"name": "new",
"ty": "T::AccountId"
}
],
"documentation": [
" 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)`.",
" # </weight>"
]
},
{
"name": "set_fields",
"arguments": [
{
"name": "index",
"ty": "Compact<RegistrarIndex>"
},
{
"name": "fields",
"ty": "IdentityFields"
}
],
"documentation": [
" 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)`.",
" # </weight>"
]
},
{
"name": "provide_judgement",
"arguments": [
{
"name": "reg_index",
"ty": "Compact<RegistrarIndex>"
},
{
"name": "target",
"ty": "<T::Lookup as StaticLookup>::Source"
},
{
"name": "judgement",
"ty": "Judgement<BalanceOf<T>>"
}
],
"documentation": [
" 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>"
]
},
{
"name": "kill_identity",
"arguments": [
{
"name": "target",
"ty": "<T::Lookup as StaticLookup>::Source"
}
],
"documentation": [
" 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 be _Root_ or 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>"
]
}
],
"event": [
{
"name": "IdentitySet",
"arguments": [
"AccountId"
],
"documentation": [
" A name was set or reset (which will remove all judgements)."
]
},
{
"name": "IdentityCleared",
"arguments": [
"AccountId",
"Balance"
],
"documentation": [
" A name was cleared, and the given balance returned."
]
},
{
"name": "IdentityKilled",
"arguments": [
"AccountId",
"Balance"
],
"documentation": [
" A name was removed and the given balance slashed."
]
},
{
"name": "JudgementRequested",
"arguments": [
"AccountId",
"RegistrarIndex"
],
"documentation": [
" A judgement was asked from a registrar."
]
},
{
"name": "JudgementUnrequested",
"arguments": [
"AccountId",
"RegistrarIndex"
],
"documentation": [
" A judgement request was retracted."
]
},
{
"name": "JudgementGiven",
"arguments": [
"AccountId",
"RegistrarIndex"
],
"documentation": [
" A judgement was given by a registrar."
]
},
{
"name": "RegistrarAdded",
"arguments": [
"RegistrarIndex"
],
"documentation": [
" A registrar was added."
]
}
],
"constants": [],
"errors": [
{
"name": "TooManySubAccounts",
"documentation": [
" Too many subs-accounts."
]
},
{
"name": "NotFound",
"documentation": [
" Account isn't found."
]
},
{
"name": "NotNamed",
"documentation": [
" Account isn't named."
]
},
{
"name": "EmptyIndex",
"documentation": [
" Empty index."
]
},
{
"name": "FeeChanged",
"documentation": [
" Fee is changed."
]
},
{
"name": "NoIdentity",
"documentation": [
" No identity found."
]
},
{
"name": "StickyJudgement",
"documentation": [
" Sticky judgement."
]
},
{
"name": "JudgementGiven",
"documentation": [
" Judgement given."
]
},
{
"name": "InvalidJudgement",
"documentation": [
" Invalid judgement."
]
},
{
"name": "InvalidIndex",
"documentation": [
" The index is invalid."
]
},
{
"name": "InvalidTarget",
"documentation": [
" The target is invalid."
]
},
{
"name": "TooManyFields",
"documentation": [
" Too many additional fields."
]
}
]
},
{
"name": "Society",
"storage": {
"prefix": "Society",
"entries": [
{
"name": "Founder",
"modifier": "Optional",
"ty": {
"Plain": "T::AccountId"
},
"default": [
0
],
"documentation": [
" The first member."
]
},
{
"name": "Rules",
"modifier": "Optional",
"ty": {
"Plain": "T::Hash"
},
"default": [
0
],
"documentation": [
" A hash of the rules of this society concerning membership. Can only be set once and",
" only by the founder."
]
},
{
"name": "Candidates",
"modifier": "Default",
"ty": {
"Plain": "Vec<Bid<T::AccountId, BalanceOf<T, I>>>"
},
"default": [
0
],
"documentation": [
" The current set of candidates; bidders that are attempting to become members."
]
},
{
"name": "SuspendedCandidates",
"modifier": "Optional",
"ty": {
"Map": {
"hasher": "Twox64Concat",
"key": "T::AccountId",
"value": "(BalanceOf<T, I>, BidKind<T::AccountId, BalanceOf<T, I>>)",
"unused": false
}
},
"default": [
0
],
"documentation": [
" The set of suspended candidates."
]
},
{
"name": "Pot",
"modifier": "Default",
"ty": {
"Plain": "BalanceOf<T, I>"
},
"default": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"documentation": [
" Amount of our account balance that is specifically for the next round's bid(s)."
]
},
{
"name": "Head",
"modifier": "Optional",
"ty": {
"Plain": "T::AccountId"
},
"default": [
0
],
"documentation": [
" The most primary from the most recently approved members."
]
},
{
"name": "Members",
"modifier": "Default",
"ty": {
"Plain": "Vec<T::AccountId>"
},
"default": [
0
],
"documentation": [
" The current set of members, ordered."
]
},
{
"name": "SuspendedMembers",
"modifier": "Default",
"ty": {
"Map": {
"hasher": "Twox64Concat",
"key": "T::AccountId",
"value": "bool",
"unused": false
}
},
"default": [
0
],
"documentation": [
" The set of suspended members."
]
},
{
"name": "Bids",
"modifier": "Default",
"ty": {
"Plain": "Vec<Bid<T::AccountId, BalanceOf<T, I>>>"
},
"default": [
0
],
"documentation": [
" The current bids, stored ordered by the value of the bid."
]
},
{
"name": "Vouching",
"modifier": "Optional",
"ty": {
"Map": {
"hasher": "Twox64Concat",
"key": "T::AccountId",
"value": "VouchingStatus",
"unused": false
}
},
"default": [
0
],
"documentation": [
" Members currently vouching or banned from vouching again"
]
},
{
"name": "Payouts",
"modifier": "Default",
"ty": {
"Map": {
"hasher": "Twox64Concat",
"key": "T::AccountId",
"value": "Vec<(T::BlockNumber, BalanceOf<T, I>)>",
"unused": false
}
},
"default": [
0
],
"documentation": [
" Pending payouts; ordered by block number, with the amount that should be paid out."
]
},
{
"name": "Strikes",
"modifier": "Default",
"ty": {
"Map": {
"hasher": "Twox64Concat",
"key": "T::AccountId",
"value": "StrikeCount",
"unused": false
}
},
"default": [
0,
0,
0,
0
],
"documentation": [
" The ongoing number of losing votes cast by the member."
]
},
{
"name": "Votes",
"modifier": "Optional",
"ty": {
"DoubleMap": {
"hasher": "Twox64Concat",
"key1": "T::AccountId",
"key2": "T::AccountId",
"value": "Vote",
"key2_hasher": "Twox64Concat"
}
},
"default": [
0
],
"documentation": [
" Double map from Candidate -> Voter -> (Maybe) Vote."
]
},
{
"name": "Defender",
"modifier": "Optional",
"ty": {
"Plain": "T::AccountId"
},
"default": [
0
],
"documentation": [
" The defending member currently being challenged."
]
},
{
"name": "DefenderVotes",
"modifier": "Optional",
"ty": {
"Map": {
"hasher": "Twox64Concat",
"key": "T::AccountId",
"value": "Vote",
"unused": false
}
},
"default": [
0
],
"documentation": [
" Votes for the defender."
]
},
{
"name": "MaxMembers",
"modifier": "Default",
"ty": {
"Plain": "u32"
},
"default": [
0,
0,
0,
0
],
"documentation": [
" The max number of members for the society at one time."
]
}
]
},
"calls": [
{
"name": "bid",
"arguments": [
{
"name": "value",
"ty": "BalanceOf<T, I>"
}
],
"documentation": [
" A user outside of the society can make a bid for entry.",
"",
" Payment: `CandidateDeposit` will be reserved for making a bid. It is returned",
" when the bid becomes a member, or if the bid calls `unbid`.",
"",
" The dispatch origin for this call must be _Signed_.",
"",
" Parameters:",
" - `value`: A one time payment the bid would like to receive when joining the society.",
"",
" # <weight>",
" Key: B (len of bids), C (len of candidates), M (len of members), X (balance reserve)",
" - Storage Reads:",
" \t- One storage read to check for suspended candidate. O(1)",
" \t- One storage read to check for suspended member. O(1)",
" \t- One storage read to retrieve all current bids. O(B)",
" \t- One storage read to retrieve all current candidates. O(C)",
" \t- One storage read to retrieve all members. O(M)",
" - Storage Writes:",
" \t- One storage mutate to add a new bid to the vector O(B) (TODO: possible optimization w/ read)",
" \t- Up to one storage removal if bid.len() > MAX_BID_COUNT. O(1)",
" - Notable Computation:",
" \t- O(B + C + log M) search to check user is not already a part of society.",
" \t- O(log B) search to insert the new bid sorted.",
" - External Module Operations:",
" \t- One balance reserve operation. O(X)",
" \t- Up to one balance unreserve operation if bids.len() > MAX_BID_COUNT.",
" - Events:",
" \t- One event for new bid.",
" \t- Up to one event for AutoUnbid if bid.len() > MAX_BID_COUNT.",
"",
" Total Complexity: O(M + B + C + logM + logB + X)",
" # </weight>"
]
},
{
"name": "unbid",
"arguments": [
{
"name": "pos",
"ty": "u32"
}
],
"documentation": [
" A bidder can remove their bid for entry into society.",
" By doing so, they will have their candidate deposit returned or",
" they will unvouch their voucher.",
"",
" Payment: The bid deposit is unreserved if the user made a bid.",
"",
" The dispatch origin for this call must be _Signed_ and a bidder.",
"",
" Parameters:",
" - `pos`: Position in the `Bids` vector of the bid who wants to unbid.",
"",
" # <weight>",
" Key: B (len of bids), X (balance unreserve)",
" - One storage read and write to retrieve and update the bids. O(B)",
" - Either one unreserve balance action O(X) or one vouching storage removal. O(1)",
" - One event.",
"",
" Total Complexity: O(B + X)",
" # </weight>"
]
},
{
"name": "vouch",
"arguments": [
{
"name": "who",
"ty": "T::AccountId"
},
{
"name": "value",
"ty": "BalanceOf<T, I>"
},
{
"name": "tip",
"ty": "BalanceOf<T, I>"
}
],
"documentation": [
" As a member, vouch for someone to join society by placing a bid on their behalf.",
"",
" There is no deposit required to vouch for a new bid, but a member can only vouch for",
" one bid at a time. If the bid becomes a suspended candidate and ultimately rejected by",
" the suspension judgement origin, the member will be banned from vouching again.",
"",
" As a vouching member, you can claim a tip if the candidate is accepted. This tip will",
" be paid as a portion of the reward the member will receive for joining the society.",
"",
" The dispatch origin for this call must be _Signed_ and a member.",
"",
" Parameters:",
" - `who`: The user who you would like to vouch for.",
" - `value`: The total reward to be paid between you and the candidate if they become",
" a member in the society.",
" - `tip`: Your cut of the total `value` payout when the candidate is inducted into",
" the society. Tips larger than `value` will be saturated upon payout.",
"",
" # <weight>",
" Key: B (len of bids), C (len of candidates), M (len of members)",
" - Storage Reads:",
" \t- One storage read to retrieve all members. O(M)",
" \t- One storage read to check member is not already vouching. O(1)",
" \t- One storage read to check for suspended candidate. O(1)",
" \t- One storage read to check for suspended member. O(1)",
" \t- One storage read to retrieve all current bids. O(B)",
" \t- One storage read to retrieve all current candidates. O(C)",
" - Storage Writes:",
" \t- One storage write to insert vouching status to the member. O(1)",
" \t- One storage mutate to add a new bid to the vector O(B) (TODO: possible optimization w/ read)",
" \t- Up to one storage removal if bid.len() > MAX_BID_COUNT. O(1)",
" - Notable Computation:",
" \t- O(log M) search to check sender is a member.",
" \t- O(B + C + log M) search to check user is not already a part of society.",
" \t- O(log B) search to insert the new bid sorted.",
" - External Module Operations:",
" \t- One balance reserve operation. O(X)",
" \t- Up to one balance unreserve operation if bids.len() > MAX_BID_COUNT.",
" - Events:",
" \t- One event for vouch.",
" \t- Up to one event for AutoUnbid if bid.len() > MAX_BID_COUNT.",
"",
" Total Complexity: O(M + B + C + logM + logB + X)",
" # </weight>"
]
},
{
"name": "unvouch",
"arguments": [
{
"name": "pos",
"ty": "u32"
}
],
"documentation": [
" As a vouching member, unvouch a bid. This only works while vouched user is",
" only a bidder (and not a candidate).",
"",
" The dispatch origin for this call must be _Signed_ and a vouching member.",
"",
" Parameters:",
" - `pos`: Position in the `Bids` vector of the bid who should be unvouched.",
"",
" # <weight>",
" Key: B (len of bids)",
" - One storage read O(1) to check the signer is a vouching member.",
" - One storage mutate to retrieve and update the bids. O(B)",
" - One vouching storage removal. O(1)",
" - One event.",
"",
" Total Complexity: O(B)",
" # </weight>"
]
},
{
"name": "vote",
"arguments": [
{
"name": "candidate",
"ty": "<T::Lookup as StaticLookup>::Source"
},
{
"name": "approve",
"ty": "bool"
}
],
"documentation": [
" As a member, vote on a candidate.",
"",
" The dispatch origin for this call must be _Signed_ and a member.",
"",
" Parameters:",
" - `candidate`: The candidate that the member would like to bid on.",
" - `approve`: A boolean which says if the candidate should be",
" approved (`true`) or rejected (`false`).",
"",
" # <weight>",
" Key: C (len of candidates), M (len of members)",
" - One storage read O(M) and O(log M) search to check user is a member.",
" - One account lookup.",
" - One storage read O(C) and O(C) search to check that user is a candidate.",
" - One storage write to add vote to votes. O(1)",
" - One event.",
"",
" Total Complexity: O(M + logM + C)",
" # </weight>"
]
},
{
"name": "defender_vote",
"arguments": [
{
"name": "approve",
"ty": "bool"
}
],
"documentation": [
" As a member, vote on the defender.",
"",
" The dispatch origin for this call must be _Signed_ and a member.",
"",
" Parameters:",
" - `approve`: A boolean which says if the candidate should be",
" approved (`true`) or rejected (`false`).",
"",
" # <weight>",
" - Key: M (len of members)",
" - One storage read O(M) and O(log M) search to check user is a member.",
" - One storage write to add vote to votes. O(1)",
" - One event.",
"",
" Total Complexity: O(M + logM)",
" # </weight>"
]
},
{
"name": "payout",
"arguments": [],
"documentation": [
" Transfer the first matured payout for the sender and remove it from the records.",
"",
" NOTE: This extrinsic needs to be called multiple times to claim multiple matured payouts.",
"",
" Payment: The member will receive a payment equal to their first matured",
" payout to their free balance.",
"",
" The dispatch origin for this call must be _Signed_ and a member with",
" payouts remaining.",
"",
" # <weight>",
" Key: M (len of members), P (number of payouts for a particular member)",
" - One storage read O(M) and O(log M) search to check signer is a member.",
" - One storage read O(P) to get all payouts for a member.",
" - One storage read O(1) to get the current block number.",
" - One currency transfer call. O(X)",
" - One storage write or removal to update the member's payouts. O(P)",
"",
" Total Complexity: O(M + logM + P + X)",
" # </weight>"
]
},
{
"name": "found",
"arguments": [
{
"name": "founder",
"ty": "T::AccountId"
},
{
"name": "max_members",
"ty": "u32"
},
{
"name": "rules",
"ty": "Vec<u8>"
}
],
"documentation": [
" Found the society.",
"",
" This is done as a discrete action in order to allow for the",
" module to be included into a running chain and can only be done once.",
"",
" The dispatch origin for this call must be from the _FounderSetOrigin_.",
"",
" Parameters:",
" - `founder` - The first member and head of the newly founded society.",
" - `max_members` - The initial max number of members for the society.",
" - `rules` - The rules of this society concerning membership.",
"",
" # <weight>",
" - Two storage mutates to set `Head` and `Founder`. O(1)",
" - One storage write to add the first member to society. O(1)",
" - One event.",
"",
" Total Complexity: O(1)",
" # </weight>"
]
},
{
"name": "unfound",
"arguments": [],
"documentation": [
" Annul the founding of the society.",
"",
" The dispatch origin for this call must be Signed, and the signing account must be both",
" the `Founder` and the `Head`. This implies that it may only be done when there is one",
" member.",
"",
" # <weight>",
" - Two storage reads O(1).",
" - Four storage removals O(1).",
" - One event.",
"",
" Total Complexity: O(1)",
" # </weight>"
]
},
{
"name": "judge_suspended_member",
"arguments": [
{
"name": "who",
"ty": "T::AccountId"
},
{
"name": "forgive",
"ty": "bool"
}
],
"documentation": [
" Allow suspension judgement origin to make judgement on a suspended member.",
"",
" If a suspended member is forgiven, we simply add them back as a member, not affecting",
" any of the existing storage items for that member.",
"",
" If a suspended member is rejected, remove all associated storage items, including",
" their payouts, and remove any vouched bids they currently have.",
"",
" The dispatch origin for this call must be from the _SuspensionJudgementOrigin_.",
"",
" Parameters:",
" - `who` - The suspended member to be judged.",
" - `forgive` - A boolean representing whether the suspension judgement origin",
" forgives (`true`) or rejects (`false`) a suspended member.",
"",
" # <weight>",
" Key: B (len of bids), M (len of members)",
" - One storage read to check `who` is a suspended member. O(1)",
" - Up to one storage write O(M) with O(log M) binary search to add a member back to society.",
" - Up to 3 storage removals O(1) to clean up a removed member.",
" - Up to one storage write O(B) with O(B) search to remove vouched bid from bids.",
" - Up to one additional event if unvouch takes place.",
" - One storage removal. O(1)",
" - One event for the judgement.",
"",
" Total Complexity: O(M + logM + B)",
" # </weight>"
]
},
{
"name": "judge_suspended_candidate",
"arguments": [
{
"name": "who",
"ty": "T::AccountId"
},
{
"name": "judgement",
"ty": "Judgement"
}
],
"documentation": [
" Allow suspended judgement origin to make judgement on a suspended candidate.",
"",
" If the judgement is `Approve`, we add them to society as a member with the appropriate",
" payment for joining society.",
"",
" If the judgement is `Reject`, we either slash the deposit of the bid, giving it back",
" to the society treasury, or we ban the voucher from vouching again.",
"",
" If the judgement is `Rebid`, we put the candidate back in the bid pool and let them go",
" through the induction process again.",
"",
" The dispatch origin for this call must be from the _SuspensionJudgementOrigin_.",
"",
" Parameters:",
" - `who` - The suspended candidate to be judged.",
" - `judgement` - `Approve`, `Reject`, or `Rebid`.",
"",
" # <weight>",
" Key: B (len of bids), M (len of members), X (balance action)",
" - One storage read to check `who` is a suspended candidate.",
" - One storage removal of the suspended candidate.",
" - Approve Logic",
" \t- One storage read to get the available pot to pay users with. O(1)",
" \t- One storage write to update the available pot. O(1)",
" \t- One storage read to get the current block number. O(1)",
" \t- One storage read to get all members. O(M)",
" \t- Up to one unreserve currency action.",
" \t- Up to two new storage writes to payouts.",
" \t- Up to one storage write with O(log M) binary search to add a member to society.",
" - Reject Logic",
" \t- Up to one repatriate reserved currency action. O(X)",
" \t- Up to one storage write to ban the vouching member from vouching again.",
" - Rebid Logic",
" \t- Storage mutate with O(log B) binary search to place the user back into bids.",
" - Up to one additional event if unvouch takes place.",
" - One storage removal.",
" - One event for the judgement.",
"",
" Total Complexity: O(M + logM + B + X)",
" # </weight>"
]
},
{
"name": "set_max_members",
"arguments": [
{
"name": "max",
"ty": "u32"
}
],
"documentation": [
" Allows root origin to change the maximum number of members in society.",
" Max membership count must be greater than 1.",
"",
" The dispatch origin for this call must be from _ROOT_.",
"",
" Parameters:",
" - `max` - The maximum number of members for the society.",
"",
" # <weight>",
" - One storage write to update the max. O(1)",
" - One event.",
"",
" Total Complexity: O(1)",
" # </weight>"
]
}
],
"event": [
{
"name": "Founded",
"arguments": [
"AccountId"
],
"documentation": [
" The society is founded by the given identity."
]
},
{
"name": "Bid",
"arguments": [
"AccountId",
"Balance"
],
"documentation": [
" A membership bid just happened. The given account is the candidate's ID and their offer",
" is the second."
]
},
{
"name": "Vouch",
"arguments": [
"AccountId",
"Balance",
"AccountId"
],
"documentation": [
" A membership bid just happened by vouching. The given account is the candidate's ID and",
" their offer is the second. The vouching party is the third."
]
},
{
"name": "AutoUnbid",
"arguments": [
"AccountId"
],
"documentation": [
" A candidate was dropped (due to an excess of bids in the system)."
]
},
{
"name": "Unbid",
"arguments": [
"AccountId"
],
"documentation": [
" A candidate was dropped (by their request)."
]
},
{
"name": "Unvouch",
"arguments": [
"AccountId"
],
"documentation": [
" A candidate was dropped (by request of who vouched for them)."
]
},
{
"name": "Inducted",
"arguments": [
"AccountId",
"Vec<AccountId>"
],
"documentation": [
" A group of candidates have been inducted. The batch's primary is the first value, the",
" batch in full is the second."
]
},
{
"name": "SuspendedMemberJudgement",
"arguments": [
"AccountId",
"bool"
],
"documentation": [
" A suspended member has been judged"
]
},
{
"name": "CandidateSuspended",
"arguments": [
"AccountId"
],
"documentation": [
" A candidate has been suspended"
]
},
{
"name": "MemberSuspended",
"arguments": [
"AccountId"
],
"documentation": [
" A member has been suspended"
]
},
{
"name": "Challenged",
"arguments": [
"AccountId"
],
"documentation": [
" A member has been challenged"
]
},
{
"name": "Vote",
"arguments": [
"AccountId",
"AccountId",
"bool"
],
"documentation": [
" A vote has been placed (candidate, voter, vote)"
]
},
{
"name": "DefenderVote",
"arguments": [
"AccountId",
"bool"
],
"documentation": [
" A vote has been placed for a defending member (voter, vote)"
]
},
{
"name": "NewMaxMembers",
"arguments": [
"u32"
],
"documentation": [
" A new max member count has been set"
]
},
{
"name": "Unfounded",
"arguments": [
"AccountId"
],
"documentation": [
" Society is unfounded."
]
}
],
"constants": [
{
"name": "CandidateDeposit",
"ty": "BalanceOf<T, I>",
"value": [
0,
160,
114,
78,
24,
9,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"documentation": [
" The minimum amount of a deposit required for a bid to be made."
]
},
{
"name": "WrongSideDeduction",
"ty": "BalanceOf<T, I>",
"value": [
0,
32,
74,
169,
209,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"documentation": [
" The amount of the unpaid reward that gets deducted in the case that either a skeptic",
" doesn't vote or someone votes in the wrong way."
]
},
{
"name": "MaxStrikes",
"ty": "u32",
"value": [
10,
0,
0,
0
],
"documentation": [
" The number of times a member may vote the wrong way (or not at all, when they are a skeptic)",
" before they become suspended."
]
},
{
"name": "PeriodSpend",
"ty": "BalanceOf<T, I>",
"value": [
0,
64,
99,
82,
191,
198,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"documentation": [
" The amount of incentive paid within each period. Doesn't include VoterTip."
]
},
{
"name": "RotationPeriod",
"ty": "T::BlockNumber",
"value": [
128,
187,
0,
0
],
"documentation": [
" The number of blocks between candidate/membership rotation periods."
]
},
{
"name": "ChallengePeriod",
"ty": "T::BlockNumber",
"value": [
192,
137,
1,
0
],
"documentation": [
" The number of blocks between membership challenges."
]
}
],
"errors": [
{
"name": "BadPosition",
"documentation": [
" An incorrect position was provided."
]
},
{
"name": "NotMember",
"documentation": [
" User is not a member."
]
},
{
"name": "AlreadyMember",
"documentation": [
" User is already a member."
]
},
{
"name": "Suspended",
"documentation": [
" User is suspended."
]
},
{
"name": "NotSuspended",
"documentation": [
" User is not suspended."
]
},
{
"name": "NoPayout",
"documentation": [
" Nothing to payout."
]
},
{
"name": "AlreadyFounded",
"documentation": [
" Society already founded."
]
},
{
"name": "InsufficientPot",
"documentation": [
" Not enough in pot to accept candidate."
]
},
{
"name": "AlreadyVouching",
"documentation": [
" Member is already vouching or banned from vouching again."
]
},
{
"name": "NotVouching",
"documentation": [
" Member is not vouching."
]
},
{
"name": "Head",
"documentation": [
" Cannot remove the head of the chain."
]
},
{
"name": "Founder",
"documentation": [
" Cannot remove the founder."
]
},
{
"name": "AlreadyBid",
"documentation": [
" User has already made a bid."
]
},
{
"name": "AlreadyCandidate",
"documentation": [
" User is already a candidate."
]
},
{
"name": "NotCandidate",
"documentation": [
" User is not a candidate."
]
},
{
"name": "MaxMembers",
"documentation": [
" Too many members in the society."
]
},
{
"name": "NotFounder",
"documentation": [
" The caller is not the founder."
]
},
{
"name": "NotHead",
"documentation": [
" The caller is not the head."
]
}
]
},
{
"name": "Recovery",
"storage": {
"prefix": "Recovery",
"entries": [
{
"name": "Recoverable",
"modifier": "Optional",
"ty": {
"Map": {
"hasher": "Twox64Concat",
"key": "T::AccountId",
"value": "RecoveryConfig<T::BlockNumber, BalanceOf<T>, T::AccountId>",
"unused": false
}
},
"default": [
0
],
"documentation": [
" The set of recoverable accounts and their recovery configuration."
]
},
{
"name": "ActiveRecoveries",
"modifier": "Optional",
"ty": {
"DoubleMap": {
"hasher": "Twox64Concat",
"key1": "T::AccountId",
"key2": "T::AccountId",
"value": "ActiveRecovery<T::BlockNumber, BalanceOf<T>, T::AccountId>",
"key2_hasher": "Twox64Concat"
}
},
"default": [
0
],
"documentation": [
" Active recovery attempts.",
"",
" First account is the account to be recovered, and the second account",
" is the user trying to recover the account."
]
},
{
"name": "Proxy",
"modifier": "Optional",
"ty": {
"Map": {
"hasher": "Blake2_128Concat",
"key": "T::AccountId",
"value": "T::AccountId",
"unused": false
}
},
"default": [
0
],
"documentation": [
" The list of allowed proxy accounts.",
"",
" Map from the user who can access it to the recovered account."
]
}
]
},
"calls": [
{
"name": "as_recovered",
"arguments": [
{
"name": "account",
"ty": "T::AccountId"
},
{
"name": "call",
"ty": "Box<<T as Trait>::Call>"
}
],
"documentation": [
" 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>"
]
},
{
"name": "set_recovered",
"arguments": [
{
"name": "lost",
"ty": "T::AccountId"
},
{
"name": "rescuer",
"ty": "T::AccountId"
}
],
"documentation": [
" 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>"
]
},
{
"name": "create_recovery",
"arguments": [
{
"name": "friends",
"ty": "Vec<T::AccountId>"
},
{
"name": "threshold",
"ty": "u16"
},
{
"name": "delay_period",
"ty": "T::BlockNumber"
}
],
"documentation": [
" 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>"
]
},
{
"name": "initiate_recovery",
"arguments": [
{
"name": "account",
"ty": "T::AccountId"
}
],
"documentation": [
" 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>"
]
},
{
"name": "vouch_recovery",
"arguments": [
{
"name": "lost",
"ty": "T::AccountId"
},
{
"name": "rescuer",
"ty": "T::AccountId"
}
],
"documentation": [
" 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>"
]
},
{
"name": "claim_recovery",
"arguments": [
{
"name": "account",
"ty": "T::AccountId"
}
],
"documentation": [
" 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>"
]
},
{
"name": "close_recovery",
"arguments": [
{
"name": "rescuer",
"ty": "T::AccountId"
}
],
"documentation": [
" 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>"
]
},
{
"name": "remove_recovery",
"arguments": [],
"documentation": [
" 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>"
]
},
{
"name": "cancel_recovered",
"arguments": [
{
"name": "account",
"ty": "T::AccountId"
}
],
"documentation": [
" 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>"
]
}
],
"event": [
{
"name": "RecoveryCreated",
"arguments": [
"AccountId"
],
"documentation": [
" A recovery process has been set up for an account"
]
},
{
"name": "RecoveryInitiated",
"arguments": [
"AccountId",
"AccountId"
],
"documentation": [
" A recovery process has been initiated for account_1 by account_2"
]
},
{
"name": "RecoveryVouched",
"arguments": [
"AccountId",
"AccountId",
"AccountId"
],
"documentation": [
" A recovery process for account_1 by account_2 has been vouched for by account_3"
]
},
{
"name": "RecoveryClosed",
"arguments": [
"AccountId",
"AccountId"
],
"documentation": [
" A recovery process for account_1 by account_2 has been closed"
]
},
{
"name": "AccountRecovered",
"arguments": [
"AccountId",
"AccountId"
],
"documentation": [
" Account_1 has been successfully recovered by account_2"
]
},
{
"name": "RecoveryRemoved",
"arguments": [
"AccountId"
],
"documentation": [
" A recovery process has been removed for an account"
]
}
],
"constants": [],
"errors": [
{
"name": "NotAllowed",
"documentation": [
" User is not allowed to make a call on behalf of this account"
]
},
{
"name": "ZeroThreshold",
"documentation": [
" Threshold must be greater than zero"
]
},
{
"name": "NotEnoughFriends",
"documentation": [
" Friends list must be greater than zero and threshold"
]
},
{
"name": "MaxFriends",
"documentation": [
" Friends list must be less than max friends"
]
},
{
"name": "NotSorted",
"documentation": [
" Friends list must be sorted and free of duplicates"
]
},
{
"name": "NotRecoverable",
"documentation": [
" This account is not set up for recovery"
]
},
{
"name": "AlreadyRecoverable",
"documentation": [
" This account is already set up for recovery"
]
},
{
"name": "AlreadyStarted",
"documentation": [
" A recovery process has already started for this account"
]
},
{
"name": "NotStarted",
"documentation": [
" A recovery process has not started for this rescuer"
]
},
{
"name": "NotFriend",
"documentation": [
" This account is not a friend who can vouch"
]
},
{
"name": "DelayPeriod",
"documentation": [
" The friend must wait until the delay period to vouch for this recovery"
]
},
{
"name": "AlreadyVouched",
"documentation": [
" This user has already vouched for this recovery"
]
},
{
"name": "Threshold",
"documentation": [
" The threshold for recovering this account has not been met"
]
},
{
"name": "StillActive",
"documentation": [
" There are still active recovery attempts that need to be closed"
]
},
{
"name": "Overflow",
"documentation": [
" There was an overflow in a calculation"
]
},
{
"name": "AlreadyProxy",
"documentation": [
" This account is already set up for recovery"
]
}
]
},
{
"name": "Vesting",
"storage": {
"prefix": "Vesting",
"entries": [
{
"name": "Vesting",
"modifier": "Optional",
"ty": {
"Map": {
"hasher": "Blake2_128Concat",
"key": "T::AccountId",
"value": "VestingInfo<BalanceOf<T>, T::BlockNumber>",
"unused": false
}
},
"default": [
0
],
"documentation": [
" Information regarding the vesting of a given account."
]
}
]
},
"calls": [
{
"name": "vest",
"arguments": [],
"documentation": [
" Unlock any vested funds of the sender account.",
"",
" The dispatch origin for this call must be _Signed_ and the sender must have funds still",
" locked under this module.",
"",
" Emits either `VestingCompleted` or `VestingUpdated`.",
"",
" # <weight>",
" - `O(1)`.",
" - One balance-lock operation.",
" - One storage read (codec `O(1)`) and up to one removal.",
" - One event.",
" # </weight>"
]
},
{
"name": "vest_other",
"arguments": [
{
"name": "target",
"ty": "<T::Lookup as StaticLookup>::Source"
}
],
"documentation": [
" Unlock any vested funds of a `target` account.",
"",
" The dispatch origin for this call must be _Signed_.",
"",
" - `target`: The account whose vested funds should be unlocked. Must have funds still",
" locked under this module.",
"",
" Emits either `VestingCompleted` or `VestingUpdated`.",
"",
" # <weight>",
" - `O(1)`.",
" - Up to one account lookup.",
" - One balance-lock operation.",
" - One storage read (codec `O(1)`) and up to one removal.",
" - One event.",
" # </weight>"
]
},
{
"name": "vested_transfer",
"arguments": [
{
"name": "target",
"ty": "<T::Lookup as StaticLookup>::Source"
},
{
"name": "schedule",
"ty": "VestingInfo<BalanceOf<T>, T::BlockNumber>"
}
],
"documentation": [
" Create a vested transfer.",
"",
" The dispatch origin for this call must be _Signed_.",
"",
" - `target`: The account that should be transferred the vested funds.",
" - `amount`: The amount of funds to transfer and will be vested.",
" - `schedule`: The vesting schedule attached to the transfer.",
"",
" Emits `VestingCreated`.",
"",
" # <weight>",
" - Creates a new storage entry, but is protected by a minimum transfer",
"\t amount needed to succeed.",
" # </weight>"
]
}
],
"event": [
{
"name": "VestingUpdated",
"arguments": [
"AccountId",
"Balance"
],
"documentation": [
" The amount vested has been updated. This could indicate more funds are available. The",
" balance given is the amount which is left unvested (and thus locked)."
]
},
{
"name": "VestingCompleted",
"arguments": [
"AccountId"
],
"documentation": [
" An account (given) has become fully vested. No further vesting can happen."
]
}
],
"constants": [
{
"name": "MinVestedTransfer",
"ty": "BalanceOf<T>",
"value": [
0,
64,
122,
16,
243,
90,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"documentation": [
" The minimum amount to be transferred to create a new vesting schedule."
]
}
],
"errors": [
{
"name": "NotVesting",
"documentation": [
" The account given is not vesting."
]
},
{
"name": "ExistingVestingSchedule",
"documentation": [
" An existing vesting schedule already exists for this account that cannot be clobbered."
]
},
{
"name": "AmountLow",
"documentation": [
" Amount being transferred is too low to create a vesting schedule."
]
}
]
}
],
"extrinsic": {
"version": 4,
"signed_extensions": [
"RestrictFunctionality",
"CheckVersion",
"CheckGenesis",
"CheckEra",
"CheckNonce",
"CheckWeight",
"ChargeTransactionPayment",
"LimitParathreadCommits"
]
}
}
}
]
Raw
meta_block_1768321_rust.txt
This file has been truncated, but you can view the full file.
RuntimeMetadataPrefixed(
1635018093,
RuntimeMetadata::V11(
RuntimeMetadataV11 {
modules: [
ModuleMetadata {
name: "System",
storage: Some(
StorageMetadata {
prefix: "System",
entries: [
StorageEntryMetadata {
name: "Account",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Map {
hasher: StorageHasher::Blake2_128Concat,
key: "T::AccountId",
value: "AccountInfo<T::Index, T::AccountData>",
unused: false,
},
default: [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
],
documentation: [
" The full account information for a particular account ID.",
],
},
StorageEntryMetadata {
name: "ExtrinsicCount",
modifier: StorageEntryModifier::Optional,
ty: StorageEntryType::Plain(
"u32",
),
default: [
0,
],
documentation: [
" Total extrinsics count for the current block.",
],
},
StorageEntryMetadata {
name: "AllExtrinsicsWeight",
modifier: StorageEntryModifier::Optional,
ty: StorageEntryType::Plain(
"Weight",
),
default: [
0,
],
documentation: [
" Total weight for all extrinsics put together, for the current block.",
],
},
StorageEntryMetadata {
name: "AllExtrinsicsLen",
modifier: StorageEntryModifier::Optional,
ty: StorageEntryType::Plain(
"u32",
),
default: [
0,
],
documentation: [
" Total length (in bytes) for all extrinsics put together, for the current block.",
],
},
StorageEntryMetadata {
name: "BlockHash",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Map {
hasher: StorageHasher::Twox64Concat,
key: "T::BlockNumber",
value: "T::Hash",
unused: false,
},
default: [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
],
documentation: [
" Map of block numbers to block hashes.",
],
},
StorageEntryMetadata {
name: "ExtrinsicData",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Map {
hasher: StorageHasher::Twox64Concat,
key: "u32",
value: "Vec<u8>",
unused: false,
},
default: [
0,
],
documentation: [
" Extrinsics data for the current block (maps an extrinsic\'s index to its data).",
],
},
StorageEntryMetadata {
name: "Number",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Plain(
"T::BlockNumber",
),
default: [
0,
0,
0,
0,
],
documentation: [
" The current block number being processed. Set by `execute_block`.",
],
},
StorageEntryMetadata {
name: "ParentHash",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Plain(
"T::Hash",
),
default: [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
],
documentation: [
" Hash of the previous block.",
],
},
StorageEntryMetadata {
name: "ExtrinsicsRoot",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Plain(
"T::Hash",
),
default: [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
],
documentation: [
" Extrinsics root of the current block, also part of the block header.",
],
},
StorageEntryMetadata {
name: "Digest",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Plain(
"DigestOf<T>",
),
default: [
0,
],
documentation: [
" Digest of the current block, also part of the block header.",
],
},
StorageEntryMetadata {
name: "Events",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Plain(
"Vec<EventRecord<T::Event, T::Hash>>",
),
default: [
0,
],
documentation: [
" Events deposited for the current block.",
],
},
StorageEntryMetadata {
name: "EventCount",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Plain(
"EventIndex",
),
default: [
0,
0,
0,
0,
],
documentation: [
" The number of events in the `Events<T>` list.",
],
},
StorageEntryMetadata {
name: "EventTopics",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Map {
hasher: StorageHasher::Blake2_128Concat,
key: "T::Hash",
value: "Vec<(T::BlockNumber, EventIndex)>",
unused: false,
},
default: [
0,
],
documentation: [
" Mapping between a topic (represented by T::Hash) and a vector of indexes",
" of events in the `<Events<T>>` list.",
"",
" All topic vectors have deterministic storage locations depending on the topic. This",
" allows light-clients to leverage the changes trie storage tracking mechanism and",
" in case of changes fetch the list of events of interest.",
"",
" The value has the type `(T::BlockNumber, EventIndex)` because if we used only just",
" the `EventIndex` then in case if the topic has the same contents on the next block",
" no notification will be triggered thus the event might be lost.",
],
},
StorageEntryMetadata {
name: "LastRuntimeUpgrade",
modifier: StorageEntryModifier::Optional,
ty: StorageEntryType::Plain(
"LastRuntimeUpgradeInfo",
),
default: [
0,
],
documentation: [
" Stores the `spec_version` and `spec_name` of when the last runtime upgrade happened.",
],
},
StorageEntryMetadata {
name: "ExecutionPhase",
modifier: StorageEntryModifier::Optional,
ty: StorageEntryType::Plain(
"Phase",
),
default: [
0,
],
documentation: [
" The execution phase of the block.",
],
},
],
},
),
calls: Some(
[
FunctionMetadata {
name: "fill_block",
arguments: [
FunctionArgumentMetadata {
name: "_ratio",
ty: "Perbill",
},
],
documentation: [
" A dispatch that will fill the block weight up to the given ratio.",
],
},
FunctionMetadata {
name: "remark",
arguments: [
FunctionArgumentMetadata {
name: "_remark",
ty: "Vec<u8>",
},
],
documentation: [
" Make some on-chain remark.",
],
},
FunctionMetadata {
name: "set_heap_pages",
arguments: [
FunctionArgumentMetadata {
name: "pages",
ty: "u64",
},
],
documentation: [
" Set the number of pages in the WebAssembly environment\'s heap.",
],
},
FunctionMetadata {
name: "set_code",
arguments: [
FunctionArgumentMetadata {
name: "code",
ty: "Vec<u8>",
},
],
documentation: [
" Set the new runtime code.",
],
},
FunctionMetadata {
name: "set_code_without_checks",
arguments: [
FunctionArgumentMetadata {
name: "code",
ty: "Vec<u8>",
},
],
documentation: [
" Set the new runtime code without doing any checks of the given `code`.",
],
},
FunctionMetadata {
name: "set_changes_trie_config",
arguments: [
FunctionArgumentMetadata {
name: "changes_trie_config",
ty: "Option<ChangesTrieConfiguration>",
},
],
documentation: [
" Set the new changes trie configuration.",
],
},
FunctionMetadata {
name: "set_storage",
arguments: [
FunctionArgumentMetadata {
name: "items",
ty: "Vec<KeyValue>",
},
],
documentation: [
" Set some items of storage.",
],
},
FunctionMetadata {
name: "kill_storage",
arguments: [
FunctionArgumentMetadata {
name: "keys",
ty: "Vec<Key>",
},
],
documentation: [
" Kill some items from storage.",
],
},
FunctionMetadata {
name: "kill_prefix",
arguments: [
FunctionArgumentMetadata {
name: "prefix",
ty: "Key",
},
],
documentation: [
" Kill all storage items with a key that starts with the given prefix.",
],
},
FunctionMetadata {
name: "suicide",
arguments: [],
documentation: [
" Kill the sending account, assuming there are no references outstanding and the composite",
" data is equal to its default value.",
],
},
],
),
event: Some(
[
EventMetadata {
name: "ExtrinsicSuccess",
arguments: [
"DispatchInfo",
],
documentation: [
" An extrinsic completed successfully.",
],
},
EventMetadata {
name: "ExtrinsicFailed",
arguments: [
"DispatchError",
"DispatchInfo",
],
documentation: [
" An extrinsic failed.",
],
},
EventMetadata {
name: "CodeUpdated",
arguments: [],
documentation: [
" `:code` was updated.",
],
},
EventMetadata {
name: "NewAccount",
arguments: [
"AccountId",
],
documentation: [
" A new account was created.",
],
},
EventMetadata {
name: "KilledAccount",
arguments: [
"AccountId",
],
documentation: [
" An account was reaped.",
],
},
],
),
constants: [],
errors: [
ErrorMetadata {
name: "InvalidSpecName",
documentation: [
" The name of specification does not match between the current runtime",
" and the new runtime.",
],
},
ErrorMetadata {
name: "SpecVersionNeedsToIncrease",
documentation: [
" The specification version is not allowed to decrease between the current runtime",
" and the new runtime.",
],
},
ErrorMetadata {
name: "FailedToExtractRuntimeVersion",
documentation: [
" Failed to extract the runtime version from the new runtime.",
"",
" Either calling `Core_version` or decoding `RuntimeVersion` failed.",
],
},
ErrorMetadata {
name: "NonDefaultComposite",
documentation: [
" Suicide called when the account has non-default composite data.",
],
},
ErrorMetadata {
name: "NonZeroRefCount",
documentation: [
" There is a non-zero reference count preventing the account from being purged.",
],
},
],
},
ModuleMetadata {
name: "RandomnessCollectiveFlip",
storage: Some(
StorageMetadata {
prefix: "RandomnessCollectiveFlip",
entries: [
StorageEntryMetadata {
name: "RandomMaterial",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Plain(
"Vec<T::Hash>",
),
default: [
0,
],
documentation: [
" Series of block headers from the last 81 blocks that acts as random seed material. This",
" is arranged as a ring buffer with `block_number % 81` being the index into the `Vec` of",
" the oldest hash.",
],
},
],
},
),
calls: None,
event: None,
constants: [],
errors: [],
},
ModuleMetadata {
name: "Babe",
storage: Some(
StorageMetadata {
prefix: "Babe",
entries: [
StorageEntryMetadata {
name: "EpochIndex",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Plain(
"u64",
),
default: [
0,
0,
0,
0,
0,
0,
0,
0,
],
documentation: [
" Current epoch index.",
],
},
StorageEntryMetadata {
name: "Authorities",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Plain(
"Vec<(AuthorityId, BabeAuthorityWeight)>",
),
default: [
0,
],
documentation: [
" Current epoch authorities.",
],
},
StorageEntryMetadata {
name: "GenesisSlot",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Plain(
"u64",
),
default: [
0,
0,
0,
0,
0,
0,
0,
0,
],
documentation: [
" The slot at which the first epoch actually started. This is 0",
" until the first block of the chain.",
],
},
StorageEntryMetadata {
name: "CurrentSlot",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Plain(
"u64",
),
default: [
0,
0,
0,
0,
0,
0,
0,
0,
],
documentation: [
" Current slot number.",
],
},
StorageEntryMetadata {
name: "Randomness",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Plain(
"[u8; 32]",
),
default: [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
],
documentation: [
" The epoch randomness for the *current* epoch.",
"",
" # Security",
"",
" This MUST NOT be used for gambling, as it can be influenced by a",
" malicious validator in the short term. It MAY be used in many",
" cryptographic protocols, however, so long as one remembers that this",
" (like everything else on-chain) it is public. For example, it can be",
" used where a number is needed that cannot have been chosen by an",
" adversary, for purposes such as public-coin zero-knowledge proofs.",
],
},
StorageEntryMetadata {
name: "NextRandomness",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Plain(
"[u8; 32]",
),
default: [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
],
documentation: [
" Next epoch randomness.",
],
},
StorageEntryMetadata {
name: "SegmentIndex",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Plain(
"u32",
),
default: [
0,
0,
0,
0,
],
documentation: [
" Randomness under construction.",
"",
" We make a tradeoff between storage accesses and list length.",
" We store the under-construction randomness in segments of up to",
" `UNDER_CONSTRUCTION_SEGMENT_LENGTH`.",
"",
" Once a segment reaches this length, we begin the next one.",
" We reset all segments and return to `0` at the beginning of every",
" epoch.",
],
},
StorageEntryMetadata {
name: "UnderConstruction",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Map {
hasher: StorageHasher::Twox64Concat,
key: "u32",
value: "Vec<[u8; 32]>",
unused: false,
},
default: [
0,
],
documentation: [],
},
StorageEntryMetadata {
name: "Initialized",
modifier: StorageEntryModifier::Optional,
ty: StorageEntryType::Plain(
"MaybeVrf",
),
default: [
0,
],
documentation: [
" Temporary value (cleared at block finalization) which is `Some`",
" if per-block initialization has already been called for current block.",
],
},
],
},
),
calls: Some(
[],
),
event: None,
constants: [
ModuleConstantMetadata {
name: "EpochDuration",
ty: "u64",
value: [
88,
2,
0,
0,
0,
0,
0,
0,
],
documentation: [
" The number of **slots** that an epoch takes. We couple sessions to",
" epochs, i.e. we start a new session once the new epoch begins.",
],
},
ModuleConstantMetadata {
name: "ExpectedBlockTime",
ty: "T::Moment",
value: [
112,
23,
0,
0,
0,
0,
0,
0,
],
documentation: [
" The expected average block time at which BABE should be creating",
" blocks. Since BABE is probabilistic it is not trivial to figure out",
" what the expected average block time should be based on the slot",
" duration and the security parameter `c` (where `1 - c` represents",
" the probability of a slot being empty).",
],
},
],
errors: [],
},
ModuleMetadata {
name: "Timestamp",
storage: Some(
StorageMetadata {
prefix: "Timestamp",
entries: [
StorageEntryMetadata {
name: "Now",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Plain(
"T::Moment",
),
default: [
0,
0,
0,
0,
0,
0,
0,
0,
],
documentation: [
" Current time for the current block.",
],
},
StorageEntryMetadata {
name: "DidUpdate",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Plain(
"bool",
),
default: [
0,
],
documentation: [
" Did the timestamp get updated in this block?",
],
},
],
},
),
calls: Some(
[
FunctionMetadata {
name: "set",
arguments: [
FunctionArgumentMetadata {
name: "now",
ty: "Compact<T::Moment>",
},
],
documentation: [
" 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`.",
],
},
],
),
event: None,
constants: [
ModuleConstantMetadata {
name: "MinimumPeriod",
ty: "T::Moment",
value: [
184,
11,
0,
0,
0,
0,
0,
0,
],
documentation: [
" The minimum period between blocks. Beware that this is different to the *expected* period",
" that the block production apparatus provides. Your chosen consensus system will generally",
" work with this to determine a sensible block time. e.g. For Aura, it will be double this",
" period on default settings.",
],
},
],
errors: [],
},
ModuleMetadata {
name: "Indices",
storage: Some(
StorageMetadata {
prefix: "Indices",
entries: [
StorageEntryMetadata {
name: "Accounts",
modifier: StorageEntryModifier::Optional,
ty: StorageEntryType::Map {
hasher: StorageHasher::Blake2_128Concat,
key: "T::AccountIndex",
value: "(T::AccountId, BalanceOf<T>)",
unused: false,
},
default: [
0,
],
documentation: [
" The lookup from index to account.",
],
},
],
},
),
calls: Some(
[
FunctionMetadata {
name: "claim",
arguments: [
FunctionArgumentMetadata {
name: "index",
ty: "T::AccountIndex",
},
],
documentation: [
" 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.",
" # </weight>",
],
},
FunctionMetadata {
name: "transfer",
arguments: [
FunctionArgumentMetadata {
name: "new",
ty: "T::AccountId",
},
FunctionArgumentMetadata {
name: "index",
ty: "T::AccountIndex",
},
],
documentation: [
" 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.",
" # </weight>",
],
},
FunctionMetadata {
name: "free",
arguments: [
FunctionArgumentMetadata {
name: "index",
ty: "T::AccountIndex",
},
],
documentation: [
" 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.",
" # </weight>",
],
},
FunctionMetadata {
name: "force_transfer",
arguments: [
FunctionArgumentMetadata {
name: "new",
ty: "T::AccountId",
},
FunctionArgumentMetadata {
name: "index",
ty: "T::AccountIndex",
},
],
documentation: [
" 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.",
"",
" Emits `IndexAssigned` if successful.",
"",
" # <weight>",
" - `O(1)`.",
" - One storage mutation (codec `O(1)`).",
" - Up to one reserve operation.",
" - One event.",
" # </weight>",
],
},
],
),
event: Some(
[
EventMetadata {
name: "IndexAssigned",
arguments: [
"AccountId",
"AccountIndex",
],
documentation: [
" A account index was assigned.",
],
},
EventMetadata {
name: "IndexFreed",
arguments: [
"AccountIndex",
],
documentation: [
" A account index has been freed up (unassigned).",
],
},
],
),
constants: [],
errors: [],
},
ModuleMetadata {
name: "Balances",
storage: Some(
StorageMetadata {
prefix: "Balances",
entries: [
StorageEntryMetadata {
name: "TotalIssuance",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Plain(
"T::Balance",
),
default: [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
],
documentation: [
" The total units issued in the system.",
],
},
StorageEntryMetadata {
name: "Account",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Map {
hasher: StorageHasher::Blake2_128Concat,
key: "T::AccountId",
value: "AccountData<T::Balance>",
unused: false,
},
default: [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
],
documentation: [
" The balance of an account.",
"",
" NOTE: THIS MAY NEVER BE IN EXISTENCE AND YET HAVE A `total().is_zero()`. If the total",
" is ever zero, then the entry *MUST* be removed.",
"",
" NOTE: This is only used in the case that this module is used to store balances.",
],
},
StorageEntryMetadata {
name: "Locks",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Map {
hasher: StorageHasher::Blake2_128Concat,
key: "T::AccountId",
value: "Vec<BalanceLock<T::Balance>>",
unused: false,
},
default: [
0,
],
documentation: [
" Any liquidity locks on some account balances.",
" NOTE: Should only be accessed when setting, changing and freeing a lock.",
],
},
StorageEntryMetadata {
name: "StorageVersion",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Plain(
"Releases",
),
default: [
0,
],
documentation: [
" Storage version of the pallet.",
"",
" This is set to v2.0.0 for new networks.",
],
},
],
},
),
calls: Some(
[
FunctionMetadata {
name: "transfer",
arguments: [
FunctionArgumentMetadata {
name: "dest",
ty: "<T::Lookup as StaticLookup>::Source",
},
FunctionArgumentMetadata {
name: "value",
ty: "Compact<T::Balance>",
},
],
documentation: [
" 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.",
"",
" # </weight>",
],
},
FunctionMetadata {
name: "set_balance",
arguments: [
FunctionArgumentMetadata {
name: "who",
ty: "<T::Lookup as StaticLookup>::Source",
},
FunctionArgumentMetadata {
name: "new_free",
ty: "Compact<T::Balance>",
},
FunctionArgumentMetadata {
name: "new_reserved",
ty: "Compact<T::Balance>",
},
],
documentation: [
" 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`.",
"",
" # <weight>",
" - Independent of the arguments.",
" - Contains a limited number of reads and writes.",
" # </weight>",
],
},
FunctionMetadata {
name: "force_transfer",
arguments: [
FunctionArgumentMetadata {
name: "source",
ty: "<T::Lookup as StaticLookup>::Source",
},
FunctionArgumentMetadata {
name: "dest",
ty: "<T::Lookup as StaticLookup>::Source",
},
FunctionArgumentMetadata {
name: "value",
ty: "Compact<T::Balance>",
},
],
documentation: [
" Exactly as `transfer`, except the origin must be root and the source account may be",
" specified.",
],
},
FunctionMetadata {
name: "transfer_keep_alive",
arguments: [
FunctionArgumentMetadata {
name: "dest",
ty: "<T::Lookup as StaticLookup>::Source",
},
FunctionArgumentMetadata {
name: "value",
ty: "Compact<T::Balance>",
},
],
documentation: [
" 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.Module.html#method.transfer",
],
},
],
),
event: Some(
[
EventMetadata {
name: "Endowed",
arguments: [
"AccountId",
"Balance",
],
documentation: [
" An account was created with some free balance.",
],
},
EventMetadata {
name: "DustLost",
arguments: [
"AccountId",
"Balance",
],
documentation: [
" An account was removed whose balance was non-zero but below ExistentialDeposit,",
" resulting in an outright loss.",
],
},
EventMetadata {
name: "Transfer",
arguments: [
"AccountId",
"AccountId",
"Balance",
],
documentation: [
" Transfer succeeded (from, to, value).",
],
},
EventMetadata {
name: "BalanceSet",
arguments: [
"AccountId",
"Balance",
"Balance",
],
documentation: [
" A balance was set by root (who, free, reserved).",
],
},
EventMetadata {
name: "Deposit",
arguments: [
"AccountId",
"Balance",
],
documentation: [
" Some amount was deposited (e.g. for transaction fees).",
],
},
],
),
constants: [
ModuleConstantMetadata {
name: "ExistentialDeposit",
ty: "T::Balance",
value: [
0,
228,
11,
84,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
],
documentation: [
" The minimum amount required to keep an account open.",
],
},
],
errors: [
ErrorMetadata {
name: "VestingBalance",
documentation: [
" Vesting balance too high to send value",
],
},
ErrorMetadata {
name: "LiquidityRestrictions",
documentation: [
" Account liquidity restrictions prevent withdrawal",
],
},
ErrorMetadata {
name: "Overflow",
documentation: [
" Got an overflow after adding",
],
},
ErrorMetadata {
name: "InsufficientBalance",
documentation: [
" Balance too low to send value",
],
},
ErrorMetadata {
name: "ExistentialDeposit",
documentation: [
" Value too low to create account due to existential deposit",
],
},
ErrorMetadata {
name: "KeepAlive",
documentation: [
" Transfer/payment would kill account",
],
},
ErrorMetadata {
name: "ExistingVestingSchedule",
documentation: [
" A vesting schedule already exists for this account",
],
},
ErrorMetadata {
name: "DeadAccount",
documentation: [
" Beneficiary account must pre-exist",
],
},
],
},
ModuleMetadata {
name: "TransactionPayment",
storage: Some(
StorageMetadata {
prefix: "TransactionPayment",
entries: [
StorageEntryMetadata {
name: "NextFeeMultiplier",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Plain(
"Multiplier",
),
default: [
0,
0,
0,
0,
0,
0,
0,
0,
],
documentation: [],
},
],
},
),
calls: None,
event: None,
constants: [
ModuleConstantMetadata {
name: "TransactionBaseFee",
ty: "BalanceOf<T>",
value: [
0,
228,
11,
84,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
],
documentation: [
" The fee to be paid for making a transaction; the base.",
],
},
ModuleConstantMetadata {
name: "TransactionByteFee",
ty: "BalanceOf<T>",
value: [
0,
225,
245,
5,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
],
documentation: [
" The fee to be paid for making a transaction; the per-byte portion.",
],
},
],
errors: [],
},
ModuleMetadata {
name: "Authorship",
storage: Some(
StorageMetadata {
prefix: "Authorship",
entries: [
StorageEntryMetadata {
name: "Uncles",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Plain(
"Vec<UncleEntryItem<T::BlockNumber, T::Hash, T::AccountId>>",
),
default: [
0,
],
documentation: [
" Uncles",
],
},
StorageEntryMetadata {
name: "Author",
modifier: StorageEntryModifier::Optional,
ty: StorageEntryType::Plain(
"T::AccountId",
),
default: [
0,
],
documentation: [
" Author of current block.",
],
},
StorageEntryMetadata {
name: "DidSetUncles",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Plain(
"bool",
),
default: [
0,
],
documentation: [
" Whether uncles were already set in this block.",
],
},
],
},
),
calls: Some(
[
FunctionMetadata {
name: "set_uncles",
arguments: [
FunctionArgumentMetadata {
name: "new_uncles",
ty: "Vec<T::Header>",
},
],
documentation: [
" Provide a set of uncles.",
],
},
],
),
event: None,
constants: [],
errors: [
ErrorMetadata {
name: "InvalidUncleParent",
documentation: [
" The uncle parent not in the chain.",
],
},
ErrorMetadata {
name: "UnclesAlreadySet",
documentation: [
" Uncles already set in the block.",
],
},
ErrorMetadata {
name: "TooManyUncles",
documentation: [
" Too many uncles.",
],
},
ErrorMetadata {
name: "GenesisUncle",
documentation: [
" The uncle is genesis.",
],
},
ErrorMetadata {
name: "TooHighUncle",
documentation: [
" The uncle is too high in chain.",
],
},
ErrorMetadata {
name: "UncleAlreadyIncluded",
documentation: [
" The uncle is already included.",
],
},
ErrorMetadata {
name: "OldUncle",
documentation: [
" The uncle isn\'t recent enough to be included.",
],
},
],
},
ModuleMetadata {
name: "Staking",
storage: Some(
StorageMetadata {
prefix: "Staking",
entries: [
StorageEntryMetadata {
name: "HistoryDepth",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Plain(
"u32",
),
default: [
84,
0,
0,
0,
],
documentation: [
" Number of era to keep in history.",
"",
" Information is kept for eras in `[current_era - history_depth; current_era]",
"",
" Must be more than the number of era delayed by session otherwise.",
" i.e. active era must always be in history.",
" i.e. `active_era > current_era - history_depth` must be guaranteed.",
],
},
StorageEntryMetadata {
name: "ValidatorCount",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Plain(
"u32",
),
default: [
0,
0,
0,
0,
],
documentation: [
" The ideal number of staking participants.",
],
},
StorageEntryMetadata {
name: "MinimumValidatorCount",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Plain(
"u32",
),
default: [
4,
0,
0,
0,
],
documentation: [
" Minimum number of staking participants before emergency conditions are imposed.",
],
},
StorageEntryMetadata {
name: "Invulnerables",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Plain(
"Vec<T::AccountId>",
),
default: [
0,
],
documentation: [
" Any validators that may never be slashed or forcibly kicked. It\'s a Vec since they\'re",
" easy to initialize and the performance hit is minimal (we expect no more than four",
" invulnerables) and restricted to testnets.",
],
},
StorageEntryMetadata {
name: "Bonded",
modifier: StorageEntryModifier::Optional,
ty: StorageEntryType::Map {
hasher: StorageHasher::Twox64Concat,
key: "T::AccountId",
value: "T::AccountId",
unused: false,
},
default: [
0,
],
documentation: [
" Map from all locked \"stash\" accounts to the controller account.",
],
},
StorageEntryMetadata {
name: "Ledger",
modifier: StorageEntryModifier::Optional,
ty: StorageEntryType::Map {
hasher: StorageHasher::Blake2_128Concat,
key: "T::AccountId",
value: "StakingLedger<T::AccountId, BalanceOf<T>>",
unused: false,
},
default: [
0,
],
documentation: [
" Map from all (unlocked) \"controller\" accounts to the info regarding the staking.",
],
},
StorageEntryMetadata {
name: "Payee",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Map {
hasher: StorageHasher::Twox64Concat,
key: "T::AccountId",
value: "RewardDestination",
unused: false,
},
default: [
0,
],
documentation: [
" Where the reward payment should be made. Keyed by stash.",
],
},
StorageEntryMetadata {
name: "Validators",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Map {
hasher: StorageHasher::Twox64Concat,
key: "T::AccountId",
value: "ValidatorPrefs",
unused: false,
},
default: [
0,
],
documentation: [
" The map from (wannabe) validator stash key to the preferences of that validator.",
],
},
StorageEntryMetadata {
name: "Nominators",
modifier: StorageEntryModifier::Optional,
ty: StorageEntryType::Map {
hasher: StorageHasher::Twox64Concat,
key: "T::AccountId",
value: "Nominations<T::AccountId>",
unused: false,
},
default: [
0,
],
documentation: [
" The map from nominator stash key to the set of stash keys of all validators to nominate.",
],
},
StorageEntryMetadata {
name: "CurrentEra",
modifier: StorageEntryModifier::Optional,
ty: StorageEntryType::Plain(
"EraIndex",
),
default: [
0,
],
documentation: [
" The current era index.",
"",
" This is the latest planned era, depending on how session module queues the validator",
" set, it might be active or not.",
],
},
StorageEntryMetadata {
name: "ActiveEra",
modifier: StorageEntryModifier::Optional,
ty: StorageEntryType::Plain(
"ActiveEraInfo<MomentOf<T>>",
),
default: [
0,
],
documentation: [
" The active era information, it holds index and start.",
"",
" The active era is the era currently rewarded.",
" Validator set of this era must be equal to `SessionInterface::validators`.",
],
},
StorageEntryMetadata {
name: "ErasStartSessionIndex",
modifier: StorageEntryModifier::Optional,
ty: StorageEntryType::Map {
hasher: StorageHasher::Twox64Concat,
key: "EraIndex",
value: "SessionIndex",
unused: false,
},
default: [
0,
],
documentation: [
" The session index at which the era start for the last `HISTORY_DEPTH` eras",
],
},
StorageEntryMetadata {
name: "ErasStakers",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::DoubleMap {
hasher: StorageHasher::Twox64Concat,
key1: "EraIndex",
key2: "T::AccountId",
value: "Exposure<T::AccountId, BalanceOf<T>>",
key2_hasher: StorageHasher::Twox64Concat,
},
default: [
0,
0,
0,
],
documentation: [
" Exposure of validator at era.",
"",
" This is keyed first by the era index to allow bulk deletion and then the stash account.",
"",
" Is it removed after `HISTORY_DEPTH` eras.",
" If stakers hasn\'t been set or has been removed then empty exposure is returned.",
],
},
StorageEntryMetadata {
name: "ErasStakersClipped",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::DoubleMap {
hasher: StorageHasher::Twox64Concat,
key1: "EraIndex",
key2: "T::AccountId",
value: "Exposure<T::AccountId, BalanceOf<T>>",
key2_hasher: StorageHasher::Twox64Concat,
},
default: [
0,
0,
0,
],
documentation: [
" Clipped Exposure of validator at era.",
"",
" This is similar to [`ErasStakers`] but number of nominators exposed is reduce to the",
" `T::MaxNominatorRewardedPerValidator` biggest stakers.",
" (Note: the field `total` and `own` of the exposure remains unchanged).",
" This is used to limit the i/o cost for the nominator payout.",
"",
" This is keyed fist by the era index to allow bulk deletion and then the stash account.",
"",
" Is it removed after `HISTORY_DEPTH` eras.",
" If stakers hasn\'t been set or has been removed then empty exposure is returned.",
],
},
StorageEntryMetadata {
name: "ErasValidatorPrefs",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::DoubleMap {
hasher: StorageHasher::Twox64Concat,
key1: "EraIndex",
key2: "T::AccountId",
value: "ValidatorPrefs",
key2_hasher: StorageHasher::Twox64Concat,
},
default: [
0,
],
documentation: [
" Similarly to `ErasStakers` this holds the preferences of validators.",
"",
" This is keyed first by the era index to allow bulk deletion and then the stash account.",
"",
" Is it removed after `HISTORY_DEPTH` eras.",
],
},
StorageEntryMetadata {
name: "ErasValidatorReward",
modifier: StorageEntryModifier::Optional,
ty: StorageEntryType::Map {
hasher: StorageHasher::Twox64Concat,
key: "EraIndex",
value: "BalanceOf<T>",
unused: false,
},
default: [
0,
],
documentation: [
" The total validator era payout for the last `HISTORY_DEPTH` eras.",
"",
" Eras that haven\'t finished yet or has been removed doesn\'t have reward.",
],
},
StorageEntryMetadata {
name: "ErasRewardPoints",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Map {
hasher: StorageHasher::Twox64Concat,
key: "EraIndex",
value: "EraRewardPoints<T::AccountId>",
unused: false,
},
default: [
0,
0,
0,
0,
0,
],
documentation: [
" Rewards for the last `HISTORY_DEPTH` eras.",
" If reward hasn\'t been set or has been removed then 0 reward is returned.",
],
},
StorageEntryMetadata {
name: "ErasTotalStake",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Map {
hasher: StorageHasher::Twox64Concat,
key: "EraIndex",
value: "BalanceOf<T>",
unused: false,
},
default: [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
],
documentation: [
" The total amount staked for the last `HISTORY_DEPTH` eras.",
" If total hasn\'t been set or has been removed then 0 stake is returned.",
],
},
StorageEntryMetadata {
name: "ForceEra",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Plain(
"Forcing",
),
default: [
0,
],
documentation: [
" True if the next session change will be a new era regardless of index.",
],
},
StorageEntryMetadata {
name: "SlashRewardFraction",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Plain(
"Perbill",
),
default: [
0,
0,
0,
0,
],
documentation: [
" The percentage of the slash that is distributed to reporters.",
"",
" The rest of the slashed value is handled by the `Slash`.",
],
},
StorageEntryMetadata {
name: "CanceledSlashPayout",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Plain(
"BalanceOf<T>",
),
default: [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
],
documentation: [
" The amount of currency given to reporters of a slash event which was",
" canceled by extraordinary circumstances (e.g. governance).",
],
},
StorageEntryMetadata {
name: "UnappliedSlashes",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Map {
hasher: StorageHasher::Twox64Concat,
key: "EraIndex",
value: "Vec<UnappliedSlash<T::AccountId, BalanceOf<T>>>",
unused: false,
},
default: [
0,
],
documentation: [
" All unapplied slashes that are queued for later.",
],
},
StorageEntryMetadata {
name: "BondedEras",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Plain(
"Vec<(EraIndex, SessionIndex)>",
),
default: [
0,
],
documentation: [
" A mapping from still-bonded eras to the first session index of that era.",
"",
" Must contains information for eras for the range:",
" `[active_era - bounding_duration; active_era]`",
],
},
StorageEntryMetadata {
name: "ValidatorSlashInEra",
modifier: StorageEntryModifier::Optional,
ty: StorageEntryType::DoubleMap {
hasher: StorageHasher::Twox64Concat,
key1: "EraIndex",
key2: "T::AccountId",
value: "(Perbill, BalanceOf<T>)",
key2_hasher: StorageHasher::Twox64Concat,
},
default: [
0,
],
documentation: [
" All slashing events on validators, mapped by era to the highest slash proportion",
" and slash value of the era.",
],
},
StorageEntryMetadata {
name: "NominatorSlashInEra",
modifier: StorageEntryModifier::Optional,
ty: StorageEntryType::DoubleMap {
hasher: StorageHasher::Twox64Concat,
key1: "EraIndex",
key2: "T::AccountId",
value: "BalanceOf<T>",
key2_hasher: StorageHasher::Twox64Concat,
},
default: [
0,
],
documentation: [
" All slashing events on nominators, mapped by era to the highest slash value of the era.",
],
},
StorageEntryMetadata {
name: "SlashingSpans",
modifier: StorageEntryModifier::Optional,
ty: StorageEntryType::Map {
hasher: StorageHasher::Twox64Concat,
key: "T::AccountId",
value: "slashing::SlashingSpans",
unused: false,
},
default: [
0,
],
documentation: [
" Slashing spans for stash accounts.",
],
},
StorageEntryMetadata {
name: "SpanSlash",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Map {
hasher: StorageHasher::Twox64Concat,
key: "(T::AccountId, slashing::SpanIndex)",
value: "slashing::SpanRecord<BalanceOf<T>>",
unused: false,
},
default: [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
],
documentation: [
" Records information about the maximum slash of a stash within a slashing span,",
" as well as how much reward has been paid out.",
],
},
StorageEntryMetadata {
name: "EarliestUnappliedSlash",
modifier: StorageEntryModifier::Optional,
ty: StorageEntryType::Plain(
"EraIndex",
),
default: [
0,
],
documentation: [
" The earliest era for which we have a pending, unapplied slash.",
],
},
StorageEntryMetadata {
name: "StorageVersion",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Plain(
"Releases",
),
default: [
1,
],
documentation: [
" Storage version of the pallet.",
"",
" This is set to v2.0.0 for new networks.",
],
},
],
},
),
calls: Some(
[
FunctionMetadata {
name: "bond",
arguments: [
FunctionArgumentMetadata {
name: "controller",
ty: "<T::Lookup as StaticLookup>::Source",
},
FunctionArgumentMetadata {
name: "value",
ty: "Compact<BalanceOf<T>>",
},
FunctionArgumentMetadata {
name: "payee",
ty: "RewardDestination",
},
],
documentation: [
" 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>",
],
},
FunctionMetadata {
name: "bond_extra",
arguments: [
FunctionArgumentMetadata {
name: "max_additional",
ty: "Compact<BalanceOf<T>>",
},
],
documentation: [
" Add some extra amount that have appeared in the stash `free_balance` into the balance up",
" for staking.",
"",
" Use this if there are additional funds in your stash account that you wish to bond.",
" Unlike [`bond`] or [`unbond`] this function does not impose any limitation on the amount",
" that can be added.",
"",
" The dispatch origin for this call must be _Signed_ by the stash, not the controller.",
"",
" Emits `Bonded`.",
"",
" # <weight>",
" - Independent of the arguments. Insignificant complexity.",
" - O(1).",
" - One DB entry.",
" # </weight>",
],
},
FunctionMetadata {
name: "unbond",
arguments: [
FunctionArgumentMetadata {
name: "value",
ty: "Compact<BalanceOf<T>>",
},
],
documentation: [
" Schedule a portion of the stash to be unlocked ready for transfer out after the bond",
" period ends. If this leaves an amount actively bonded less than",
" T::Currency::minimum_balance(), then it is increased to the full amount.",
"",
" Once the unlock period is done, you can call `withdraw_unbonded` to actually move",
" the funds out of management ready for transfer.",
"",
" No more than a limited number of unlocking chunks (see `MAX_UNLOCKING_CHUNKS`)",
" can co-exists at the same time. In that case, [`Call::withdraw_unbonded`] need",
" to be called first to remove some of the chunks (if possible).",
"",
" The dispatch origin for this call must be _Signed_ by the controller, not the stash.",
"",
" Emits `Unbonded`.",
"",
" See also [`Call::withdraw_unbonded`].",
"",
" # <weight>",
" - Independent of the arguments. Limited but potentially exploitable complexity.",
" - Contains a limited number of reads.",
" - Each call (requires the remainder of the bonded balance to be above `minimum_balance`)",
" will cause a new entry to be inserted into a vector (`Ledger.unlocking`) kept in storage.",
" The only way to clean the aforementioned storage item is also user-controlled via",
" `withdraw_unbonded`.",
" - One DB entry.",
" </weight>",
],
},
FunctionMetadata {
name: "withdraw_unbonded",
arguments: [],
documentation: [
" Remove any unlocked chunks from the `unlocking` queue from our management.",
"",
" This essentially frees up that balance to be used by the stash account to do",
" whatever it wants.",
"",
" The dispatch origin for this call must be _Signed_ by the controller, not the stash.",
"",
" Emits `Withdrawn`.",
"",
" See also [`Call::unbond`].",
"",
" # <weight>",
" - Could be dependent on the `origin` argument and how much `unlocking` chunks exist.",
" It implies `consolidate_unlocked` which loops over `Ledger.unlocking`, which is",
" indirectly user-controlled. See [`unbond`] for more detail.",
" - Contains a limited number of reads, yet the size of which could be large based on `ledger`.",
" - Writes are limited to the `origin` account key.",
" # </weight>",
],
},
FunctionMetadata {
name: "validate",
arguments: [
FunctionArgumentMetadata {
name: "prefs",
ty: "ValidatorPrefs",
},
],
documentation: [
" 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.",
"",
" # <weight>",
" - Independent of the arguments. Insignificant complexity.",
" - Contains a limited number of reads.",
" - Writes are limited to the `origin` account key.",
" # </weight>",
],
},
FunctionMetadata {
name: "nominate",
arguments: [
FunctionArgumentMetadata {
name: "targets",
ty: "Vec<<T::Lookup as StaticLookup>::Source>",
},
],
documentation: [
" 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`,",
" which is capped at `MAX_NOMINATIONS`.",
" - Both the reads and writes follow a similar pattern.",
" # </weight>",
],
},
FunctionMetadata {
name: "chill",
arguments: [],
documentation: [
" 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>",
],
},
FunctionMetadata {
name: "set_payee",
arguments: [
FunctionArgumentMetadata {
name: "payee",
ty: "RewardDestination",
},
],
documentation: [
" (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>",
],
},
FunctionMetadata {
name: "set_controller",
arguments: [
FunctionArgumentMetadata {
name: "controller",
ty: "<T::Lookup as StaticLookup>::Source",
},
],
documentation: [
" (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>",
],
},
FunctionMetadata {
name: "set_validator_count",
arguments: [
FunctionArgumentMetadata {
name: "new",
ty: "Compact<u32>",
},
],
documentation: [
" The ideal number of validators.",
],
},
FunctionMetadata {
name: "force_no_eras",
arguments: [],
documentation: [
" Force there to be no new eras indefinitely.",
"",
" # <weight>",
" - No arguments.",
" # </weight>",
],
},
FunctionMetadata {
name: "force_new_era",
arguments: [],
documentation: [
" 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.",
"",
" # <weight>",
" - No arguments.",
" # </weight>",
],
},
FunctionMetadata {
name: "set_invulnerables",
arguments: [
FunctionArgumentMetadata {
name: "validators",
ty: "Vec<T::AccountId>",
},
],
documentation: [
" Set the validators who cannot be slashed (if any).",
],
},
FunctionMetadata {
name: "force_unstake",
arguments: [
FunctionArgumentMetadata {
name: "stash",
ty: "T::AccountId",
},
],
documentation: [
" Force a current staker to become completely unstaked, immediately.",
],
},
FunctionMetadata {
name: "force_new_era_always",
arguments: [],
documentation: [
" Force there to be a new era at the end of sessions indefinitely.",
"",
" # <weight>",
" - One storage write",
" # </weight>",
],
},
FunctionMetadata {
name: "cancel_deferred_slash",
arguments: [
FunctionArgumentMetadata {
name: "era",
ty: "EraIndex",
},
FunctionArgumentMetadata {
name: "slash_indices",
ty: "Vec<u32>",
},
],
documentation: [
" Cancel enactment of a deferred slash. Can be called by either the root origin or",
" the `T::SlashCancelOrigin`.",
" passing the era and indices of the slashes for that era to kill.",
"",
" # <weight>",
" - One storage write.",
" # </weight>",
],
},
FunctionMetadata {
name: "payout_nominator",
arguments: [
FunctionArgumentMetadata {
name: "era",
ty: "EraIndex",
},
FunctionArgumentMetadata {
name: "validators",
ty: "Vec<(T::AccountId, u32)>",
},
],
documentation: [
" Make one nominator\'s payout for one era.",
"",
" - `who` is the controller account of the nominator to pay out.",
" - `era` may not be lower than one following the most recently paid era. If it is higher,",
" then it indicates an instruction to skip the payout of all previous eras.",
" - `validators` is the list of all validators that `who` had exposure to during `era`,",
" alongside the index of `who` in the clipped exposure of the validator.",
" I.e. each element is a tuple of",
" `(validator, index of `who` in clipped exposure of validator)`.",
" If it is incomplete, then less than the full reward will be paid out.",
" It must not exceed `MAX_NOMINATIONS`.",
"",
" WARNING: once an era is payed for a validator such validator can\'t claim the payout of",
" previous era.",
"",
" WARNING: Incorrect arguments here can result in loss of payout. Be very careful.",
"",
" # <weight>",
" - Number of storage read of `O(validators)`; `validators` is the argument of the call,",
" and is bounded by `MAX_NOMINATIONS`.",
" - Each storage read is `O(N)` size and decode complexity; `N` is the maximum",
" nominations that can be given to a single validator.",
" - Computation complexity: `O(MAX_NOMINATIONS * logN)`; `MAX_NOMINATIONS` is the",
" maximum number of validators that may be nominated by a single nominator, it is",
" bounded only economically (all nominators are required to place a minimum stake).",
" # </weight>",
],
},
FunctionMetadata {
name: "payout_validator",
arguments: [
FunctionArgumentMetadata {
name: "era",
ty: "EraIndex",
},
],
documentation: [
" Make one validator\'s payout for one era.",
"",
" - `who` is the controller account of the validator to pay out.",
" - `era` may not be lower than one following the most recently paid era. If it is higher,",
" then it indicates an instruction to skip the payout of all previous eras.",
"",
" WARNING: once an era is payed for a validator such validator can\'t claim the payout of",
" previous era.",
"",
" WARNING: Incorrect arguments here can result in loss of payout. Be very careful.",
"",
" # <weight>",
" - Time complexity: O(1).",
" - Contains a limited number of reads and writes.",
" # </weight>",
],
},
FunctionMetadata {
name: "rebond",
arguments: [
FunctionArgumentMetadata {
name: "value",
ty: "Compact<BalanceOf<T>>",
},
],
documentation: [
" Rebond a portion of the stash scheduled to be unlocked.",
"",
" # <weight>",
" - Time complexity: O(1). Bounded by `MAX_UNLOCKING_CHUNKS`.",
" - Storage changes: Can\'t increase storage, only decrease it.",
" # </weight>",
],
},
FunctionMetadata {
name: "set_history_depth",
arguments: [
FunctionArgumentMetadata {
name: "new_history_depth",
ty: "Compact<EraIndex>",
},
],
documentation: [
" Set history_depth value.",
"",
" Origin must be root.",
],
},
FunctionMetadata {
name: "reap_stash",
arguments: [
FunctionArgumentMetadata {
name: "stash",
ty: "T::AccountId",
},
],
documentation: [
" Remove all data structure concerning a staker/stash once its balance is zero.",
" This is essentially equivalent to `withdraw_unbonded` except it can be called by anyone",
" and the target `stash` must have no funds left.",
"",
" This can be called from any origin.",
"",
" - `stash`: The stash account to reap. Its balance must be zero.",
],
},
],
),
event: Some(
[
EventMetadata {
name: "Reward",
arguments: [
"AccountId",
"Balance",
],
documentation: [
" The staker has been rewarded by this amount. AccountId is controller account.",
],
},
EventMetadata {
name: "Slash",
arguments: [
"AccountId",
"Balance",
],
documentation: [
" One validator (and its nominators) has been slashed by the given amount.",
],
},
EventMetadata {
name: "OldSlashingReportDiscarded",
arguments: [
"SessionIndex",
],
documentation: [
" An old slashing report from a prior era was discarded because it could",
" not be processed.",
],
},
EventMetadata {
name: "Bonded",
arguments: [
"AccountId",
"Balance",
],
documentation: [
" An account has bonded this amount.",
"",
" NOTE: This event is only emitted when funds are bonded via a dispatchable. Notably,",
" it will not be emitted for staking rewards when they are added to stake.",
],
},
EventMetadata {
name: "Unbonded",
arguments: [
"AccountId",
"Balance",
],
documentation: [
" An account has unbonded this amount.",
],
},
EventMetadata {
name: "Withdrawn",
arguments: [
"AccountId",
"Balance",
],
documentation: [
" An account has called `withdraw_unbonded` and removed unbonding chunks worth `Balance`",
" from the unlocking queue.",
],
},
],
),
constants: [
ModuleConstantMetadata {
name: "SessionsPerEra",
ty: "SessionIndex",
value: [
6,
0,
0,
0,
],
documentation: [
" Number of sessions per era.",
],
},
ModuleConstantMetadata {
name: "BondingDuration",
ty: "EraIndex",
value: [
28,
0,
0,
0,
],
documentation: [
" Number of eras that staked funds must remain bonded for.",
],
},
],
errors: [
ErrorMetadata {
name: "NotController",
documentation: [
" Not a controller account.",
],
},
ErrorMetadata {
name: "NotStash",
documentation: [
" Not a stash account.",
],
},
ErrorMetadata {
name: "AlreadyBonded",
documentation: [
" Stash is already bonded.",
],
},
ErrorMetadata {
name: "AlreadyPaired",
documentation: [
" Controller is already paired.",
],
},
ErrorMetadata {
name: "EmptyTargets",
documentation: [
" Targets cannot be empty.",
],
},
ErrorMetadata {
name: "DuplicateIndex",
documentation: [
" Duplicate index.",
],
},
ErrorMetadata {
name: "InvalidSlashIndex",
documentation: [
" Slash record index out of bounds.",
],
},
ErrorMetadata {
name: "InsufficientValue",
documentation: [
" Can not bond with value less than minimum balance.",
],
},
ErrorMetadata {
name: "NoMoreChunks",
documentation: [
" Can not schedule more unlock chunks.",
],
},
ErrorMetadata {
name: "NoUnlockChunk",
documentation: [
" Can not rebond without unlocking chunks.",
],
},
ErrorMetadata {
name: "FundedTarget",
documentation: [
" Attempting to target a stash that still has funds.",
],
},
ErrorMetadata {
name: "InvalidEraToReward",
documentation: [
" Invalid era to reward.",
],
},
ErrorMetadata {
name: "InvalidNumberOfNominations",
documentation: [
" Invalid number of nominations.",
],
},
ErrorMetadata {
name: "NotSortedAndUnique",
documentation: [
" Items are not sorted and unique.",
],
},
],
},
ModuleMetadata {
name: "Offences",
storage: Some(
StorageMetadata {
prefix: "Offences",
entries: [
StorageEntryMetadata {
name: "Reports",
modifier: StorageEntryModifier::Optional,
ty: StorageEntryType::Map {
hasher: StorageHasher::Twox64Concat,
key: "ReportIdOf<T>",
value: "OffenceDetails<T::AccountId, T::IdentificationTuple>",
unused: false,
},
default: [
0,
],
documentation: [
" The primary structure that holds all offence records keyed by report identifiers.",
],
},
StorageEntryMetadata {
name: "ConcurrentReportsIndex",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::DoubleMap {
hasher: StorageHasher::Twox64Concat,
key1: "Kind",
key2: "OpaqueTimeSlot",
value: "Vec<ReportIdOf<T>>",
key2_hasher: StorageHasher::Twox64Concat,
},
default: [
0,
],
documentation: [
" A vector of reports of the same kind that happened at the same time slot.",
],
},
StorageEntryMetadata {
name: "ReportsByKindIndex",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Map {
hasher: StorageHasher::Twox64Concat,
key: "Kind",
value: "Vec<u8>",
unused: false,
},
default: [
0,
],
documentation: [
" Enumerates all reports of a kind along with the time they happened.",
"",
" All reports are sorted by the time of offence.",
"",
" Note that the actual type of this mapping is `Vec<u8>`, this is because values of",
" different types are not supported at the moment so we are doing the manual serialization.",
],
},
],
},
),
calls: Some(
[],
),
event: Some(
[
EventMetadata {
name: "Offence",
arguments: [
"Kind",
"OpaqueTimeSlot",
],
documentation: [
" There is an offence reported of the given `kind` happened at the `session_index` and",
" (kind-specific) time slot. This event is not deposited for duplicate slashes.",
],
},
],
),
constants: [],
errors: [],
},
ModuleMetadata {
name: "Session",
storage: Some(
StorageMetadata {
prefix: "Session",
entries: [
StorageEntryMetadata {
name: "Validators",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Plain(
"Vec<T::ValidatorId>",
),
default: [
0,
],
documentation: [
" The current set of validators.",
],
},
StorageEntryMetadata {
name: "CurrentIndex",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Plain(
"SessionIndex",
),
default: [
0,
0,
0,
0,
],
documentation: [
" Current index of the session.",
],
},
StorageEntryMetadata {
name: "QueuedChanged",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Plain(
"bool",
),
default: [
0,
],
documentation: [
" True if the underlying economic identities or weighting behind the validators",
" has changed in the queued validator set.",
],
},
StorageEntryMetadata {
name: "QueuedKeys",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Plain(
"Vec<(T::ValidatorId, T::Keys)>",
),
default: [
0,
],
documentation: [
" The queued keys for the next session. When the next session begins, these keys",
" will be used to determine the validator\'s session keys.",
],
},
StorageEntryMetadata {
name: "DisabledValidators",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Plain(
"Vec<u32>",
),
default: [
0,
],
documentation: [
" Indices of disabled validators.",
"",
" The set is cleared when `on_session_ending` returns a new set of identities.",
],
},
StorageEntryMetadata {
name: "NextKeys",
modifier: StorageEntryModifier::Optional,
ty: StorageEntryType::Map {
hasher: StorageHasher::Twox64Concat,
key: "T::ValidatorId",
value: "T::Keys",
unused: false,
},
default: [
0,
],
documentation: [
" The next session keys for a validator.",
],
},
StorageEntryMetadata {
name: "KeyOwner",
modifier: StorageEntryModifier::Optional,
ty: StorageEntryType::Map {
hasher: StorageHasher::Twox64Concat,
key: "(KeyTypeId, Vec<u8>)",
value: "T::ValidatorId",
unused: false,
},
default: [
0,
],
documentation: [
" The owner of a key. The key is the `KeyTypeId` + the encoded key.",
],
},
],
},
),
calls: Some(
[
FunctionMetadata {
name: "set_keys",
arguments: [
FunctionArgumentMetadata {
name: "keys",
ty: "T::Keys",
},
FunctionArgumentMetadata {
name: "proof",
ty: "Vec<u8>",
},
],
documentation: [
" 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>",
" - O(log n) in number of accounts.",
" - One extra DB entry.",
" - Increases system account refs by one on success iff there were previously no keys set.",
" In this case, purge_keys will need to be called before the account can be removed.",
" # </weight>",
],
},
FunctionMetadata {
name: "purge_keys",
arguments: [],
documentation: [
" 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.",
"",
" # <weight>",
" - O(N) in number of key types.",
" - Removes N + 1 DB entries.",
" - Reduces system account refs by one on success.",
" # </weight>",
],
},
],
),
event: Some(
[
EventMetadata {
name: "NewSession",
arguments: [
"SessionIndex",
],
documentation: [
" New session has happened. Note that the argument is the session index, not the block",
" number as the type might suggest.",
],
},
],
),
constants: [],
errors: [
ErrorMetadata {
name: "InvalidProof",
documentation: [
" Invalid ownership proof.",
],
},
ErrorMetadata {
name: "NoAssociatedValidatorId",
documentation: [
" No associated validator ID for account.",
],
},
ErrorMetadata {
name: "DuplicatedKey",
documentation: [
" Registered duplicate key.",
],
},
ErrorMetadata {
name: "NoKeys",
documentation: [
" No keys are associated with this account.",
],
},
],
},
ModuleMetadata {
name: "FinalityTracker",
storage: Some(
StorageMetadata {
prefix: "FinalityTracker",
entries: [
StorageEntryMetadata {
name: "RecentHints",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Plain(
"Vec<T::BlockNumber>",
),
default: [
0,
],
documentation: [
" Recent hints.",
],
},
StorageEntryMetadata {
name: "OrderedHints",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Plain(
"Vec<T::BlockNumber>",
),
default: [
0,
],
documentation: [
" Ordered recent hints.",
],
},
StorageEntryMetadata {
name: "Median",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Plain(
"T::BlockNumber",
),
default: [
0,
0,
0,
0,
],
documentation: [
" The median.",
],
},
StorageEntryMetadata {
name: "Update",
modifier: StorageEntryModifier::Optional,
ty: StorageEntryType::Plain(
"T::BlockNumber",
),
default: [
0,
],
documentation: [
" Final hint to apply in the block. `None` means \"same as parent\".",
],
},
StorageEntryMetadata {
name: "Initialized",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Plain(
"bool",
),
default: [
0,
],
documentation: [],
},
],
},
),
calls: Some(
[
FunctionMetadata {
name: "final_hint",
arguments: [
FunctionArgumentMetadata {
name: "hint",
ty: "Compact<T::BlockNumber>",
},
],
documentation: [
" Hint that the author of this block thinks the best finalized",
" block is the given number.",
],
},
],
),
event: None,
constants: [
ModuleConstantMetadata {
name: "WindowSize",
ty: "T::BlockNumber",
value: [
101,
0,
0,
0,
],
documentation: [
" The number of recent samples to keep from this chain. Default is 101.",
],
},
ModuleConstantMetadata {
name: "ReportLatency",
ty: "T::BlockNumber",
value: [
232,
3,
0,
0,
],
documentation: [
" The delay after which point things become suspicious. Default is 1000.",
],
},
],
errors: [
ErrorMetadata {
name: "AlreadyUpdated",
documentation: [
" Final hint must be updated only once in the block",
],
},
ErrorMetadata {
name: "BadHint",
documentation: [
" Finalized height above block number",
],
},
],
},
ModuleMetadata {
name: "Grandpa",
storage: Some(
StorageMetadata {
prefix: "GrandpaFinality",
entries: [
StorageEntryMetadata {
name: "State",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Plain(
"StoredState<T::BlockNumber>",
),
default: [
0,
],
documentation: [
" State of the current authority set.",
],
},
StorageEntryMetadata {
name: "PendingChange",
modifier: StorageEntryModifier::Optional,
ty: StorageEntryType::Plain(
"StoredPendingChange<T::BlockNumber>",
),
default: [
0,
],
documentation: [
" Pending change: (signaled at, scheduled change).",
],
},
StorageEntryMetadata {
name: "NextForced",
modifier: StorageEntryModifier::Optional,
ty: StorageEntryType::Plain(
"T::BlockNumber",
),
default: [
0,
],
documentation: [
" next block number where we can force a change.",
],
},
StorageEntryMetadata {
name: "Stalled",
modifier: StorageEntryModifier::Optional,
ty: StorageEntryType::Plain(
"(T::BlockNumber, T::BlockNumber)",
),
default: [
0,
],
documentation: [
" `true` if we are currently stalled.",
],
},
StorageEntryMetadata {
name: "CurrentSetId",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Plain(
"SetId",
),
default: [
0,
0,
0,
0,
0,
0,
0,
0,
],
documentation: [
" The number of changes (both in terms of keys and underlying economic responsibilities)",
" in the \"set\" of Grandpa validators from genesis.",
],
},
StorageEntryMetadata {
name: "SetIdSession",
modifier: StorageEntryModifier::Optional,
ty: StorageEntryType::Map {
hasher: StorageHasher::Twox64Concat,
key: "SetId",
value: "SessionIndex",
unused: false,
},
default: [
0,
],
documentation: [
" A mapping from grandpa set ID to the index of the *most recent* session for which its",
" members were responsible.",
],
},
],
},
),
calls: Some(
[
FunctionMetadata {
name: "report_misbehavior",
arguments: [
FunctionArgumentMetadata {
name: "_report",
ty: "Vec<u8>",
},
],
documentation: [
" Report some misbehavior.",
],
},
],
),
event: Some(
[
EventMetadata {
name: "NewAuthorities",
arguments: [
"AuthorityList",
],
documentation: [
" New authority set has been applied.",
],
},
EventMetadata {
name: "Paused",
arguments: [],
documentation: [
" Current authority set has been paused.",
],
},
EventMetadata {
name: "Resumed",
arguments: [],
documentation: [
" Current authority set has been resumed.",
],
},
],
),
constants: [],
errors: [
ErrorMetadata {
name: "PauseFailed",
documentation: [
" Attempt to signal GRANDPA pause when the authority set isn\'t live",
" (either paused or already pending pause).",
],
},
ErrorMetadata {
name: "ResumeFailed",
documentation: [
" Attempt to signal GRANDPA resume when the authority set isn\'t paused",
" (either live or already pending resume).",
],
},
ErrorMetadata {
name: "ChangePending",
documentation: [
" Attempt to signal GRANDPA change with one already pending.",
],
},
ErrorMetadata {
name: "TooSoon",
documentation: [
" Cannot signal forced change so soon after last.",
],
},
],
},
ModuleMetadata {
name: "ImOnline",
storage: Some(
StorageMetadata {
prefix: "ImOnline",
entries: [
StorageEntryMetadata {
name: "HeartbeatAfter",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Plain(
"T::BlockNumber",
),
default: [
0,
0,
0,
0,
],
documentation: [
" The block number after which it\'s ok to send heartbeats in current session.",
"",
" At the beginning of each session we set this to a value that should",
" fall roughly in the middle of the session duration.",
" The idea is to first wait for the validators to produce a block",
" in the current session, so that the heartbeat later on will not be necessary.",
],
},
StorageEntryMetadata {
name: "Keys",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Plain(
"Vec<T::AuthorityId>",
),
default: [
0,
],
documentation: [
" The current set of keys that may issue a heartbeat.",
],
},
StorageEntryMetadata {
name: "ReceivedHeartbeats",
modifier: StorageEntryModifier::Optional,
ty: StorageEntryType::DoubleMap {
hasher: StorageHasher::Twox64Concat,
key1: "SessionIndex",
key2: "AuthIndex",
value: "Vec<u8>",
key2_hasher: StorageHasher::Twox64Concat,
},
default: [
0,
],
documentation: [
" For each session index, we keep a mapping of `AuthIndex` to",
" `offchain::OpaqueNetworkState`.",
],
},
StorageEntryMetadata {
name: "AuthoredBlocks",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::DoubleMap {
hasher: StorageHasher::Twox64Concat,
key1: "SessionIndex",
key2: "T::ValidatorId",
value: "u32",
key2_hasher: StorageHasher::Twox64Concat,
},
default: [
0,
0,
0,
0,
],
documentation: [
" For each session index, we keep a mapping of `T::ValidatorId` to the",
" number of blocks authored by the given authority.",
],
},
],
},
),
calls: Some(
[
FunctionMetadata {
name: "heartbeat",
arguments: [
FunctionArgumentMetadata {
name: "heartbeat",
ty: "Heartbeat<T::BlockNumber>",
},
FunctionArgumentMetadata {
name: "_signature",
ty: "<T::AuthorityId as RuntimeAppPublic>::Signature",
},
],
documentation: [],
},
],
),
event: Some(
[
EventMetadata {
name: "HeartbeatReceived",
arguments: [
"AuthorityId",
],
documentation: [
" A new heartbeat was received from `AuthorityId`",
],
},
EventMetadata {
name: "AllGood",
arguments: [],
documentation: [
" At the end of the session, no offence was committed.",
],
},
EventMetadata {
name: "SomeOffline",
arguments: [
"Vec<IdentificationTuple>",
],
documentation: [
" At the end of the session, at least once validator was found to be offline.",
],
},
],
),
constants: [],
errors: [
ErrorMetadata {
name: "InvalidKey",
documentation: [
" Non existent public key.",
],
},
ErrorMetadata {
name: "DuplicatedHeartbeat",
documentation: [
" Duplicated heartbeat.",
],
},
],
},
ModuleMetadata {
name: "AuthorityDiscovery",
storage: None,
calls: Some(
[],
),
event: None,
constants: [],
errors: [],
},
ModuleMetadata {
name: "Democracy",
storage: Some(
StorageMetadata {
prefix: "Democracy",
entries: [
StorageEntryMetadata {
name: "PublicPropCount",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Plain(
"PropIndex",
),
default: [
0,
0,
0,
0,
],
documentation: [
" The number of (public) proposals that have been made so far.",
],
},
StorageEntryMetadata {
name: "PublicProps",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Plain(
"Vec<(PropIndex, T::Hash, T::AccountId)>",
),
default: [
0,
],
documentation: [
" The public proposals. Unsorted. The second item is the proposal\'s hash.",
],
},
StorageEntryMetadata {
name: "DepositOf",
modifier: StorageEntryModifier::Optional,
ty: StorageEntryType::Map {
hasher: StorageHasher::Twox64Concat,
key: "PropIndex",
value: "(BalanceOf<T>, Vec<T::AccountId>)",
unused: false,
},
default: [
0,
],
documentation: [
" Those who have locked a deposit.",
],
},
StorageEntryMetadata {
name: "Preimages",
modifier: StorageEntryModifier::Optional,
ty: StorageEntryType::Map {
hasher: StorageHasher::Identity,
key: "T::Hash",
value: "(Vec<u8>, T::AccountId, BalanceOf<T>, T::BlockNumber)",
unused: false,
},
default: [
0,
],
documentation: [
" Map of hashes to the proposal preimage, along with who registered it and their deposit.",
" The block number is the block at which it was deposited.",
],
},
StorageEntryMetadata {
name: "ReferendumCount",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Plain(
"ReferendumIndex",
),
default: [
0,
0,
0,
0,
],
documentation: [
" The next free referendum index, aka the number of referenda started so far.",
],
},
StorageEntryMetadata {
name: "LowestUnbaked",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Plain(
"ReferendumIndex",
),
default: [
0,
0,
0,
0,
],
documentation: [
" The lowest referendum index representing an unbaked referendum. Equal to",
" `ReferendumCount` if there isn\'t a unbaked referendum.",
],
},
StorageEntryMetadata {
name: "ReferendumInfoOf",
modifier: StorageEntryModifier::Optional,
ty: StorageEntryType::Map {
hasher: StorageHasher::Twox64Concat,
key: "ReferendumIndex",
value: "ReferendumInfo<T::BlockNumber, T::Hash, BalanceOf<T>>",
unused: false,
},
default: [
0,
],
documentation: [
" Information concerning any given referendum.",
],
},
StorageEntryMetadata {
name: "DispatchQueue",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Plain(
"Vec<(T::BlockNumber, T::Hash, ReferendumIndex)>",
),
default: [
0,
],
documentation: [
" Queue of successful referenda to be dispatched. Stored ordered by block number.",
],
},
StorageEntryMetadata {
name: "VotingOf",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Map {
hasher: StorageHasher::Twox64Concat,
key: "T::AccountId",
value: "Voting<BalanceOf<T>, T::AccountId, T::BlockNumber>",
unused: false,
},
default: [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
],
documentation: [
" All votes for a particular voter. We store the balance for the number of votes that we",
" have recorded. The second item is the total amount of delegations, that will be added.",
],
},
StorageEntryMetadata {
name: "Proxy",
modifier: StorageEntryModifier::Optional,
ty: StorageEntryType::Map {
hasher: StorageHasher::Twox64Concat,
key: "T::AccountId",
value: "ProxyState<T::AccountId>",
unused: false,
},
default: [
0,
],
documentation: [
" Who is able to vote for whom. Value is the fund-holding account, key is the",
" vote-transaction-sending account.",
],
},
StorageEntryMetadata {
name: "Locks",
modifier: StorageEntryModifier::Optional,
ty: StorageEntryType::Map {
hasher: StorageHasher::Twox64Concat,
key: "T::AccountId",
value: "T::BlockNumber",
unused: false,
},
default: [
0,
],
documentation: [
" Accounts for which there are locks in action which may be removed at some point in the",
" future. The value is the block number at which the lock expires and may be removed.",
],
},
StorageEntryMetadata {
name: "LastTabledWasExternal",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Plain(
"bool",
),
default: [
0,
],
documentation: [
" True if the last referendum tabled was submitted externally. False if it was a public",
" proposal.",
],
},
StorageEntryMetadata {
name: "NextExternal",
modifier: StorageEntryModifier::Optional,
ty: StorageEntryType::Plain(
"(T::Hash, VoteThreshold)",
),
default: [
0,
],
documentation: [
" The referendum to be tabled whenever it would be valid to table an external proposal.",
" This happens when a referendum needs to be tabled and one of two conditions are met:",
" - `LastTabledWasExternal` is `false`; or",
" - `PublicProps` is empty.",
],
},
StorageEntryMetadata {
name: "Blacklist",
modifier: StorageEntryModifier::Optional,
ty: StorageEntryType::Map {
hasher: StorageHasher::Identity,
key: "T::Hash",
value: "(T::BlockNumber, Vec<T::AccountId>)",
unused: false,
},
default: [
0,
],
documentation: [
" A record of who vetoed what. Maps proposal hash to a possible existent block number",
" (until when it may not be resubmitted) and who vetoed it.",
],
},
StorageEntryMetadata {
name: "Cancellations",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Map {
hasher: StorageHasher::Identity,
key: "T::Hash",
value: "bool",
unused: false,
},
default: [
0,
],
documentation: [
" Record of all proposals that have been subject to emergency cancellation.",
],
},
],
},
),
calls: Some(
[
FunctionMetadata {
name: "propose",
arguments: [
FunctionArgumentMetadata {
name: "proposal_hash",
ty: "T::Hash",
},
FunctionArgumentMetadata {
name: "value",
ty: "Compact<BalanceOf<T>>",
},
],
documentation: [
" 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(1)`.",
" - Two DB changes, one DB entry.",
" # </weight>",
],
},
FunctionMetadata {
name: "second",
arguments: [
FunctionArgumentMetadata {
name: "proposal",
ty: "Compact<PropIndex>",
},
],
documentation: [
" 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.",
"",
" # <weight>",
" - `O(1)`.",
" - One DB entry.",
" # </weight>",
],
},
FunctionMetadata {
name: "vote",
arguments: [
FunctionArgumentMetadata {
name: "ref_index",
ty: "Compact<ReferendumIndex>",
},
FunctionArgumentMetadata {
name: "vote",
ty: "AccountVote<BalanceOf<T>>",
},
],
documentation: [
" 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(1)`.",
" - One DB change, one DB entry.",
" # </weight>",
],
},
FunctionMetadata {
name: "proxy_vote",
arguments: [
FunctionArgumentMetadata {
name: "ref_index",
ty: "Compact<ReferendumIndex>",
},
FunctionArgumentMetadata {
name: "vote",
ty: "AccountVote<BalanceOf<T>>",
},
],
documentation: [
" Vote in a referendum on behalf of a stash. 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 proxy vote for.",
" - `vote`: The vote configuration.",
"",
" # <weight>",
" - `O(1)`.",
" - One DB change, one DB entry.",
" # </weight>",
],
},
FunctionMetadata {
name: "emergency_cancel",
arguments: [
FunctionArgumentMetadata {
name: "ref_index",
ty: "ReferendumIndex",
},
],
documentation: [
" 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>",
" - Depends on size of storage vec `VotersFor` for this referendum.",
" # </weight>",
],
},
FunctionMetadata {
name: "external_propose",
arguments: [
FunctionArgumentMetadata {
name: "proposal_hash",
ty: "T::Hash",
},
],
documentation: [
" 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(1)`.",
" - One DB change.",
" # </weight>",
],
},
FunctionMetadata {
name: "external_propose_majority",
arguments: [
FunctionArgumentMetadata {
name: "proposal_hash",
ty: "T::Hash",
},
],
documentation: [
" 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)`.",
" - One DB change.",
" # </weight>",
],
},
FunctionMetadata {
name: "external_propose_default",
arguments: [
FunctionArgumentMetadata {
name: "proposal_hash",
ty: "T::Hash",
},
],
documentation: [
" 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)`.",
" - One DB change.",
" # </weight>",
],
},
FunctionMetadata {
name: "fast_track",
arguments: [
FunctionArgumentMetadata {
name: "proposal_hash",
ty: "T::Hash",
},
FunctionArgumentMetadata {
name: "voting_period",
ty: "T::BlockNumber",
},
FunctionArgumentMetadata {
name: "delay",
ty: "T::BlockNumber",
},
],
documentation: [
" 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>",
" - One DB clear.",
" - One DB change.",
" - One extra DB entry.",
" # </weight>",
],
},
FunctionMetadata {
name: "veto_external",
arguments: [
FunctionArgumentMetadata {
name: "proposal_hash",
ty: "T::Hash",
},
],
documentation: [
" 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>",
" - Two DB entries.",
" - One DB clear.",
" - Performs a binary search on `existing_vetoers` which should not",
" be very large.",
" # </weight>",
],
},
FunctionMetadata {
name: "cancel_referendum",
arguments: [
FunctionArgumentMetadata {
name: "ref_index",
ty: "Compact<ReferendumIndex>",
},
],
documentation: [
" Remove a referendum.",
"",
" The dispatch origin of this call must be _Root_.",
"",
" - `ref_index`: The index of the referendum to cancel.",
"",
" # <weight>",
" - `O(1)`.",
" # </weight>",
],
},
FunctionMetadata {
name: "cancel_queued",
arguments: [
FunctionArgumentMetadata {
name: "which",
ty: "ReferendumIndex",
},
],
documentation: [
" Cancel a proposal queued for enactment.",
"",
" The dispatch origin of this call must be _Root_.",
"",
" - `which`: The index of the referendum to cancel.",
"",
" # <weight>",
" - One DB change.",
" # </weight>",
],
},
FunctionMetadata {
name: "activate_proxy",
arguments: [
FunctionArgumentMetadata {
name: "proxy",
ty: "T::AccountId",
},
],
documentation: [
" Specify a proxy that is already open to us. Called by the stash.",
"",
" NOTE: Used to be called `set_proxy`.",
"",
" The dispatch origin of this call must be _Signed_.",
"",
" - `proxy`: The account that will be activated as proxy.",
"",
" # <weight>",
" - One extra DB entry.",
" # </weight>",
],
},
FunctionMetadata {
name: "close_proxy",
arguments: [],
documentation: [
" Clear the proxy. Called by the proxy.",
"",
" NOTE: Used to be called `resign_proxy`.",
"",
" The dispatch origin of this call must be _Signed_.",
"",
" # <weight>",
" - One DB clear.",
" # </weight>",
],
},
FunctionMetadata {
name: "deactivate_proxy",
arguments: [
FunctionArgumentMetadata {
name: "proxy",
ty: "T::AccountId",
},
],
documentation: [
" Deactivate the proxy, but leave open to this account. Called by the stash.",
"",
" The proxy must already be active.",
"",
" NOTE: Used to be called `remove_proxy`.",
"",
" The dispatch origin of this call must be _Signed_.",
"",
" - `proxy`: The account that will be deactivated as proxy.",
"",
" # <weight>",
" - One DB clear.",
" # </weight>",
],
},
FunctionMetadata {
name: "delegate",
arguments: [
FunctionArgumentMetadata {
name: "to",
ty: "T::AccountId",
},
FunctionArgumentMetadata {
name: "conviction",
ty: "Conviction",
},
FunctionArgumentMetadata {
name: "balance",
ty: "BalanceOf<T>",
},
],
documentation: [
" 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>",
" # </weight>",
],
},
FunctionMetadata {
name: "undelegate",
arguments: [],
documentation: [
" 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(1).",
" # </weight>",
],
},
FunctionMetadata {
name: "clear_public_proposals",
arguments: [],
documentation: [
" Clears all public proposals.",
"",
" The dispatch origin of this call must be _Root_.",
"",
" # <weight>",
" - `O(1)`.",
" - One DB clear.",
" # </weight>",
],
},
FunctionMetadata {
name: "note_preimage",
arguments: [
FunctionArgumentMetadata {
name: "encoded_proposal",
ty: "Vec<u8>",
},
],
documentation: [
" 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>",
" - Dependent on the size of `encoded_proposal` but protected by a",
" required deposit.",
" # </weight>",
],
},
FunctionMetadata {
name: "note_imminent_preimage",
arguments: [
FunctionArgumentMetadata {
name: "encoded_proposal",
ty: "Vec<u8>",
},
],
documentation: [
" Register the preimage for an upcoming proposal. This requires the proposal to be",
" in the dispatch queue. No deposit is needed.",
"",
" The dispatch origin of this call must be _Signed_.",
"",
" - `encoded_proposal`: The preimage of a proposal.",
"",
" Emits `PreimageNoted`.",
"",
" # <weight>",
" - Dependent on the size of `encoded_proposal`.",
" # </weight>",
],
},
FunctionMetadata {
name: "reap_preimage",
arguments: [
FunctionArgumentMetadata {
name: "proposal_hash",
ty: "T::Hash",
},
],
documentation: [
" 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.",
"",
" 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>",
" - One DB clear.",
" # </weight>",
],
},
FunctionMetadata {
name: "unlock",
arguments: [
FunctionArgumentMetadata {
name: "target",
ty: "T::AccountId",
},
],
documentation: [
" 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(1)`.",
" # </weight>",
],
},
FunctionMetadata {
name: "open_proxy",
arguments: [
FunctionArgumentMetadata {
name: "target",
ty: "T::AccountId",
},
],
documentation: [
" Become a proxy.",
"",
" This must be called prior to a later `activate_proxy`.",
"",
" Origin must be a Signed.",
"",
" - `target`: The account whose votes will later be proxied.",
"",
" `close_proxy` must be called before the account can be destroyed.",
"",
" # <weight>",
" - One extra DB entry.",
" # </weight>",
],
},
FunctionMetadata {
name: "remove_vote",
arguments: [
FunctionArgumentMetadata {
name: "index",
ty: "ReferendumIndex",
},
],
documentation: [
" 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>",
],
},
FunctionMetadata {
name: "remove_other_vote",
arguments: [
FunctionArgumentMetadata {
name: "target",
ty: "T::AccountId",
},
FunctionArgumentMetadata {
name: "index",
ty: "ReferendumIndex",
},
],
documentation: [
" 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>",
],
},
FunctionMetadata {
name: "proxy_delegate",
arguments: [
FunctionArgumentMetadata {
name: "to",
ty: "T::AccountId",
},
FunctionArgumentMetadata {
name: "conviction",
ty: "Conviction",
},
FunctionArgumentMetadata {
name: "balance",
ty: "BalanceOf<T>",
},
],
documentation: [
" Delegate the voting power (with some given conviction) of a proxied 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 have",
" been set as the proxy account for `target`.",
"",
" - `target`: The account whole voting power shall be delegated and whose balance locked.",
" This 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>",
" # </weight>",
],
},
FunctionMetadata {
name: "proxy_undelegate",
arguments: [],
documentation: [
" Undelegate the voting power of a proxied 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 a",
" proxy for some other account which is currently delegating.",
"",
" Emits `Undelegated`.",
"",
" # <weight>",
" - O(1).",
" # </weight>",
],
},
FunctionMetadata {
name: "proxy_remove_vote",
arguments: [
FunctionArgumentMetadata {
name: "index",
ty: "ReferendumIndex",
},
],
documentation: [
" Remove a proxied vote for a referendum.",
"",
" Exactly equivalent to `remove_vote` except that it operates on the account that the",
" sender is a proxy for.",
"",
" The dispatch origin of this call must be _Signed_ and the signing account must be a",
" proxy for some other account which has a registered vote for the referendum of `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>",
],
},
],
),
event: Some(
[
EventMetadata {
name: "Proposed",
arguments: [
"PropIndex",
"Balance",
],
documentation: [
" A motion has been proposed by a public account.",
],
},
EventMetadata {
name: "Tabled",
arguments: [
"PropIndex",
"Balance",
"Vec<AccountId>",
],
documentation: [
" A public proposal has been tabled for referendum vote.",
],
},
EventMetadata {
name: "ExternalTabled",
arguments: [],
documentation: [
" An external proposal has been tabled.",
],
},
EventMetadata {
name: "Started",
arguments: [
"ReferendumIndex",
"VoteThreshold",
],
documentation: [
" A referendum has begun.",
],
},
EventMetadata {
name: "Passed",
arguments: [
"ReferendumIndex",
],
documentation: [
" A proposal has been approved by referendum.",
],
},
EventMetadata {
name: "NotPassed",
arguments: [
"ReferendumIndex",
],
documentation: [
" A proposal has been rejected by referendum.",
],
},
EventMetadata {
name: "Cancelled",
arguments: [
"ReferendumIndex",
],
documentation: [
" A referendum has been cancelled.",
],
},
EventMetadata {
name: "Executed",
arguments: [
"ReferendumIndex",
"bool",
],
documentation: [
" A proposal has been enacted.",
],
},
EventMetadata {
name: "Delegated",
arguments: [
"AccountId",
"AccountId",
],
documentation: [
" An account has delegated their vote to another account.",
],
},
EventMetadata {
name: "Undelegated",
arguments: [
"AccountId",
],
documentation: [
" An account has cancelled a previous delegation operation.",
],
},
EventMetadata {
name: "Vetoed",
arguments: [
"AccountId",
"Hash",
"BlockNumber",
],
documentation: [
" An external proposal has been vetoed.",
],
},
EventMetadata {
name: "PreimageNoted",
arguments: [
"Hash",
"AccountId",
"Balance",
],
documentation: [
" A proposal\'s preimage was noted, and the deposit taken.",
],
},
EventMetadata {
name: "PreimageUsed",
arguments: [
"Hash",
"AccountId",
"Balance",
],
documentation: [
" A proposal preimage was removed and used (the deposit was returned).",
],
},
EventMetadata {
name: "PreimageInvalid",
arguments: [
"Hash",
"ReferendumIndex",
],
documentation: [
" A proposal could not be executed because its preimage was invalid.",
],
},
EventMetadata {
name: "PreimageMissing",
arguments: [
"Hash",
"ReferendumIndex",
],
documentation: [
" A proposal could not be executed because its preimage was missing.",
],
},
EventMetadata {
name: "PreimageReaped",
arguments: [
"Hash",
"AccountId",
"Balance",
"AccountId",
],
documentation: [
" A registered preimage was removed and the deposit collected by the reaper (last item).",
],
},
EventMetadata {
name: "Unlocked",
arguments: [
"AccountId",
],
documentation: [
" An account has been unlocked successfully.",
],
},
],
),
constants: [
ModuleConstantMetadata {
name: "EnactmentPeriod",
ty: "T::BlockNumber",
value: [
0,
194,
1,
0,
],
documentation: [
" The minimum period of locking and the period between a proposal being approved and enacted.",
"",
" It should generally be a little more than the unstake period to ensure that",
" voting stakers have an opportunity to remove themselves from the system in the case where",
" they are on the losing side of a vote.",
],
},
ModuleConstantMetadata {
name: "LaunchPeriod",
ty: "T::BlockNumber",
value: [
192,
137,
1,
0,
],
documentation: [
" How often (in blocks) new public referenda are launched.",
],
},
ModuleConstantMetadata {
name: "VotingPeriod",
ty: "T::BlockNumber",
value: [
192,
137,
1,
0,
],
documentation: [
" How often (in blocks) to check for new votes.",
],
},
ModuleConstantMetadata {
name: "MinimumDeposit",
ty: "BalanceOf<T>",
value: [
0,
16,
165,
212,
232,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
],
documentation: [
" The minimum amount to be used as a deposit for a public referendum proposal.",
],
},
ModuleConstantMetadata {
name: "FastTrackVotingPeriod",
ty: "T::BlockNumber",
value: [
8,
7,
0,
0,
],
documentation: [
" Minimum voting period allowed for an emergency referendum.",
],
},
ModuleConstantMetadata {
name: "CooloffPeriod",
ty: "T::BlockNumber",
value: [
192,
137,
1,
0,
],
documentation: [
" Period in blocks where an external proposal may not be re-submitted after being vetoed.",
],
},
ModuleConstantMetadata {
name: "PreimageByteDeposit",
ty: "BalanceOf<T>",
value: [
0,
225,
245,
5,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
],
documentation: [
" The amount of balance that must be deposited per byte of preimage stored.",
],
},
],
errors: [
ErrorMetadata {
name: "ValueLow",
documentation: [
" Value too low",
],
},
ErrorMetadata {
name: "ProposalMissing",
documentation: [
" Proposal does not exist",
],
},
ErrorMetadata {
name: "NotProxy",
documentation: [
" Not a proxy",
],
},
ErrorMetadata {
name: "BadIndex",
documentation: [
" Unknown index",
],
},
ErrorMetadata {
name: "AlreadyCanceled",
documentation: [
" Cannot cancel the same proposal twice",
],
},
ErrorMetadata {
name: "DuplicateProposal",
documentation: [
" Proposal already made",
],
},
ErrorMetadata {
name: "ProposalBlacklisted",
documentation: [
" Proposal still blacklisted",
],
},
ErrorMetadata {
name: "NotSimpleMajority",
documentation: [
" Next external proposal not simple majority",
],
},
ErrorMetadata {
name: "InvalidHash",
documentation: [
" Invalid hash",
],
},
ErrorMetadata {
name: "NoProposal",
documentation: [
" No external proposal",
],
},
ErrorMetadata {
name: "AlreadyVetoed",
documentation: [
" Identity may not veto a proposal twice",
],
},
ErrorMetadata {
name: "AlreadyProxy",
documentation: [
" Already a proxy",
],
},
ErrorMetadata {
name: "WrongProxy",
documentation: [
" Wrong proxy",
],
},
ErrorMetadata {
name: "NotDelegated",
documentation: [
" Not delegated",
],
},
ErrorMetadata {
name: "DuplicatePreimage",
documentation: [
" Preimage already noted",
],
},
ErrorMetadata {
name: "NotImminent",
documentation: [
" Not imminent",
],
},
ErrorMetadata {
name: "TooEarly",
documentation: [
" Too early",
],
},
ErrorMetadata {
name: "Imminent",
documentation: [
" Imminent",
],
},
ErrorMetadata {
name: "PreimageMissing",
documentation: [
" Preimage not found",
],
},
ErrorMetadata {
name: "ReferendumInvalid",
documentation: [
" Vote given for invalid referendum",
],
},
ErrorMetadata {
name: "PreimageInvalid",
documentation: [
" Invalid preimage",
],
},
ErrorMetadata {
name: "NoneWaiting",
documentation: [
" No proposals waiting",
],
},
ErrorMetadata {
name: "NotLocked",
documentation: [
" The target account does not have a lock.",
],
},
ErrorMetadata {
name: "NotExpired",
documentation: [
" The lock on the account to be unlocked has not yet expired.",
],
},
ErrorMetadata {
name: "NotOpen",
documentation: [
" A proxy-pairing was attempted to an account that was not open.",
],
},
ErrorMetadata {
name: "WrongOpen",
documentation: [
" A proxy-pairing was attempted to an account that was open to another account.",
],
},
ErrorMetadata {
name: "NotActive",
documentation: [
" A proxy-de-pairing was attempted to an account that was not active.",
],
},
ErrorMetadata {
name: "NotVoter",
documentation: [
" The given account did not vote on the referendum.",
],
},
ErrorMetadata {
name: "NoPermission",
documentation: [
" The actor has no permission to conduct the action.",
],
},
ErrorMetadata {
name: "AlreadyDelegating",
documentation: [
" The account is already delegating.",
],
},
ErrorMetadata {
name: "Overflow",
documentation: [
" An unexpected integer overflow occurred.",
],
},
ErrorMetadata {
name: "Underflow",
documentation: [
" An unexpected integer underflow occurred.",
],
},
ErrorMetadata {
name: "InsufficientFunds",
documentation: [
" Too high a balance was provided that the account cannot afford.",
],
},
ErrorMetadata {
name: "NotDelegating",
documentation: [
" The account is not currently delegating.",
],
},
ErrorMetadata {
name: "VotesExist",
documentation: [
" The account currently has votes attached to it and the operation cannot succeed until",
" these are removed, either through `unvote` or `reap_vote`.",
],
},
ErrorMetadata {
name: "InstantNotAllowed",
documentation: [
" The instant referendum origin is currently disallowed.",
],
},
ErrorMetadata {
name: "Nonsense",
documentation: [
" Delegation to oneself makes no sense.",
],
},
],
},
ModuleMetadata {
name: "Council",
storage: Some(
StorageMetadata {
prefix: "Instance1Collective",
entries: [
StorageEntryMetadata {
name: "Proposals",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Plain(
"Vec<T::Hash>",
),
default: [
0,
],
documentation: [
" The hashes of the active proposals.",
],
},
StorageEntryMetadata {
name: "ProposalOf",
modifier: StorageEntryModifier::Optional,
ty: StorageEntryType::Map {
hasher: StorageHasher::Identity,
key: "T::Hash",
value: "<T as Trait<I>>::Proposal",
unused: false,
},
default: [
0,
],
documentation: [
" Actual proposal for a given hash, if it\'s current.",
],
},
StorageEntryMetadata {
name: "Voting",
modifier: StorageEntryModifier::Optional,
ty: StorageEntryType::Map {
hasher: StorageHasher::Identity,
key: "T::Hash",
value: "Votes<T::AccountId, T::BlockNumber>",
unused: false,
},
default: [
0,
],
documentation: [
" Votes on a given proposal, if it is ongoing.",
],
},
StorageEntryMetadata {
name: "ProposalCount",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Plain(
"u32",
),
default: [
0,
0,
0,
0,
],
documentation: [
" Proposals so far.",
],
},
StorageEntryMetadata {
name: "Members",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Plain(
"Vec<T::AccountId>",
),
default: [
0,
],
documentation: [
" The current members of the collective. This is stored sorted (just by value).",
],
},
StorageEntryMetadata {
name: "Prime",
modifier: StorageEntryModifier::Optional,
ty: StorageEntryType::Plain(
"T::AccountId",
),
default: [
0,
],
documentation: [
" The member who provides the default vote for any other members that do not vote before",
" the timeout. If None, then no member has that privilege.",
],
},
],
},
),
calls: Some(
[
FunctionMetadata {
name: "set_members",
arguments: [
FunctionArgumentMetadata {
name: "new_members",
ty: "Vec<T::AccountId>",
},
FunctionArgumentMetadata {
name: "prime",
ty: "Option<T::AccountId>",
},
],
documentation: [
" Set the collective\'s membership.",
"",
" - `new_members`: The new member list. Be nice to the chain and",
" - `prime`: The prime member whose vote sets the default.",
"",
" Requires root origin.",
],
},
FunctionMetadata {
name: "execute",
arguments: [
FunctionArgumentMetadata {
name: "proposal",
ty: "Box<<T as Trait<I>>::Proposal>",
},
],
documentation: [
" Dispatch a proposal from a member using the `Member` origin.",
"",
" Origin must be a member of the collective.",
],
},
FunctionMetadata {
name: "propose",
arguments: [
FunctionArgumentMetadata {
name: "threshold",
ty: "Compact<MemberCount>",
},
FunctionArgumentMetadata {
name: "proposal",
ty: "Box<<T as Trait<I>>::Proposal>",
},
],
documentation: [
" # <weight>",
" - Bounded storage reads and writes.",
" - Argument `threshold` has bearing on weight.",
" # </weight>",
],
},
FunctionMetadata {
name: "vote",
arguments: [
FunctionArgumentMetadata {
name: "proposal",
ty: "T::Hash",
},
FunctionArgumentMetadata {
name: "index",
ty: "Compact<ProposalIndex>",
},
FunctionArgumentMetadata {
name: "approve",
ty: "bool",
},
],
documentation: [
" # <weight>",
" - Bounded storage read and writes.",
" - Will be slightly heavier if the proposal is approved / disapproved after the vote.",
" # </weight>",
],
},
FunctionMetadata {
name: "close",
arguments: [
FunctionArgumentMetadata {
name: "proposal",
ty: "T::Hash",
},
FunctionArgumentMetadata {
name: "index",
ty: "Compact<ProposalIndex>",
},
],
documentation: [
" May be called by any signed account after the voting duration has ended in order to",
" finish voting and close the proposal.",
"",
" Abstentions are counted as rejections unless there is a prime member set and the prime",
" member cast an approval.",
"",
" - the weight of `proposal` preimage.",
" - up to three events deposited.",
" - one read, two removals, one mutation. (plus three static reads.)",
" - computation and i/o `O(P + L + M)` where:",
" - `M` is number of members,",
" - `P` is number of active proposals,",
" - `L` is the encoded length of `proposal` preimage.",
],
},
],
),
event: Some(
[
EventMetadata {
name: "Proposed",
arguments: [
"AccountId",
"ProposalIndex",
"Hash",
"MemberCount",
],
documentation: [
" A motion (given hash) has been proposed (by given account) with a threshold (given",
" `MemberCount`).",
],
},
EventMetadata {
name: "Voted",
arguments: [
"AccountId",
"Hash",
"bool",
"MemberCount",
"MemberCount",
],
documentation: [
" A motion (given hash) has been voted on by given account, leaving",
" a tally (yes votes and no votes given respectively as `MemberCount`).",
],
},
EventMetadata {
name: "Approved",
arguments: [
"Hash",
],
documentation: [
" A motion was approved by the required threshold.",
],
},
EventMetadata {
name: "Disapproved",
arguments: [
"Hash",
],
documentation: [
" A motion was not approved by the required threshold.",
],
},
EventMetadata {
name: "Executed",
arguments: [
"Hash",
"bool",
],
documentation: [
" A motion was executed; `bool` is true if returned without error.",
],
},
EventMetadata {
name: "MemberExecuted",
arguments: [
"Hash",
"bool",
],
documentation: [
" A single member did some action; `bool` is true if returned without error.",
],
},
EventMetadata {
name: "Closed",
arguments: [
"Hash",
"MemberCount",
"MemberCount",
],
documentation: [
" A proposal was closed after its duration was up.",
],
},
],
),
constants: [],
errors: [
ErrorMetadata {
name: "NotMember",
documentation: [
" Account is not a member",
],
},
ErrorMetadata {
name: "DuplicateProposal",
documentation: [
" Duplicate proposals not allowed",
],
},
ErrorMetadata {
name: "ProposalMissing",
documentation: [
" Proposal must exist",
],
},
ErrorMetadata {
name: "WrongIndex",
documentation: [
" Mismatched index",
],
},
ErrorMetadata {
name: "DuplicateVote",
documentation: [
" Duplicate vote ignored",
],
},
ErrorMetadata {
name: "AlreadyInitialized",
documentation: [
" Members are already initialized!",
],
},
ErrorMetadata {
name: "TooEarly",
documentation: [
" The close call is made too early, before the end of the voting.",
],
},
],
},
ModuleMetadata {
name: "TechnicalCommittee",
storage: Some(
StorageMetadata {
prefix: "Instance2Collective",
entries: [
StorageEntryMetadata {
name: "Proposals",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Plain(
"Vec<T::Hash>",
),
default: [
0,
],
documentation: [
" The hashes of the active proposals.",
],
},
StorageEntryMetadata {
name: "ProposalOf",
modifier: StorageEntryModifier::Optional,
ty: StorageEntryType::Map {
hasher: StorageHasher::Identity,
key: "T::Hash",
value: "<T as Trait<I>>::Proposal",
unused: false,
},
default: [
0,
],
documentation: [
" Actual proposal for a given hash, if it\'s current.",
],
},
StorageEntryMetadata {
name: "Voting",
modifier: StorageEntryModifier::Optional,
ty: StorageEntryType::Map {
hasher: StorageHasher::Identity,
key: "T::Hash",
value: "Votes<T::AccountId, T::BlockNumber>",
unused: false,
},
default: [
0,
],
documentation: [
" Votes on a given proposal, if it is ongoing.",
],
},
StorageEntryMetadata {
name: "ProposalCount",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Plain(
"u32",
),
default: [
0,
0,
0,
0,
],
documentation: [
" Proposals so far.",
],
},
StorageEntryMetadata {
name: "Members",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Plain(
"Vec<T::AccountId>",
),
default: [
0,
],
documentation: [
" The current members of the collective. This is stored sorted (just by value).",
],
},
StorageEntryMetadata {
name: "Prime",
modifier: StorageEntryModifier::Optional,
ty: StorageEntryType::Plain(
"T::AccountId",
),
default: [
0,
],
documentation: [
" The member who provides the default vote for any other members that do not vote before",
" the timeout. If None, then no member has that privilege.",
],
},
],
},
),
calls: Some(
[
FunctionMetadata {
name: "set_members",
arguments: [
FunctionArgumentMetadata {
name: "new_members",
ty: "Vec<T::AccountId>",
},
FunctionArgumentMetadata {
name: "prime",
ty: "Option<T::AccountId>",
},
],
documentation: [
" Set the collective\'s membership.",
"",
" - `new_members`: The new member list. Be nice to the chain and",
" - `prime`: The prime member whose vote sets the default.",
"",
" Requires root origin.",
],
},
FunctionMetadata {
name: "execute",
arguments: [
FunctionArgumentMetadata {
name: "proposal",
ty: "Box<<T as Trait<I>>::Proposal>",
},
],
documentation: [
" Dispatch a proposal from a member using the `Member` origin.",
"",
" Origin must be a member of the collective.",
],
},
FunctionMetadata {
name: "propose",
arguments: [
FunctionArgumentMetadata {
name: "threshold",
ty: "Compact<MemberCount>",
},
FunctionArgumentMetadata {
name: "proposal",
ty: "Box<<T as Trait<I>>::Proposal>",
},
],
documentation: [
" # <weight>",
" - Bounded storage reads and writes.",
" - Argument `threshold` has bearing on weight.",
" # </weight>",
],
},
FunctionMetadata {
name: "vote",
arguments: [
FunctionArgumentMetadata {
name: "proposal",
ty: "T::Hash",
},
FunctionArgumentMetadata {
name: "index",
ty: "Compact<ProposalIndex>",
},
FunctionArgumentMetadata {
name: "approve",
ty: "bool",
},
],
documentation: [
" # <weight>",
" - Bounded storage read and writes.",
" - Will be slightly heavier if the proposal is approved / disapproved after the vote.",
" # </weight>",
],
},
FunctionMetadata {
name: "close",
arguments: [
FunctionArgumentMetadata {
name: "proposal",
ty: "T::Hash",
},
FunctionArgumentMetadata {
name: "index",
ty: "Compact<ProposalIndex>",
},
],
documentation: [
" May be called by any signed account after the voting duration has ended in order to",
" finish voting and close the proposal.",
"",
" Abstentions are counted as rejections unless there is a prime member set and the prime",
" member cast an approval.",
"",
" - the weight of `proposal` preimage.",
" - up to three events deposited.",
" - one read, two removals, one mutation. (plus three static reads.)",
" - computation and i/o `O(P + L + M)` where:",
" - `M` is number of members,",
" - `P` is number of active proposals,",
" - `L` is the encoded length of `proposal` preimage.",
],
},
],
),
event: Some(
[
EventMetadata {
name: "Proposed",
arguments: [
"AccountId",
"ProposalIndex",
"Hash",
"MemberCount",
],
documentation: [
" A motion (given hash) has been proposed (by given account) with a threshold (given",
" `MemberCount`).",
],
},
EventMetadata {
name: "Voted",
arguments: [
"AccountId",
"Hash",
"bool",
"MemberCount",
"MemberCount",
],
documentation: [
" A motion (given hash) has been voted on by given account, leaving",
" a tally (yes votes and no votes given respectively as `MemberCount`).",
],
},
EventMetadata {
name: "Approved",
arguments: [
"Hash",
],
documentation: [
" A motion was approved by the required threshold.",
],
},
EventMetadata {
name: "Disapproved",
arguments: [
"Hash",
],
documentation: [
" A motion was not approved by the required threshold.",
],
},
EventMetadata {
name: "Executed",
arguments: [
"Hash",
"bool",
],
documentation: [
" A motion was executed; `bool` is true if returned without error.",
],
},
EventMetadata {
name: "MemberExecuted",
arguments: [
"Hash",
"bool",
],
documentation: [
" A single member did some action; `bool` is true if returned without error.",
],
},
EventMetadata {
name: "Closed",
arguments: [
"Hash",
"MemberCount",
"MemberCount",
],
documentation: [
" A proposal was closed after its duration was up.",
],
},
],
),
constants: [],
errors: [
ErrorMetadata {
name: "NotMember",
documentation: [
" Account is not a member",
],
},
ErrorMetadata {
name: "DuplicateProposal",
documentation: [
" Duplicate proposals not allowed",
],
},
ErrorMetadata {
name: "ProposalMissing",
documentation: [
" Proposal must exist",
],
},
ErrorMetadata {
name: "WrongIndex",
documentation: [
" Mismatched index",
],
},
ErrorMetadata {
name: "DuplicateVote",
documentation: [
" Duplicate vote ignored",
],
},
ErrorMetadata {
name: "AlreadyInitialized",
documentation: [
" Members are already initialized!",
],
},
ErrorMetadata {
name: "TooEarly",
documentation: [
" The close call is made too early, before the end of the voting.",
],
},
],
},
ModuleMetadata {
name: "ElectionsPhragmen",
storage: Some(
StorageMetadata {
prefix: "PhragmenElection",
entries: [
StorageEntryMetadata {
name: "Members",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Plain(
"Vec<(T::AccountId, BalanceOf<T>)>",
),
default: [
0,
],
documentation: [
" The current elected membership. Sorted based on account id.",
],
},
StorageEntryMetadata {
name: "RunnersUp",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Plain(
"Vec<(T::AccountId, BalanceOf<T>)>",
),
default: [
0,
],
documentation: [
" The current runners_up. Sorted based on low to high merit (worse to best runner).",
],
},
StorageEntryMetadata {
name: "ElectionRounds",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Plain(
"u32",
),
default: [
0,
0,
0,
0,
],
documentation: [
" The total number of vote rounds that have happened, excluding the upcoming one.",
],
},
StorageEntryMetadata {
name: "VotesOf",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Map {
hasher: StorageHasher::Twox64Concat,
key: "T::AccountId",
value: "Vec<T::AccountId>",
unused: false,
},
default: [
0,
],
documentation: [
" Votes of a particular voter, with the round index of the votes.",
],
},
StorageEntryMetadata {
name: "StakeOf",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Map {
hasher: StorageHasher::Twox64Concat,
key: "T::AccountId",
value: "BalanceOf<T>",
unused: false,
},
default: [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
],
documentation: [
" Locked stake of a voter.",
],
},
StorageEntryMetadata {
name: "Candidates",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Plain(
"Vec<T::AccountId>",
),
default: [
0,
],
documentation: [
" The present candidate list. Sorted based on account-id. A current member or a runner can",
" never enter this vector and is always implicitly assumed to be a candidate.",
],
},
],
},
),
calls: Some(
[
FunctionMetadata {
name: "vote",
arguments: [
FunctionArgumentMetadata {
name: "votes",
ty: "Vec<T::AccountId>",
},
FunctionArgumentMetadata {
name: "value",
ty: "Compact<BalanceOf<T>>",
},
],
documentation: [
" Vote for a set of candidates for the upcoming round of election.",
"",
" The `votes` should:",
" - not be empty.",
" - be less than the number of candidates.",
"",
" Upon voting, `value` units of `who`\'s balance is locked and a bond amount is reserved.",
" It is the responsibility of the caller to not place all of their balance into the lock",
" and keep some for further transactions.",
"",
" # <weight>",
" #### State",
" Reads: O(1)",
" Writes: O(V) given `V` votes. V is bounded by 16.",
" # </weight>",
],
},
FunctionMetadata {
name: "remove_voter",
arguments: [],
documentation: [
" Remove `origin` as a voter. This removes the lock and returns the bond.",
"",
" # <weight>",
" #### State",
" Reads: O(1)",
" Writes: O(1)",
" # </weight>",
],
},
FunctionMetadata {
name: "report_defunct_voter",
arguments: [
FunctionArgumentMetadata {
name: "target",
ty: "<T::Lookup as StaticLookup>::Source",
},
],
documentation: [
" Report `target` for being an defunct voter. In case of a valid report, the reporter is",
" rewarded by the bond amount of `target`. Otherwise, the reporter itself is removed and",
" their bond is slashed.",
"",
" A defunct voter is defined to be:",
" - a voter whose current submitted votes are all invalid. i.e. all of them are no",
" longer a candidate nor an active member.",
"",
" # <weight>",
" #### State",
" Reads: O(NLogM) given M current candidates and N votes for `target`.",
" Writes: O(1)",
" # </weight>",
],
},
FunctionMetadata {
name: "submit_candidacy",
arguments: [],
documentation: [
" Submit oneself for candidacy.",
"",
" A candidate will either:",
" - Lose at the end of the term and forfeit their deposit.",
" - Win and become a member. Members will eventually get their stash back.",
" - Become a runner-up. Runners-ups are reserved members in case one gets forcefully",
" removed.",
"",
" # <weight>",
" #### State",
" Reads: O(LogN) Given N candidates.",
" Writes: O(1)",
" # </weight>",
],
},
FunctionMetadata {
name: "renounce_candidacy",
arguments: [],
documentation: [
" 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 bond is",
" unreserved, returned and origin is removed as a candidate.",
" - `origin` is a current runner up. In this case, the bond is unreserved, returned and",
" origin is removed as a runner.",
" - `origin` is a current member. In this case, the bond is unreserved and origin is",
" removed as a member, consequently not being a candidate for the next round anymore.",
" Similar to [`remove_voter`], if replacement runners exists, they are immediately used.",
],
},
FunctionMetadata {
name: "remove_member",
arguments: [
FunctionArgumentMetadata {
name: "who",
ty: "<T::Lookup as StaticLookup>::Source",
},
],
documentation: [
" 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 round is started.",
"",
" Note that this does not affect the designated block number of the next election.",
"",
" # <weight>",
" #### State",
" Reads: O(do_phragmen)",
" Writes: O(do_phragmen)",
" # </weight>",
],
},
],
),
event: Some(
[
EventMetadata {
name: "NewTerm",
arguments: [
"Vec<(AccountId, Balance)>",
],
documentation: [
" A new term with new members. This indicates that enough candidates existed, not that",
" enough have has been elected. The inner value must be examined for this purpose.",
],
},
EventMetadata {
name: "EmptyTerm",
arguments: [],
documentation: [
" No (or not enough) candidates existed for this round.",
],
},
EventMetadata {
name: "MemberKicked",
arguments: [
"AccountId",
],
documentation: [
" A member has been removed. This should always be followed by either `NewTerm` ot",
" `EmptyTerm`.",
],
},
EventMetadata {
name: "MemberRenounced",
arguments: [
"AccountId",
],
documentation: [
" A member has renounced their candidacy.",
],
},
EventMetadata {
name: "VoterReported",
arguments: [
"AccountId",
"AccountId",
"bool",
],
documentation: [
" A voter (first element) was reported (byt the second element) with the the report being",
" successful or not (third element).",
],
},
],
),
constants: [
ModuleConstantMetadata {
name: "CandidacyBond",
ty: "BalanceOf<T>",
value: [
0,
16,
165,
212,
232,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
],
documentation: [],
},
ModuleConstantMetadata {
name: "VotingBond",
ty: "BalanceOf<T>",
value: [
0,
116,
59,
164,
11,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
],
documentation: [],
},
ModuleConstantMetadata {
name: "DesiredMembers",
ty: "u32",
value: [
13,
0,
0,
0,
],
documentation: [],
},
ModuleConstantMetadata {
name: "DesiredRunnersUp",
ty: "u32",
value: [
7,
0,
0,
0,
],
documentation: [],
},
ModuleConstantMetadata {
name: "TermDuration",
ty: "T::BlockNumber",
value: [
64,
56,
0,
0,
],
documentation: [],
},
],
errors: [
ErrorMetadata {
name: "UnableToVote",
documentation: [
" Cannot vote when no candidates or members exist.",
],
},
ErrorMetadata {
name: "NoVotes",
documentation: [
" Must vote for at least one candidate.",
],
},
ErrorMetadata {
name: "TooManyVotes",
documentation: [
" Cannot vote more than candidates.",
],
},
ErrorMetadata {
name: "MaximumVotesExceeded",
documentation: [
" Cannot vote more than maximum allowed.",
],
},
ErrorMetadata {
name: "LowBalance",
documentation: [
" Cannot vote with stake less than minimum balance.",
],
},
ErrorMetadata {
name: "UnableToPayBond",
documentation: [
" Voter can not pay voting bond.",
],
},
ErrorMetadata {
name: "MustBeVoter",
documentation: [
" Must be a voter.",
],
},
ErrorMetadata {
name: "ReportSelf",
documentation: [
" Cannot report self.",
],
},
ErrorMetadata {
name: "DuplicatedCandidate",
documentation: [
" Duplicated candidate submission.",
],
},
ErrorMetadata {
name: "MemberSubmit",
documentation: [
" Member cannot re-submit candidacy.",
],
},
ErrorMetadata {
name: "RunnerSubmit",
documentation: [
" Runner cannot re-submit candidacy.",
],
},
ErrorMetadata {
name: "InsufficientCandidateFunds",
documentation: [
" Candidate does not have enough funds.",
],
},
ErrorMetadata {
name: "InvalidOrigin",
documentation: [
" Origin is not a candidate, member or a runner up.",
],
},
ErrorMetadata {
name: "NotMember",
documentation: [
" Not a member.",
],
},
],
},
ModuleMetadata {
name: "TechnicalMembership",
storage: Some(
StorageMetadata {
prefix: "Instance1Membership",
entries: [
StorageEntryMetadata {
name: "Members",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Plain(
"Vec<T::AccountId>",
),
default: [
0,
],
documentation: [
" The current membership, stored as an ordered Vec.",
],
},
StorageEntryMetadata {
name: "Prime",
modifier: StorageEntryModifier::Optional,
ty: StorageEntryType::Plain(
"T::AccountId",
),
default: [
0,
],
documentation: [
" The current prime member, if one exists.",
],
},
],
},
),
calls: Some(
[
FunctionMetadata {
name: "add_member",
arguments: [
FunctionArgumentMetadata {
name: "who",
ty: "T::AccountId",
},
],
documentation: [
" Add a member `who` to the set.",
"",
" May only be called from `AddOrigin` or root.",
],
},
FunctionMetadata {
name: "remove_member",
arguments: [
FunctionArgumentMetadata {
name: "who",
ty: "T::AccountId",
},
],
documentation: [
" Remove a member `who` from the set.",
"",
" May only be called from `RemoveOrigin` or root.",
],
},
FunctionMetadata {
name: "swap_member",
arguments: [
FunctionArgumentMetadata {
name: "remove",
ty: "T::AccountId",
},
FunctionArgumentMetadata {
name: "add",
ty: "T::AccountId",
},
],
documentation: [
" Swap out one member `remove` for another `add`.",
"",
" May only be called from `SwapOrigin` or root.",
"",
" Prime membership is *not* passed from `remove` to `add`, if extant.",
],
},
FunctionMetadata {
name: "reset_members",
arguments: [
FunctionArgumentMetadata {
name: "members",
ty: "Vec<T::AccountId>",
},
],
documentation: [
" Change the membership to a new set, disregarding the existing membership. Be nice and",
" pass `members` pre-sorted.",
"",
" May only be called from `ResetOrigin` or root.",
],
},
FunctionMetadata {
name: "change_key",
arguments: [
FunctionArgumentMetadata {
name: "new",
ty: "T::AccountId",
},
],
documentation: [
" Swap out the sending member for some other key `new`.",
"",
" May only be called from `Signed` origin of a current member.",
"",
" Prime membership is passed from the origin account to `new`, if extant.",
],
},
FunctionMetadata {
name: "set_prime",
arguments: [
FunctionArgumentMetadata {
name: "who",
ty: "T::AccountId",
},
],
documentation: [
" Set the prime member. Must be a current member.",
],
},
FunctionMetadata {
name: "clear_prime",
arguments: [],
documentation: [
" Remove the prime member if it exists.",
],
},
],
),
event: Some(
[
EventMetadata {
name: "MemberAdded",
arguments: [],
documentation: [
" The given member was added; see the transaction for who.",
],
},
EventMetadata {
name: "MemberRemoved",
arguments: [],
documentation: [
" The given member was removed; see the transaction for who.",
],
},
EventMetadata {
name: "MembersSwapped",
arguments: [],
documentation: [
" Two members were swapped; see the transaction for who.",
],
},
EventMetadata {
name: "MembersReset",
arguments: [],
documentation: [
" The membership was reset; see the transaction for who the new set is.",
],
},
EventMetadata {
name: "KeyChanged",
arguments: [],
documentation: [
" One of the members\' keys changed.",
],
},
EventMetadata {
name: "Dummy",
arguments: [
"sp_std::marker::PhantomData<(AccountId, Event)>",
],
documentation: [
" Phantom member, never used.",
],
},
],
),
constants: [],
errors: [],
},
ModuleMetadata {
name: "Treasury",
storage: Some(
StorageMetadata {
prefix: "Treasury",
entries: [
StorageEntryMetadata {
name: "ProposalCount",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Plain(
"ProposalIndex",
),
default: [
0,
0,
0,
0,
],
documentation: [
" Number of proposals that have been made.",
],
},
StorageEntryMetadata {
name: "Proposals",
modifier: StorageEntryModifier::Optional,
ty: StorageEntryType::Map {
hasher: StorageHasher::Twox64Concat,
key: "ProposalIndex",
value: "Proposal<T::AccountId, BalanceOf<T>>",
unused: false,
},
default: [
0,
],
documentation: [
" Proposals that have been made.",
],
},
StorageEntryMetadata {
name: "Approvals",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Plain(
"Vec<ProposalIndex>",
),
default: [
0,
],
documentation: [
" Proposal indices that have been approved but not yet awarded.",
],
},
StorageEntryMetadata {
name: "Tips",
modifier: StorageEntryModifier::Optional,
ty: StorageEntryType::Map {
hasher: StorageHasher::Twox64Concat,
key: "T::Hash",
value: "OpenTip<T::AccountId, BalanceOf<T>, T::BlockNumber, T::Hash>",
unused: false,
},
default: [
0,
],
documentation: [
" Tips that are not yet completed. Keyed by the hash of `(reason, who)` from the value.",
" This has the insecure enumerable hash function since the key itself is already",
" guaranteed to be a secure hash.",
],
},
StorageEntryMetadata {
name: "Reasons",
modifier: StorageEntryModifier::Optional,
ty: StorageEntryType::Map {
hasher: StorageHasher::Identity,
key: "T::Hash",
value: "Vec<u8>",
unused: false,
},
default: [
0,
],
documentation: [
" Simple preimage lookup from the reason\'s hash to the original data. Again, has an",
" insecure enumerable hash since the key is guaranteed to be the result of a secure hash.",
],
},
],
},
),
calls: Some(
[
FunctionMetadata {
name: "propose_spend",
arguments: [
FunctionArgumentMetadata {
name: "value",
ty: "Compact<BalanceOf<T>>",
},
FunctionArgumentMetadata {
name: "beneficiary",
ty: "<T::Lookup as StaticLookup>::Source",
},
],
documentation: [
" 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>",
" - O(1).",
" - Limited storage reads.",
" - One DB change, one extra DB entry.",
" # </weight>",
],
},
FunctionMetadata {
name: "reject_proposal",
arguments: [
FunctionArgumentMetadata {
name: "proposal_id",
ty: "Compact<ProposalIndex>",
},
],
documentation: [
" Reject a proposed spend. The original deposit will be slashed.",
"",
" # <weight>",
" - O(1).",
" - Limited storage reads.",
" - One DB clear.",
" # </weight>",
],
},
FunctionMetadata {
name: "approve_proposal",
arguments: [
FunctionArgumentMetadata {
name: "proposal_id",
ty: "Compact<ProposalIndex>",
},
],
documentation: [
" Approve a proposal. At a later time, the proposal will be allocated to the beneficiary",
" and the original deposit will be returned.",
"",
" # <weight>",
" - O(1).",
" - Limited storage reads.",
" - One DB change.",
" # </weight>",
],
},
FunctionMetadata {
name: "report_awesome",
arguments: [
FunctionArgumentMetadata {
name: "reason",
ty: "Vec<u8>",
},
FunctionArgumentMetadata {
name: "who",
ty: "T::AccountId",
},
],
documentation: [
" 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",
" `TipReportDepositPerByte` 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>",
" - `O(R)` where `R` length of `reason`.",
" - One balance operation.",
" - One storage mutation (codec `O(R)`).",
" - One event.",
" # </weight>",
],
},
FunctionMetadata {
name: "retract_tip",
arguments: [
FunctionArgumentMetadata {
name: "hash",
ty: "T::Hash",
},
],
documentation: [
" 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>",
" - `O(T)`",
" - One balance operation.",
" - Two storage removals (one read, codec `O(T)`).",
" - One event.",
" # </weight>",
],
},
FunctionMetadata {
name: "tip_new",
arguments: [
FunctionArgumentMetadata {
name: "reason",
ty: "Vec<u8>",
},
FunctionArgumentMetadata {
name: "who",
ty: "T::AccountId",
},
FunctionArgumentMetadata {
name: "tip_value",
ty: "BalanceOf<T>",
},
],
documentation: [
" 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>",
" - `O(R + T)` where `R` length of `reason`, `T` is the number of tippers. `T` is",
" naturally capped as a membership set, `R` is limited through transaction-size.",
" - Two storage insertions (codecs `O(R)`, `O(T)`), one read `O(1)`.",
" - One event.",
" # </weight>",
],
},
FunctionMetadata {
name: "tip",
arguments: [
FunctionArgumentMetadata {
name: "hash",
ty: "T::Hash",
},
FunctionArgumentMetadata {
name: "tip_value",
ty: "BalanceOf<T>",
},
],
documentation: [
" 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>",
" - `O(T)`",
" - One storage mutation (codec `O(T)`), one storage read `O(1)`.",
" - Up to one event.",
" # </weight>",
],
},
FunctionMetadata {
name: "close_tip",
arguments: [
FunctionArgumentMetadata {
name: "hash",
ty: "T::Hash",
},
],
documentation: [
" 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>",
" - `O(T)`",
" - One storage retrieval (codec `O(T)`) and two removals.",
" - Up to three balance operations.",
" # </weight>",
],
},
],
),
event: Some(
[
EventMetadata {
name: "Proposed",
arguments: [
"ProposalIndex",
],
documentation: [
" New proposal.",
],
},
EventMetadata {
name: "Spending",
arguments: [
"Balance",
],
documentation: [
" We have ended a spend period and will now allocate funds.",
],
},
EventMetadata {
name: "Awarded",
arguments: [
"ProposalIndex",
"Balance",
"AccountId",
],
documentation: [
" Some funds have been allocated.",
],
},
EventMetadata {
name: "Rejected",
arguments: [
"ProposalIndex",
"Balance",
],
documentation: [
" A proposal was rejected; funds were slashed.",
],
},
EventMetadata {
name: "Burnt",
arguments: [
"Balance",
],
documentation: [
" Some of our funds have been burnt.",
],
},
EventMetadata {
name: "Rollover",
arguments: [
"Balance",
],
documentation: [
" Spending has finished; this is the amount that rolls over until next spend.",
],
},
EventMetadata {
name: "Deposit",
arguments: [
"Balance",
],
documentation: [
" Some funds have been deposited.",
],
},
EventMetadata {
name: "NewTip",
arguments: [
"Hash",
],
documentation: [
" A new tip suggestion has been opened.",
],
},
EventMetadata {
name: "TipClosing",
arguments: [
"Hash",
],
documentation: [
" A tip suggestion has reached threshold and is closing.",
],
},
EventMetadata {
name: "TipClosed",
arguments: [
"Hash",
"AccountId",
"Balance",
],
documentation: [
" A tip suggestion has been closed.",
],
},
EventMetadata {
name: "TipRetracted",
arguments: [
"Hash",
],
documentation: [
" A tip suggestion has been retracted.",
],
},
],
),
constants: [
ModuleConstantMetadata {
name: "ProposalBond",
ty: "Permill",
value: [
80,
195,
0,
0,
],
documentation: [
" Fraction of a proposal\'s value that should be bonded in order to place the proposal.",
" An accepted proposal gets these back. A rejected proposal does not.",
],
},
ModuleConstantMetadata {
name: "ProposalBondMinimum",
ty: "BalanceOf<T>",
value: [
0,
64,
229,
156,
48,
18,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
],
documentation: [
" Minimum amount of funds that should be placed in a deposit for making a proposal.",
],
},
ModuleConstantMetadata {
name: "SpendPeriod",
ty: "T::BlockNumber",
value: [
128,
81,
1,
0,
],
documentation: [
" Period between successive spends.",
],
},
ModuleConstantMetadata {
name: "Burn",
ty: "Permill",
value: [
0,
0,
0,
0,
],
documentation: [
" Percentage of spare funds (if any) that are burnt per spend period.",
],
},
ModuleConstantMetadata {
name: "TipCountdown",
ty: "T::BlockNumber",
value: [
64,
56,
0,
0,
],
documentation: [
" The period for which a tip remains open after is has achieved threshold tippers.",
],
},
ModuleConstantMetadata {
name: "TipFindersFee",
ty: "Percent",
value: [
20,
],
documentation: [
" The amount of the final tip which goes to the original reporter of the tip.",
],
},
ModuleConstantMetadata {
name: "TipReportDepositBase",
ty: "BalanceOf<T>",
value: [
0,
16,
165,
212,
232,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
],
documentation: [
" The amount held on deposit for placing a tip report.",
],
},
ModuleConstantMetadata {
name: "TipReportDepositPerByte",
ty: "BalanceOf<T>",
value: [
0,
228,
11,
84,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
],
documentation: [
" The amount held on deposit per byte within the tip report reason.",
],
},
],
errors: [
ErrorMetadata {
name: "InsufficientProposersBalance",
documentation: [
" Proposer\'s balance is too low.",
],
},
ErrorMetadata {
name: "InvalidProposalIndex",
documentation: [
" No proposal at that index.",
],
},
ErrorMetadata {
name: "ReasonTooBig",
documentation: [
" The reason given is just too big.",
],
},
ErrorMetadata {
name: "AlreadyKnown",
documentation: [
" The tip was already found/started.",
],
},
ErrorMetadata {
name: "UnknownTip",
documentation: [
" The tip hash is unknown.",
],
},
ErrorMetadata {
name: "NotFinder",
documentation: [
" The account attempting to retract the tip is not the finder of the tip.",
],
},
ErrorMetadata {
name: "StillOpen",
documentation: [
" The tip cannot be claimed/closed because there are not enough tippers yet.",
],
},
ErrorMetadata {
name: "Premature",
documentation: [
" The tip cannot be claimed/closed because it\'s still in the countdown period.",
],
},
],
},
ModuleMetadata {
name: "Claims",
storage: Some(
StorageMetadata {
prefix: "Claims",
entries: [
StorageEntryMetadata {
name: "Claims",
modifier: StorageEntryModifier::Optional,
ty: StorageEntryType::Map {
hasher: StorageHasher::Identity,
key: "EthereumAddress",
value: "BalanceOf<T>",
unused: false,
},
default: [
0,
],
documentation: [],
},
StorageEntryMetadata {
name: "Total",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Plain(
"BalanceOf<T>",
),
default: [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
],
documentation: [],
},
StorageEntryMetadata {
name: "Vesting",
modifier: StorageEntryModifier::Optional,
ty: StorageEntryType::Map {
hasher: StorageHasher::Identity,
key: "EthereumAddress",
value: "(BalanceOf<T>, BalanceOf<T>, T::BlockNumber)",
unused: false,
},
default: [
0,
],
documentation: [
" Vesting schedule for a claim.",
" First balance is the total amount that should be held for vesting.",
" Second balance is how much should be unlocked per block.",
" The block number is when the vesting should start.",
],
},
],
},
),
calls: Some(
[
FunctionMetadata {
name: "claim",
arguments: [
FunctionArgumentMetadata {
name: "dest",
ty: "T::AccountId",
},
FunctionArgumentMetadata {
name: "ethereum_signature",
ty: "EcdsaSignature",
},
],
documentation: [
" Make a claim to collect your DOTs.",
"",
" The dispatch origin for this call must be _None_.",
"",
" Unsigned Validation:",
" A call to claim is deemed valid if the signature provided matches",
" the expected signed message of:",
"",
" > Ethereum Signed Message:",
" > (configured prefix string)(address)",
"",
" and `address` matches the `dest` account.",
"",
" Parameters:",
" - `dest`: The destination account to payout the claim.",
" - `ethereum_signature`: The signature of an ethereum signed message",
" matching the format described above.",
"",
" <weight>",
" The weight of this call is invariant over the input parameters.",
" - One `eth_recover` operation which involves a keccak hash and a",
" ecdsa recover.",
" - Three storage reads to check if a claim exists for the user, to",
" get the current pot size, to see if there exists a vesting schedule.",
" - Up to one storage write for adding a new vesting schedule.",
" - One `deposit_creating` Currency call.",
" - One storage write to update the total.",
" - Two storage removals for vesting and claims information.",
" - One deposit event.",
"",
" Total Complexity: O(1)",
" </weight>",
],
},
FunctionMetadata {
name: "mint_claim",
arguments: [
FunctionArgumentMetadata {
name: "who",
ty: "EthereumAddress",
},
FunctionArgumentMetadata {
name: "value",
ty: "BalanceOf<T>",
},
FunctionArgumentMetadata {
name: "vesting_schedule",
ty: "Option<(BalanceOf<T>, BalanceOf<T>, T::BlockNumber)>",
},
],
documentation: [
" Mint a new claim to collect DOTs.",
"",
" The dispatch origin for this call must be _Root_.",
"",
" Parameters:",
" - `who`: The Ethereum address allowed to collect this claim.",
" - `value`: The number of DOTs that will be claimed.",
" - `vesting_schedule`: An optional vesting schedule for these DOTs.",
"",
" <weight>",
" The weight of this call is invariant over the input parameters.",
" - One storage mutate to increase the total claims available.",
" - One storage write to add a new claim.",
" - Up to one storage write to add a new vesting schedule.",
"",
" Total Complexity: O(1)",
" </weight>",
],
},
],
),
event: Some(
[
EventMetadata {
name: "Claimed",
arguments: [
"AccountId",
"EthereumAddress",
"Balance",
],
documentation: [
" Someone claimed some DOTs.",
],
},
],
),
constants: [
ModuleConstantMetadata {
name: "Prefix",
ty: "&[u8]",
value: [
124,
80,
97,
121,
32,
75,
83,
77,
115,
32,
116,
111,
32,
116,
104,
101,
32,
75,
117,
115,
97,
109,
97,
32,
97,
99,
99,
111,
117,
110,
116,
58,
],
documentation: [
" The Prefix that is used in signed Ethereum messages for this network",
],
},
],
errors: [
ErrorMetadata {
name: "InvalidEthereumSignature",
documentation: [
" Invalid Ethereum signature.",
],
},
ErrorMetadata {
name: "SignerHasNoClaim",
documentation: [
" Ethereum address has no claim.",
],
},
ErrorMetadata {
name: "DestinationVesting",
documentation: [
" The destination is already vesting and cannot be the target of a further claim.",
],
},
ErrorMetadata {
name: "PotUnderflow",
documentation: [
" There\'s not enough in the pot to pay out some unvested amount. Generally implies a logic",
" error.",
],
},
],
},
ModuleMetadata {
name: "Parachains",
storage: Some(
StorageMetadata {
prefix: "Parachains",
entries: [
StorageEntryMetadata {
name: "Authorities",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Plain(
"Vec<ValidatorId>",
),
default: [
0,
],
documentation: [
" All authorities\' keys at the moment.",
],
},
StorageEntryMetadata {
name: "Code",
modifier: StorageEntryModifier::Optional,
ty: StorageEntryType::Map {
hasher: StorageHasher::Twox64Concat,
key: "ParaId",
value: "Vec<u8>",
unused: false,
},
default: [
0,
],
documentation: [
" The parachains registered at present.",
],
},
StorageEntryMetadata {
name: "Heads",
modifier: StorageEntryModifier::Optional,
ty: StorageEntryType::Map {
hasher: StorageHasher::Twox64Concat,
key: "ParaId",
value: "Vec<u8>",
unused: false,
},
default: [
0,
],
documentation: [
" The heads of the parachains registered at present.",
],
},
StorageEntryMetadata {
name: "RelayDispatchQueue",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Map {
hasher: StorageHasher::Twox64Concat,
key: "ParaId",
value: "Vec<UpwardMessage>",
unused: false,
},
default: [
0,
],
documentation: [
" Messages ready to be dispatched onto the relay chain. It is subject to",
" `MAX_MESSAGE_COUNT` and `WATERMARK_MESSAGE_SIZE`.",
],
},
StorageEntryMetadata {
name: "RelayDispatchQueueSize",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Map {
hasher: StorageHasher::Twox64Concat,
key: "ParaId",
value: "(u32, u32)",
unused: false,
},
default: [
0,
0,
0,
0,
0,
0,
0,
0,
],
documentation: [
" Size of the dispatch queues. Separated from actual data in order to avoid costly",
" decoding when checking receipt validity. First item in tuple is the count of messages",
"\tsecond if the total length (in bytes) of the message payloads.",
],
},
StorageEntryMetadata {
name: "NeedsDispatch",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Plain(
"Vec<ParaId>",
),
default: [
0,
],
documentation: [
" The ordered list of ParaIds that have a `RelayDispatchQueue` entry.",
],
},
StorageEntryMetadata {
name: "DidUpdate",
modifier: StorageEntryModifier::Optional,
ty: StorageEntryType::Plain(
"Vec<ParaId>",
),
default: [
0,
],
documentation: [
" `Some` if the parachain heads get updated in this block, along with the parachain IDs",
" that did update. Ordered in the same way as `registrar::Active` (i.e. by ParaId).",
"",
" `None` if not yet updated.",
],
},
],
},
),
calls: Some(
[
FunctionMetadata {
name: "set_heads",
arguments: [
FunctionArgumentMetadata {
name: "heads",
ty: "Vec<AttestedCandidate>",
},
],
documentation: [
" Provide candidate receipts for parachains, in ascending order by id.",
],
},
],
),
event: None,
constants: [],
errors: [
ErrorMetadata {
name: "TooManyHeadUpdates",
documentation: [
" Parachain heads must be updated only once in the block.",
],
},
ErrorMetadata {
name: "TooManyParaCandidates",
documentation: [
" Too many parachain candidates.",
],
},
ErrorMetadata {
name: "HeadsOutOfOrder",
documentation: [
" Proposed heads must be ascending order by parachain ID without duplicate.",
],
},
ErrorMetadata {
name: "UnregisteredPara",
documentation: [
" Candidate is for an unregistered parachain.",
],
},
ErrorMetadata {
name: "InvalidCollator",
documentation: [
" Invalid collator.",
],
},
ErrorMetadata {
name: "QueueFull",
documentation: [
" The message queue is full. Messages will be added when there is space.",
],
},
ErrorMetadata {
name: "InvalidMessageOrigin",
documentation: [
" The message origin is invalid.",
],
},
ErrorMetadata {
name: "NoValidatorGroup",
documentation: [
" No validator group for parachain.",
],
},
ErrorMetadata {
name: "NotEnoughValidityVotes",
documentation: [
" Not enough validity votes for candidate.",
],
},
ErrorMetadata {
name: "VotesExceedsAuthorities",
documentation: [
" The number of attestations exceeds the number of authorities.",
],
},
ErrorMetadata {
name: "WrongValidatorAttesting",
documentation: [
" Attesting validator not on this chain\'s validation duty.",
],
},
ErrorMetadata {
name: "InvalidSignature",
documentation: [
" Invalid signature from attester.",
],
},
ErrorMetadata {
name: "UntaggedVotes",
documentation: [
" Extra untagged validity votes along with candidate.",
],
},
ErrorMetadata {
name: "ParentMismatch",
documentation: [
" Wrong parent head for parachain receipt.",
],
},
ErrorMetadata {
name: "HeadDataTooLarge",
documentation: [
" Head data was too large.",
],
},
ErrorMetadata {
name: "CannotPayFees",
documentation: [
" Para does not have enough balance to pay fees.",
],
},
ErrorMetadata {
name: "UnexpectedRelayParent",
documentation: [
" Unexpected relay-parent for a candidate receipt.",
],
},
],
},
ModuleMetadata {
name: "Attestations",
storage: Some(
StorageMetadata {
prefix: "Attestations",
entries: [
StorageEntryMetadata {
name: "RecentParaBlocks",
modifier: StorageEntryModifier::Optional,
ty: StorageEntryType::Map {
hasher: StorageHasher::Twox64Concat,
key: "T::BlockNumber",
value: "IncludedBlocks<T>",
unused: false,
},
default: [
0,
],
documentation: [
" A mapping from modular block number (n % AttestationPeriod)",
" to session index and the list of candidate hashes.",
],
},
StorageEntryMetadata {
name: "ParaBlockAttestations",
modifier: StorageEntryModifier::Optional,
ty: StorageEntryType::DoubleMap {
hasher: StorageHasher::Twox64Concat,
key1: "T::BlockNumber",
key2: "Hash",
value: "BlockAttestations<T>",
key2_hasher: StorageHasher::Identity,
},
default: [
0,
],
documentation: [
" Attestations on a recent parachain block.",
],
},
StorageEntryMetadata {
name: "DidUpdate",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Plain(
"bool",
),
default: [
0,
],
documentation: [],
},
],
},
),
calls: Some(
[
FunctionMetadata {
name: "more_attestations",
arguments: [
FunctionArgumentMetadata {
name: "_more",
ty: "MoreAttestations",
},
],
documentation: [
" Provide candidate receipts for parachains, in ascending order by id.",
],
},
],
),
event: None,
constants: [],
errors: [
ErrorMetadata {
name: "TooManyAttestations",
documentation: [
" More attestations can be added only once in a block.",
],
},
],
},
ModuleMetadata {
name: "Slots",
storage: Some(
StorageMetadata {
prefix: "Slots",
entries: [
StorageEntryMetadata {
name: "AuctionCounter",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Plain(
"AuctionIndex",
),
default: [
0,
0,
0,
0,
],
documentation: [
" The number of auctions that have been started so far.",
],
},
StorageEntryMetadata {
name: "ManagedIds",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Plain(
"Vec<ParaId>",
),
default: [
0,
],
documentation: [
" Ordered list of all `ParaId` values that are managed by this module. This includes",
" chains that are not yet deployed (but have won an auction in the future).",
],
},
StorageEntryMetadata {
name: "Deposits",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Map {
hasher: StorageHasher::Twox64Concat,
key: "ParaId",
value: "Vec<BalanceOf<T>>",
unused: false,
},
default: [
0,
],
documentation: [
" Various amounts on deposit for each parachain. An entry in `ManagedIds` implies a non-",
" default entry here.",
"",
" The actual amount locked on its behalf at any time is the maximum item in this list. The",
" first item in the list is the amount locked for the current Lease Period. Following",
" items are for the subsequent lease periods.",
"",
" The default value (an empty list) implies that the parachain no longer exists (or never",
" existed) as far as this module is concerned.",
"",
" If a parachain doesn\'t exist *yet* but is scheduled to exist in the future, then it",
" will be left-padded with one or more zeroes to denote the fact that nothing is held on",
" deposit for the non-existent chain currently, but is held at some point in the future.",
],
},
StorageEntryMetadata {
name: "AuctionInfo",
modifier: StorageEntryModifier::Optional,
ty: StorageEntryType::Plain(
"(LeasePeriodOf<T>, T::BlockNumber)",
),
default: [
0,
],
documentation: [
" Information relating to the current auction, if there is one.",
"",
" The first item in the tuple is the lease period index that the first of the four",
" contiguous lease periods on auction is for. The second is the block number when the",
" auction will \"begin to end\", i.e. the first block of the Ending Period of the auction.",
],
},
StorageEntryMetadata {
name: "Winning",
modifier: StorageEntryModifier::Optional,
ty: StorageEntryType::Map {
hasher: StorageHasher::Twox64Concat,
key: "T::BlockNumber",
value: "WinningData<T>",
unused: false,
},
default: [
0,
],
documentation: [
" The winning bids for each of the 10 ranges at each block in the final Ending Period of",
" the current auction. The map\'s key is the 0-based index into the Ending Period. The",
" first block of the ending period is 0; the last is `EndingPeriod - 1`.",
],
},
StorageEntryMetadata {
name: "ReservedAmounts",
modifier: StorageEntryModifier::Optional,
ty: StorageEntryType::Map {
hasher: StorageHasher::Twox64Concat,
key: "Bidder<T::AccountId>",
value: "BalanceOf<T>",
unused: false,
},
default: [
0,
],
documentation: [
" Amounts currently reserved in the accounts of the bidders currently winning",
" (sub-)ranges.",
],
},
StorageEntryMetadata {
name: "OnboardQueue",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Map {
hasher: StorageHasher::Twox64Concat,
key: "LeasePeriodOf<T>",
value: "Vec<ParaId>",
unused: false,
},
default: [
0,
],
documentation: [
" The set of Para IDs that have won and need to be on-boarded at an upcoming lease-period.",
" This is cleared out on the first block of the lease period.",
],
},
StorageEntryMetadata {
name: "Onboarding",
modifier: StorageEntryModifier::Optional,
ty: StorageEntryType::Map {
hasher: StorageHasher::Twox64Concat,
key: "ParaId",
value: "(LeasePeriodOf<T>, IncomingParachain<T::AccountId, T::Hash>)",
unused: false,
},
default: [
0,
],
documentation: [
" The actual on-boarding information. Only exists when one of the following is true:",
" - It is before the lease period that the parachain should be on-boarded.",
" - The full on-boarding information has not yet been provided and the parachain is not",
" yet due to be off-boarded.",
],
},
StorageEntryMetadata {
name: "Offboarding",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Map {
hasher: StorageHasher::Twox64Concat,
key: "ParaId",
value: "T::AccountId",
unused: false,
},
default: [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
],
documentation: [
" Off-boarding account; currency held on deposit for the parachain gets placed here if the",
" parachain gets off-boarded; i.e. its lease period is up and it isn\'t renewed.",
],
},
],
},
),
calls: Some(
[
FunctionMetadata {
name: "new_auction",
arguments: [
FunctionArgumentMetadata {
name: "duration",
ty: "Compact<T::BlockNumber>",
},
FunctionArgumentMetadata {
name: "lease_period_index",
ty: "Compact<LeasePeriodOf<T>>",
},
],
documentation: [
" Create a new auction.",
"",
" This can only happen when there isn\'t already an auction in progress and may only be",
" called by the root origin. Accepts the `duration` of this auction and the",
" `lease_period_index` of the initial lease period of the four that are to be auctioned.",
],
},
FunctionMetadata {
name: "bid",
arguments: [
FunctionArgumentMetadata {
name: "sub",
ty: "Compact<SubId>",
},
FunctionArgumentMetadata {
name: "auction_index",
ty: "Compact<AuctionIndex>",
},
FunctionArgumentMetadata {
name: "first_slot",
ty: "Compact<LeasePeriodOf<T>>",
},
FunctionArgumentMetadata {
name: "last_slot",
ty: "Compact<LeasePeriodOf<T>>",
},
FunctionArgumentMetadata {
name: "amount",
ty: "Compact<BalanceOf<T>>",
},
],
documentation: [
" Make a new bid from an account (including a parachain account) for deploying a new",
" parachain.",
"",
" Multiple simultaneous bids from the same bidder are allowed only as long as all active",
" bids overlap each other (i.e. are mutually exclusive). Bids cannot be redacted.",
"",
" - `sub` is the sub-bidder ID, allowing for multiple competing bids to be made by (and",
" funded by) the same account.",
" - `auction_index` is the index of the auction to bid on. Should just be the present",
" value of `AuctionCounter`.",
" - `first_slot` is the first lease period index of the range to bid on. This is the",
" absolute lease period index value, not an auction-specific offset.",
" - `last_slot` is the last lease period index of the range to bid on. This is the",
" absolute lease period index value, not an auction-specific offset.",
" - `amount` is the amount to bid to be held as deposit for the parachain should the",
" bid win. This amount is held throughout the range.",
],
},
FunctionMetadata {
name: "bid_renew",
arguments: [
FunctionArgumentMetadata {
name: "auction_index",
ty: "Compact<AuctionIndex>",
},
FunctionArgumentMetadata {
name: "first_slot",
ty: "Compact<LeasePeriodOf<T>>",
},
FunctionArgumentMetadata {
name: "last_slot",
ty: "Compact<LeasePeriodOf<T>>",
},
FunctionArgumentMetadata {
name: "amount",
ty: "Compact<BalanceOf<T>>",
},
],
documentation: [
" Make a new bid from a parachain account for renewing that (pre-existing) parachain.",
"",
" The origin *must* be a parachain account.",
"",
" Multiple simultaneous bids from the same bidder are allowed only as long as all active",
" bids overlap each other (i.e. are mutually exclusive). Bids cannot be redacted.",
"",
" - `auction_index` is the index of the auction to bid on. Should just be the present",
" value of `AuctionCounter`.",
" - `first_slot` is the first lease period index of the range to bid on. This is the",
" absolute lease period index value, not an auction-specific offset.",
" - `last_slot` is the last lease period index of the range to bid on. This is the",
" absolute lease period index value, not an auction-specific offset.",
" - `amount` is the amount to bid to be held as deposit for the parachain should the",
" bid win. This amount is held throughout the range.",
],
},
FunctionMetadata {
name: "set_offboarding",
arguments: [
FunctionArgumentMetadata {
name: "dest",
ty: "<T::Lookup as StaticLookup>::Source",
},
],
documentation: [
" Set the off-boarding information for a parachain.",
"",
" The origin *must* be a parachain account.",
"",
" - `dest` is the destination account to receive the parachain\'s deposit.",
],
},
FunctionMetadata {
name: "fix_deploy_data",
arguments: [
FunctionArgumentMetadata {
name: "sub",
ty: "Compact<SubId>",
},
FunctionArgumentMetadata {
name: "para_id",
ty: "Compact<ParaId>",
},
FunctionArgumentMetadata {
name: "code_hash",
ty: "T::Hash",
},
FunctionArgumentMetadata {
name: "code_size",
ty: "u32",
},
FunctionArgumentMetadata {
name: "initial_head_data",
ty: "Vec<u8>",
},
],
documentation: [
" Set the deploy information for a successful bid to deploy a new parachain.",
"",
" - `origin` must be the successful bidder account.",
" - `sub` is the sub-bidder ID of the bidder.",
" - `para_id` is the parachain ID allotted to the winning bidder.",
" - `code_hash` is the hash of the parachain\'s Wasm validation function.",
" - `initial_head_data` is the parachain\'s initial head data.",
],
},
FunctionMetadata {
name: "elaborate_deploy_data",
arguments: [
FunctionArgumentMetadata {
name: "para_id",
ty: "Compact<ParaId>",
},
FunctionArgumentMetadata {
name: "code",
ty: "Vec<u8>",
},
],
documentation: [
" Note a new parachain\'s code.",
"",
" This must be called after `fix_deploy_data` and `code` must be the preimage of the",
" `code_hash` passed there for the same `para_id`.",
"",
" This may be called before or after the beginning of the parachain\'s first lease period.",
" If called before then the parachain will become active at the first block of its",
" starting lease period. If after, then it will become active immediately after this call.",
"",
" - `_origin` is irrelevant.",
" - `para_id` is the parachain ID whose code will be elaborated.",
" - `code` is the preimage of the registered `code_hash` of `para_id`.",
],
},
],
),
event: Some(
[
EventMetadata {
name: "NewLeasePeriod",
arguments: [
"LeasePeriod",
],
documentation: [
" A new lease period is beginning.",
],
},
EventMetadata {
name: "AuctionStarted",
arguments: [
"AuctionIndex",
"LeasePeriod",
"BlockNumber",
],
documentation: [
" An auction started. Provides its index and the block number where it will begin to",
" close and the first lease period of the quadruplet that is auctioned.",
],
},
EventMetadata {
name: "AuctionClosed",
arguments: [
"AuctionIndex",
],
documentation: [
" An auction ended. All funds become unreserved.",
],
},
EventMetadata {
name: "WonDeploy",
arguments: [
"NewBidder<AccountId>",
"SlotRange",
"ParaId",
"Balance",
],
documentation: [
" Someone won the right to deploy a parachain. Balance amount is deducted for deposit.",
],
},
EventMetadata {
name: "WonRenewal",
arguments: [
"ParaId",
"SlotRange",
"Balance",
"Balance",
],
documentation: [
" An existing parachain won the right to continue.",
" First balance is the extra amount reseved. Second is the total amount reserved.",
],
},
EventMetadata {
name: "Reserved",
arguments: [
"AccountId",
"Balance",
"Balance",
],
documentation: [
" Funds were reserved for a winning bid. First balance is the extra amount reserved.",
" Second is the total.",
],
},
EventMetadata {
name: "Unreserved",
arguments: [
"AccountId",
"Balance",
],
documentation: [
" Funds were unreserved since bidder is no longer active.",
],
},
],
),
constants: [],
errors: [
ErrorMetadata {
name: "AuctionInProgress",
documentation: [
" This auction is already in progress.",
],
},
ErrorMetadata {
name: "LeasePeriodInPast",
documentation: [
" The lease period is in the past.",
],
},
ErrorMetadata {
name: "NotParaOrigin",
documentation: [
" The origin for this call must be a parachain.",
],
},
ErrorMetadata {
name: "ParaNotOnboarding",
documentation: [
" The parachain ID is not onboarding.",
],
},
ErrorMetadata {
name: "InvalidOrigin",
documentation: [
" The origin for this call must be the origin who registered the parachain.",
],
},
ErrorMetadata {
name: "AlreadyRegistered",
documentation: [
" Parachain is already registered.",
],
},
ErrorMetadata {
name: "InvalidCode",
documentation: [
" The code must correspond to the hash.",
],
},
ErrorMetadata {
name: "UnsetDeployData",
documentation: [
" Deployment data has not been set for this parachain.",
],
},
ErrorMetadata {
name: "NonIntersectingRange",
documentation: [
" The bid must overlap all intersecting ranges.",
],
},
ErrorMetadata {
name: "NotCurrentAuction",
documentation: [
" Not a current auction.",
],
},
ErrorMetadata {
name: "NotAuction",
documentation: [
" Not an auction.",
],
},
ErrorMetadata {
name: "CodeTooLarge",
documentation: [
" Given code size is too large.",
],
},
ErrorMetadata {
name: "HeadDataTooLarge",
documentation: [
" Given initial head data is too large.",
],
},
],
},
ModuleMetadata {
name: "Registrar",
storage: Some(
StorageMetadata {
prefix: "Registrar",
entries: [
StorageEntryMetadata {
name: "Parachains",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Plain(
"Vec<ParaId>",
),
default: [
0,
],
documentation: [],
},
StorageEntryMetadata {
name: "ThreadCount",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Plain(
"u32",
),
default: [
0,
0,
0,
0,
],
documentation: [
" The number of threads to schedule per block.",
],
},
StorageEntryMetadata {
name: "SelectedThreads",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Plain(
"Vec<Vec<(ParaId, CollatorId)>>",
),
default: [
0,
],
documentation: [
" An array of the queue of set of threads scheduled for the coming blocks; ordered by",
" ascending para ID. There can be no duplicates of para ID in each list item.",
],
},
StorageEntryMetadata {
name: "Active",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Plain(
"Vec<(ParaId, Option<(CollatorId, Retriable)>)>",
),
default: [
0,
],
documentation: [
" Parathreads/chains scheduled for execution this block. If the collator ID is set, then",
" a particular collator has already been chosen for the next block, and no other collator",
" may provide the block. In this case we allow the possibility of the combination being",
" retried in a later block, expressed by `Retriable`.",
"",
" Ordered by ParaId.",
],
},
StorageEntryMetadata {
name: "NextFreeId",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Plain(
"ParaId",
),
default: [
232,
3,
0,
0,
],
documentation: [
" The next unused ParaId value. Start this high in order to keep low numbers for",
" system-level chains.",
],
},
StorageEntryMetadata {
name: "PendingSwap",
modifier: StorageEntryModifier::Optional,
ty: StorageEntryType::Map {
hasher: StorageHasher::Twox64Concat,
key: "ParaId",
value: "ParaId",
unused: false,
},
default: [
0,
],
documentation: [
" Pending swap operations.",
],
},
StorageEntryMetadata {
name: "Paras",
modifier: StorageEntryModifier::Optional,
ty: StorageEntryType::Map {
hasher: StorageHasher::Twox64Concat,
key: "ParaId",
value: "ParaInfo",
unused: false,
},
default: [
0,
],
documentation: [
" Map of all registered parathreads/chains.",
],
},
StorageEntryMetadata {
name: "RetryQueue",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Plain(
"Vec<Vec<(ParaId, CollatorId)>>",
),
default: [
0,
],
documentation: [
" The current queue for parathreads that should be retried.",
],
},
StorageEntryMetadata {
name: "Debtors",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Map {
hasher: StorageHasher::Twox64Concat,
key: "ParaId",
value: "T::AccountId",
unused: false,
},
default: [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
],
documentation: [
" Users who have paid a parathread\'s deposit",
],
},
],
},
),
calls: Some(
[
FunctionMetadata {
name: "register_para",
arguments: [
FunctionArgumentMetadata {
name: "id",
ty: "Compact<ParaId>",
},
FunctionArgumentMetadata {
name: "info",
ty: "ParaInfo",
},
FunctionArgumentMetadata {
name: "code",
ty: "Vec<u8>",
},
FunctionArgumentMetadata {
name: "initial_head_data",
ty: "Vec<u8>",
},
],
documentation: [
" Register a parachain with given code. Must be called by root.",
" Fails if given ID is already used.",
"",
" Unlike the `Registrar` trait function of the same name, this",
" checks the code and head data against size limits.",
],
},
FunctionMetadata {
name: "deregister_para",
arguments: [
FunctionArgumentMetadata {
name: "id",
ty: "Compact<ParaId>",
},
],
documentation: [
" Deregister a parachain with given id",
],
},
FunctionMetadata {
name: "set_thread_count",
arguments: [
FunctionArgumentMetadata {
name: "count",
ty: "u32",
},
],
documentation: [
" Reset the number of parathreads that can pay to be scheduled in a single block.",
"",
" - `count`: The number of parathreads.",
"",
" Must be called from Root origin.",
],
},
FunctionMetadata {
name: "register_parathread",
arguments: [
FunctionArgumentMetadata {
name: "code",
ty: "Vec<u8>",
},
FunctionArgumentMetadata {
name: "initial_head_data",
ty: "Vec<u8>",
},
],
documentation: [
" Register a parathread for immediate use.",
"",
" Must be sent from a Signed origin that is able to have ParathreadDeposit reserved.",
" `code` and `initial_head_data` are used to initialize the parathread\'s state.",
"",
" Unlike `register_para`, this function does check that the maximum code size",
" and head data size are respected, as parathread registration is an atomic",
" action.",
],
},
FunctionMetadata {
name: "select_parathread",
arguments: [
FunctionArgumentMetadata {
name: "_id",
ty: "Compact<ParaId>",
},
FunctionArgumentMetadata {
name: "_collator",
ty: "CollatorId",
},
FunctionArgumentMetadata {
name: "_head_hash",
ty: "T::Hash",
},
],
documentation: [
" Place a bid for a parathread to be progressed in the next block.",
"",
" This is a kind of special transaction that should be heavily prioritized in the",
" transaction pool according to the `value`; only `ThreadCount` of them may be presented",
" in any single block.",
],
},
FunctionMetadata {
name: "deregister_parathread",
arguments: [],
documentation: [
" Deregister a parathread and retrieve the deposit.",
"",
" Must be sent from a `Parachain` origin which is currently a parathread.",
"",
" Ensure that before calling this that any funds you want emptied from the parathread\'s",
" account is moved out; after this it will be impossible to retrieve them (without",
" governance intervention).",
],
},
FunctionMetadata {
name: "swap",
arguments: [
FunctionArgumentMetadata {
name: "other",
ty: "Compact<ParaId>",
},
],
documentation: [
" Swap a parachain with another parachain or parathread. The origin must be a `Parachain`.",
" The swap will happen only if there is already an opposite swap pending. If there is not,",
" the swap will be stored in the pending swaps map, ready for a later confirmatory swap.",
"",
" The `ParaId`s remain mapped to the same head data and code so external code can rely on",
" `ParaId` to be a long-term identifier of a notional \"parachain\". However, their",
" scheduling info (i.e. whether they\'re a parathread or parachain), auction information",
" and the auction deposit are switched.",
],
},
],
),
event: Some(
[
EventMetadata {
name: "ParathreadRegistered",
arguments: [
"ParaId",
],
documentation: [
" A parathread was registered; its new ID is supplied.",
],
},
EventMetadata {
name: "ParathreadDeregistered",
arguments: [
"ParaId",
],
documentation: [
" The parathread of the supplied ID was de-registered.",
],
},
],
),
constants: [],
errors: [
ErrorMetadata {
name: "ParaAlreadyExists",
documentation: [
" Parachain already exists.",
],
},
ErrorMetadata {
name: "InvalidChainId",
documentation: [
" Invalid parachain ID.",
],
},
ErrorMetadata {
name: "InvalidThreadId",
documentation: [
" Invalid parathread ID.",
],
},
ErrorMetadata {
name: "CodeTooLarge",
documentation: [
" Invalid para code size.",
],
},
ErrorMetadata {
name: "HeadDataTooLarge",
documentation: [
" Invalid para head data size.",
],
},
],
},
ModuleMetadata {
name: "Utility",
storage: Some(
StorageMetadata {
prefix: "Utility",
entries: [
StorageEntryMetadata {
name: "Multisigs",
modifier: StorageEntryModifier::Optional,
ty: StorageEntryType::DoubleMap {
hasher: StorageHasher::Twox64Concat,
key1: "T::AccountId",
key2: "[u8; 32]",
value: "Multisig<T::BlockNumber, BalanceOf<T>, T::AccountId>",
key2_hasher: StorageHasher::Blake2_128Concat,
},
default: [
0,
],
documentation: [
" The set of open multisig operations.",
],
},
],
},
),
calls: Some(
[
FunctionMetadata {
name: "batch",
arguments: [
FunctionArgumentMetadata {
name: "calls",
ty: "Vec<<T as Trait>::Call>",
},
],
documentation: [
" Send a batch of dispatch calls.",
"",
" This will execute until the first one fails and then stop.",
"",
" May be called from any origin.",
"",
" - `calls`: The calls to be dispatched from the same origin.",
"",
" # <weight>",
" - The sum of the weights of the `calls`.",
" - One event.",
" # </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.",
],
},
FunctionMetadata {
name: "as_sub",
arguments: [
FunctionArgumentMetadata {
name: "index",
ty: "u16",
},
FunctionArgumentMetadata {
name: "call",
ty: "Box<<T as Trait>::Call>",
},
],
documentation: [
" Send a call through an indexed pseudonym of the sender.",
"",
" The dispatch origin for this call must be _Signed_.",
"",
" # <weight>",
" - The weight of the `call` + 10,000.",
" # </weight>",
],
},
FunctionMetadata {
name: "as_multi",
arguments: [
FunctionArgumentMetadata {
name: "threshold",
ty: "u16",
},
FunctionArgumentMetadata {
name: "other_signatories",
ty: "Vec<T::AccountId>",
},
FunctionArgumentMetadata {
name: "maybe_timepoint",
ty: "Option<Timepoint<T::BlockNumber>>",
},
FunctionArgumentMetadata {
name: "call",
ty: "Box<<T as Trait>::Call>",
},
],
documentation: [
" 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: `MultisigDepositBase` will be reserved if this is the first approval, plus",
" `threshold` times `MultisigDepositFactor`. 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",
" `MultisigDepositBase + threshold * MultisigDepositFactor`.",
" # </weight>",
],
},
FunctionMetadata {
name: "approve_as_multi",
arguments: [
FunctionArgumentMetadata {
name: "threshold",
ty: "u16",
},
FunctionArgumentMetadata {
name: "other_signatories",
ty: "Vec<T::AccountId>",
},
FunctionArgumentMetadata {
name: "maybe_timepoint",
ty: "Option<Timepoint<T::BlockNumber>>",
},
FunctionArgumentMetadata {
name: "call_hash",
ty: "[u8; 32]",
},
],
documentation: [
" 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: `MultisigDepositBase` will be reserved if this is the first approval, plus",
" `threshold` times `MultisigDepositFactor`. 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",
" `MultisigDepositBase + threshold * MultisigDepositFactor`.",
" # </weight>",
],
},
FunctionMetadata {
name: "cancel_as_multi",
arguments: [
FunctionArgumentMetadata {
name: "threshold",
ty: "u16",
},
FunctionArgumentMetadata {
name: "other_signatories",
ty: "Vec<T::AccountId>",
},
FunctionArgumentMetadata {
name: "timepoint",
ty: "Timepoint<T::BlockNumber>",
},
FunctionArgumentMetadata {
name: "call_hash",
ty: "[u8; 32]",
},
],
documentation: [
" 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.",
" # </weight>",
],
},
],
),
event: Some(
[
EventMetadata {
name: "BatchInterrupted",
arguments: [
"u32",
"DispatchError",
],
documentation: [
" Batch of dispatches did not complete fully. Index of first failing dispatch given, as",
" well as the error.",
],
},
EventMetadata {
name: "BatchCompleted",
arguments: [],
documentation: [
" Batch of dispatches completed fully with no error.",
],
},
EventMetadata {
name: "NewMultisig",
arguments: [
"AccountId",
"AccountId",
],
documentation: [
" A new multisig operation has begun. First param is the account that is approving,",
" second is the multisig account.",
],
},
EventMetadata {
name: "MultisigApproval",
arguments: [
"AccountId",
"Timepoint<BlockNumber>",
"AccountId",
],
documentation: [
" A multisig operation has been approved by someone. First param is the account that is",
" approving, third is the multisig account.",
],
},
EventMetadata {
name: "MultisigExecuted",
arguments: [
"AccountId",
"Timepoint<BlockNumber>",
"AccountId",
"DispatchResult",
],
documentation: [
" A multisig operation has been executed. First param is the account that is",
" approving, third is the multisig account.",
],
},
EventMetadata {
name: "MultisigCancelled",
arguments: [
"AccountId",
"Timepoint<BlockNumber>",
"AccountId",
],
documentation: [
" A multisig operation has been cancelled. First param is the account that is",
" cancelling, third is the multisig account.",
],
},
],
),
constants: [],
errors: [
ErrorMetadata {
name: "ZeroThreshold",
documentation: [
" Threshold is too low (zero).",
],
},
ErrorMetadata {
name: "AlreadyApproved",
documentation: [
" Call is already approved by this signatory.",
],
},
ErrorMetadata {
name: "NoApprovalsNeeded",
documentation: [
" Call doesn\'t need any (more) approvals.",
],
},
ErrorMetadata {
name: "TooFewSignatories",
documentation: [
" There are too few signatories in the list.",
],
},
ErrorMetadata {
name: "TooManySignatories",
documentation: [
" There are too many signatories in the list.",
],
},
ErrorMetadata {
name: "SignatoriesOutOfOrder",
documentation: [
" The signatories were provided out of order; they should be ordered.",
],
},
ErrorMetadata {
name: "SenderInSignatories",
documentation: [
" The sender was contained in the other signatories; it shouldn\'t be.",
],
},
ErrorMetadata {
name: "NotFound",
documentation: [
" Multisig operation not found when attempting to cancel.",
],
},
ErrorMetadata {
name: "NotOwner",
documentation: [
" Only the account that originally created the multisig is able to cancel it.",
],
},
ErrorMetadata {
name: "NoTimepoint",
documentation: [
" No timepoint was given, yet the multisig operation is already underway.",
],
},
ErrorMetadata {
name: "WrongTimepoint",
documentation: [
" A different timepoint was given to the multisig operation that is underway.",
],
},
ErrorMetadata {
name: "UnexpectedTimepoint",
documentation: [
" A timepoint was given, yet no multisig operation is underway.",
],
},
],
},
ModuleMetadata {
name: "Identity",
storage: Some(
StorageMetadata {
prefix: "Identity",
entries: [
StorageEntryMetadata {
name: "IdentityOf",
modifier: StorageEntryModifier::Optional,
ty: StorageEntryType::Map {
hasher: StorageHasher::Twox64Concat,
key: "T::AccountId",
value: "Registration<BalanceOf<T>>",
unused: false,
},
default: [
0,
],
documentation: [
" Information that is pertinent to identify the entity behind an account.",
],
},
StorageEntryMetadata {
name: "SuperOf",
modifier: StorageEntryModifier::Optional,
ty: StorageEntryType::Map {
hasher: StorageHasher::Blake2_128Concat,
key: "T::AccountId",
value: "(T::AccountId, Data)",
unused: false,
},
default: [
0,
],
documentation: [
" The super-identity of an alternative \"sub\" identity together with its name, within that",
" context. If the account is not some other account\'s sub-identity, then just `None`.",
],
},
StorageEntryMetadata {
name: "SubsOf",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Map {
hasher: StorageHasher::Twox64Concat,
key: "T::AccountId",
value: "(BalanceOf<T>, Vec<T::AccountId>)",
unused: false,
},
default: [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
],
documentation: [
" Alternative \"sub\" identities of this account.",
"",
" The first item is the deposit, the second is a vector of the accounts.",
],
},
StorageEntryMetadata {
name: "Registrars",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Plain(
"Vec<Option<RegistrarInfo<BalanceOf<T>, T::AccountId>>>",
),
default: [
0,
],
documentation: [
" The set of registrars. Not expected to get very big as can only be added through a",
" special origin (likely a council motion).",
"",
" The index into this can be cast to `RegistrarIndex` to get a valid value.",
],
},
],
},
),
calls: Some(
[
FunctionMetadata {
name: "add_registrar",
arguments: [
FunctionArgumentMetadata {
name: "account",
ty: "T::AccountId",
},
],
documentation: [
" Add a registrar to the system.",
"",
" The dispatch origin for this call must be `RegistrarOrigin` or `Root`.",
"",
" - `account`: the account of the registrar.",
"",
" Emits `RegistrarAdded` if successful.",
"",
" # <weight>",
" - `O(R)` where `R` registrar-count (governance-bounded).",
" - One storage mutation (codec `O(R)`).",
" - One event.",
" # </weight>",
],
},
FunctionMetadata {
name: "set_identity",
arguments: [
FunctionArgumentMetadata {
name: "info",
ty: "IdentityInfo",
},
],
documentation: [
" 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_ and the sender must have a registered",
" identity.",
"",
" - `info`: The identity information.",
"",
" Emits `IdentitySet` if successful.",
"",
" # <weight>",
" - `O(X + X\' + R)` where `X` additional-field-count (deposit-bounded and code-bounded).",
" - At most two balance operations.",
" - One storage mutation (codec-read `O(X\' + R)`, codec-write `O(X + R)`).",
" - One event.",
" # </weight>",
],
},
FunctionMetadata {
name: "set_subs",
arguments: [
FunctionArgumentMetadata {
name: "subs",
ty: "Vec<(T::AccountId, Data)>",
},
],
documentation: [
" 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 sub-accounts.",
"",
" # <weight>",
" - `O(S)` where `S` subs-count (hard- and deposit-bounded).",
" - At most two balance operations.",
" - At most O(2 * S + 1) storage mutations; codec complexity `O(1 * S + S * 1)`);",
" one storage-exists.",
" # </weight>",
],
},
FunctionMetadata {
name: "clear_identity",
arguments: [],
documentation: [
" Clear an account\'s identity info and all sub-account 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)`.",
" - One balance-reserve operation.",
" - `S + 2` storage deletions.",
" - One event.",
" # </weight>",
],
},
FunctionMetadata {
name: "request_judgement",
arguments: [
FunctionArgumentMetadata {
name: "reg_index",
ty: "Compact<RegistrarIndex>",
},
FunctionArgumentMetadata {
name: "max_fee",
ty: "Compact<BalanceOf<T>>",
},
],
documentation: [
" 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(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>",
],
},
FunctionMetadata {
name: "cancel_request",
arguments: [
FunctionArgumentMetadata {
name: "reg_index",
ty: "RegistrarIndex",
},
],
documentation: [
" 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>",
],
},
FunctionMetadata {
name: "set_fee",
arguments: [
FunctionArgumentMetadata {
name: "index",
ty: "Compact<RegistrarIndex>",
},
FunctionArgumentMetadata {
name: "fee",
ty: "Compact<BalanceOf<T>>",
},
],
documentation: [
" 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)`.",
" # </weight>",
],
},
FunctionMetadata {
name: "set_account_id",
arguments: [
FunctionArgumentMetadata {
name: "index",
ty: "Compact<RegistrarIndex>",
},
FunctionArgumentMetadata {
name: "new",
ty: "T::AccountId",
},
],
documentation: [
" 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)`.",
" # </weight>",
],
},
FunctionMetadata {
name: "set_fields",
arguments: [
FunctionArgumentMetadata {
name: "index",
ty: "Compact<RegistrarIndex>",
},
FunctionArgumentMetadata {
name: "fields",
ty: "IdentityFields",
},
],
documentation: [
" 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)`.",
" # </weight>",
],
},
FunctionMetadata {
name: "provide_judgement",
arguments: [
FunctionArgumentMetadata {
name: "reg_index",
ty: "Compact<RegistrarIndex>",
},
FunctionArgumentMetadata {
name: "target",
ty: "<T::Lookup as StaticLookup>::Source",
},
FunctionArgumentMetadata {
name: "judgement",
ty: "Judgement<BalanceOf<T>>",
},
],
documentation: [
" 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>",
],
},
FunctionMetadata {
name: "kill_identity",
arguments: [
FunctionArgumentMetadata {
name: "target",
ty: "<T::Lookup as StaticLookup>::Source",
},
],
documentation: [
" 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 be _Root_ or 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>",
],
},
],
),
event: Some(
[
EventMetadata {
name: "IdentitySet",
arguments: [
"AccountId",
],
documentation: [
" A name was set or reset (which will remove all judgements).",
],
},
EventMetadata {
name: "IdentityCleared",
arguments: [
"AccountId",
"Balance",
],
documentation: [
" A name was cleared, and the given balance returned.",
],
},
EventMetadata {
name: "IdentityKilled",
arguments: [
"AccountId",
"Balance",
],
documentation: [
" A name was removed and the given balance slashed.",
],
},
EventMetadata {
name: "JudgementRequested",
arguments: [
"AccountId",
"RegistrarIndex",
],
documentation: [
" A judgement was asked from a registrar.",
],
},
EventMetadata {
name: "JudgementUnrequested",
arguments: [
"AccountId",
"RegistrarIndex",
],
documentation: [
" A judgement request was retracted.",
],
},
EventMetadata {
name: "JudgementGiven",
arguments: [
"AccountId",
"RegistrarIndex",
],
documentation: [
" A judgement was given by a registrar.",
],
},
EventMetadata {
name: "RegistrarAdded",
arguments: [
"RegistrarIndex",
],
documentation: [
" A registrar was added.",
],
},
],
),
constants: [],
errors: [
ErrorMetadata {
name: "TooManySubAccounts",
documentation: [
" Too many subs-accounts.",
],
},
ErrorMetadata {
name: "NotFound",
documentation: [
" Account isn\'t found.",
],
},
ErrorMetadata {
name: "NotNamed",
documentation: [
" Account isn\'t named.",
],
},
ErrorMetadata {
name: "EmptyIndex",
documentation: [
" Empty index.",
],
},
ErrorMetadata {
name: "FeeChanged",
documentation: [
" Fee is changed.",
],
},
ErrorMetadata {
name: "NoIdentity",
documentation: [
" No identity found.",
],
},
ErrorMetadata {
name: "StickyJudgement",
documentation: [
" Sticky judgement.",
],
},
ErrorMetadata {
name: "JudgementGiven",
documentation: [
" Judgement given.",
],
},
ErrorMetadata {
name: "InvalidJudgement",
documentation: [
" Invalid judgement.",
],
},
ErrorMetadata {
name: "InvalidIndex",
documentation: [
" The index is invalid.",
],
},
ErrorMetadata {
name: "InvalidTarget",
documentation: [
" The target is invalid.",
],
},
ErrorMetadata {
name: "TooManyFields",
documentation: [
" Too many additional fields.",
],
},
],
},
ModuleMetadata {
name: "Society",
storage: Some(
StorageMetadata {
prefix: "Society",
entries: [
StorageEntryMetadata {
name: "Founder",
modifier: StorageEntryModifier::Optional,
ty: StorageEntryType::Plain(
"T::AccountId",
),
default: [
0,
],
documentation: [
" The first member.",
],
},
StorageEntryMetadata {
name: "Rules",
modifier: StorageEntryModifier::Optional,
ty: StorageEntryType::Plain(
"T::Hash",
),
default: [
0,
],
documentation: [
" A hash of the rules of this society concerning membership. Can only be set once and",
" only by the founder.",
],
},
StorageEntryMetadata {
name: "Candidates",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Plain(
"Vec<Bid<T::AccountId, BalanceOf<T, I>>>",
),
default: [
0,
],
documentation: [
" The current set of candidates; bidders that are attempting to become members.",
],
},
StorageEntryMetadata {
name: "SuspendedCandidates",
modifier: StorageEntryModifier::Optional,
ty: StorageEntryType::Map {
hasher: StorageHasher::Twox64Concat,
key: "T::AccountId",
value: "(BalanceOf<T, I>, BidKind<T::AccountId, BalanceOf<T, I>>)",
unused: false,
},
default: [
0,
],
documentation: [
" The set of suspended candidates.",
],
},
StorageEntryMetadata {
name: "Pot",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Plain(
"BalanceOf<T, I>",
),
default: [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
],
documentation: [
" Amount of our account balance that is specifically for the next round\'s bid(s).",
],
},
StorageEntryMetadata {
name: "Head",
modifier: StorageEntryModifier::Optional,
ty: StorageEntryType::Plain(
"T::AccountId",
),
default: [
0,
],
documentation: [
" The most primary from the most recently approved members.",
],
},
StorageEntryMetadata {
name: "Members",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Plain(
"Vec<T::AccountId>",
),
default: [
0,
],
documentation: [
" The current set of members, ordered.",
],
},
StorageEntryMetadata {
name: "SuspendedMembers",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Map {
hasher: StorageHasher::Twox64Concat,
key: "T::AccountId",
value: "bool",
unused: false,
},
default: [
0,
],
documentation: [
" The set of suspended members.",
],
},
StorageEntryMetadata {
name: "Bids",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Plain(
"Vec<Bid<T::AccountId, BalanceOf<T, I>>>",
),
default: [
0,
],
documentation: [
" The current bids, stored ordered by the value of the bid.",
],
},
StorageEntryMetadata {
name: "Vouching",
modifier: StorageEntryModifier::Optional,
ty: StorageEntryType::Map {
hasher: StorageHasher::Twox64Concat,
key: "T::AccountId",
value: "VouchingStatus",
unused: false,
},
default: [
0,
],
documentation: [
" Members currently vouching or banned from vouching again",
],
},
StorageEntryMetadata {
name: "Payouts",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Map {
hasher: StorageHasher::Twox64Concat,
key: "T::AccountId",
value: "Vec<(T::BlockNumber, BalanceOf<T, I>)>",
unused: false,
},
default: [
0,
],
documentation: [
" Pending payouts; ordered by block number, with the amount that should be paid out.",
],
},
StorageEntryMetadata {
name: "Strikes",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Map {
hasher: StorageHasher::Twox64Concat,
key: "T::AccountId",
value: "StrikeCount",
unused: false,
},
default: [
0,
0,
0,
0,
],
documentation: [
" The ongoing number of losing votes cast by the member.",
],
},
StorageEntryMetadata {
name: "Votes",
modifier: StorageEntryModifier::Optional,
ty: StorageEntryType::DoubleMap {
hasher: StorageHasher::Twox64Concat,
key1: "T::AccountId",
key2: "T::AccountId",
value: "Vote",
key2_hasher: StorageHasher::Twox64Concat,
},
default: [
0,
],
documentation: [
" Double map from Candidate -> Voter -> (Maybe) Vote.",
],
},
StorageEntryMetadata {
name: "Defender",
modifier: StorageEntryModifier::Optional,
ty: StorageEntryType::Plain(
"T::AccountId",
),
default: [
0,
],
documentation: [
" The defending member currently being challenged.",
],
},
StorageEntryMetadata {
name: "DefenderVotes",
modifier: StorageEntryModifier::Optional,
ty: StorageEntryType::Map {
hasher: StorageHasher::Twox64Concat,
key: "T::AccountId",
value: "Vote",
unused: false,
},
default: [
0,
],
documentation: [
" Votes for the defender.",
],
},
StorageEntryMetadata {
name: "MaxMembers",
modifier: StorageEntryModifier::Default,
ty: StorageEntryType::Plain(
"u32",
),
default: [
0,
0,
0,
0,
],
documentation: [
" The max number of members for the society at one time.",
],
},
],
},
),
calls: Some(
[
FunctionMetadata {
name: "bid",
arguments: [
FunctionArgumentMetadata {
name: "value",
ty: "BalanceOf<T, I>",
},
],
documentation: [
" A user outside of the society can make a bid for entry.",
"",
" Payment: `CandidateDeposit` will be reserved for making a bid. It is returned",
" when the bid becomes a member, or if the bid calls `unbid`.",
"",
" The dispatch origin for this call must be _Signed_.",
"",
" Parameters:",
" - `value`: A one time payment the bid would like to receive when joining the society.",
"",
" # <weight>",
" Key: B (len of bids), C (len of candidates), M (len of members), X (balance reserve)",
" - Storage Reads:",
" \t- One storage read to check for suspended candidate. O(1)",
" \t- One storage read to check for suspended member. O(1)",
" \t- One storage read to retrieve all current bids. O(B)",
" \t- One storage read to retrieve all current candidates. O(C)",
" \t- One storage read to retrieve all members. O(M)",
" - Storage Writes:",
" \t- One storage mutate to add a new bid to the vector O(B) (TODO: possible optimization w/ read)",
" \t- Up to one storage removal if bid.len() > MAX_BID_COUNT. O(1)",
" - Notable Computation:",
" \t- O(B + C + log M) search to check user is not already a part of society.",
" \t- O(log B) search to insert the new bid sorted.",
" - External Module Operations:",
" \t- One balance reserve operation. O(X)",
" \t- Up to one balance unreserve operation if bids.len() > MAX_BID_COUNT.",
" - Events:",
" \t- One event for new bid.",
" \t- Up to one event for AutoUnbid if bid.len() > MAX_BID_COUNT.",
"",
" Total Complexity: O(M + B + C + logM + logB + X)",
" # </weight>",
],
},
FunctionMetadata {
name: "unbid",
arguments: [
FunctionArgumentMetadata {
name: "pos",
ty: "u32",
},
],
documentation: [
" A bidder can remove their bid for entry into society.",
" By doing so, they will have their candidate deposit returned or",
" they will unvouch their voucher.",
"",
" Payment: The bid deposit is unreserved if the user made a bid.",
"",
" The dispatch origin for this call must be _Signed_ and a bidder.",
"",
" Parameters:",
" - `pos`: Position in the `Bids` vector of the bid who wants to unbid.",
"",
" # <weight>",
" Key: B (len of bids), X (balance unreserve)",
" - One storage read and write to retrieve and update the bids. O(B)",
" - Either one unreserve balance action O(X) or one vouching storage removal. O(1)",
" - One event.",
"",
" Total Complexity: O(B + X)",
" # </weight>",
],
},
FunctionMetadata {
name: "vouch",
arguments: [
FunctionArgumentMetadata {
name: "who",
ty: "T::AccountId",
},
FunctionArgumentMetadata {
name: "value",
ty: "BalanceOf<T, I>",
},
FunctionArgumentMetadata {
name: "tip",
ty: "BalanceOf<T, I>",
},
],
documentation: [
" As a member, vouch for someone to join society by placing a bid on their behalf.",
"",
" There is no deposit required to vouch for a new bid, but a member can only vouch for",
" one bid at a time. If the bid becomes a suspended candidate and ultimately rejected by",
" the suspension judgement origin, the member will be banned from vouching again.",
"",
" As a vouching member, you can claim a tip if the candidate is accepted. This tip will",
" be paid as a portion of the reward the member will receive for joining the society.",
"",
" The dispatch origin for this call must be _Signed_ and a member.",
"",
" Parameters:",
" - `who`: The user who you would like to vouch for.",
" - `value`: The total reward to be paid between you and the candidate if they become",
" a member in the society.",
" - `tip`: Your cut of the total `value` payout when the candidate is inducted into",
" the society. Tips larger than `value` will be saturated upon payout.",
"",
" # <weight>",
" Key: B (len of bids), C (len of candidates), M (len of members)",
" - Storage Reads:",
" \t- One storage read to retrieve all members. O(M)",
" \t- One storage read to check member is not already vouching. O(1)",
" \t- One storage read to check for suspended candidate. O(1)",
" \t- One storage read to check for suspended member. O(1)",
" \t- One storage read to retrieve all current bids. O(B)",
" \t- One storage read to retrieve all current candidates. O(C)",
" - Storage Writes:",
" \t- One storage write to insert vouching status to the member. O(1)",
" \t- One storage mutate to add a new bid to the vector O(B) (TODO: possible optimization w/ read)",
" \t- Up to one storage removal if bid.len() > MAX_BID_COUNT. O(1)",
" - Notable Computation:",
" \t- O(log M) search to check sender is a member.",
" \t- O(B + C + log M) search to check user is not already a part of society.",
" \t- O(log B) search to insert the new bid sorted.",
" - External Module Operations:",
" \t- One balance reserve operation. O(X)",
" \t- Up to one balance unreserve operation if bids.len() > MAX_BID_COUNT.",
" - Events:",
" \t- One event for vouch.",
" \t- Up to one event for AutoUnbid if bid.len() > MAX_BID_COUNT.",
"",
" Total Complexity: O(M + B + C + logM + logB + X)",
" # </weight>",
],
},
FunctionMetadata {
name: "unvouch",
arguments: [
FunctionArgumentMetadata {
name: "pos",
ty: "u32",
},
],
documentation: [
" As a vouching member, unvouch a bid. This only works while vouched user is",
" only a bidder (and not a candidate).",
"",
" The dispatch origin for this call must be _Signed_ and a vouching member.",
"",
" Parameters:",
" - `pos`: Position in the `Bids` vector of the bid who should be unvouched.",
"",
" # <weight>",
" Key: B (len of bids)",
" - One storage read O(1) to check the signer is a vouching member.",
" - One storage mutate to retrieve and update the bids. O(B)",
" - One vouching storage removal. O(1)",
" - One event.",
"",
" Total Complexity: O(B)",
" # </weight>",
],
},
FunctionMetadata {
name: "vote",
arguments: [
FunctionArgumentMetadata {
name: "candidate",
ty: "<T::Lookup as StaticLookup>::Source",
},
FunctionArgumentMetadata {
name: "approve",
ty: "bool",
},
],
documentation: [
" As a member, vote on a candidate.",
"",
" The dispatch origin for this call must be _Signed_ and a member.",
"",
" Parameters:",
" - `candidate`: The candidate that the member would like to bid on.",
" - `approve`: A boolean which says if the candidate should be",
" approved (`true`) or rejected (`false`).",
"",
" # <weight>",
" Key: C (len of candidates), M (len of members)",
" - One storage read O(M) and O(log M) search to check user is a member.",
" - One account lookup.",
" - One storage read O(C) and O(C) search to check that user is a candidate.",
" - One storage write to add vote to votes. O(1)",
" - One event.",
"",
" Total Complexity: O(M + logM + C)",
" # </weight>",
],
},
FunctionMetadata {
name: "defender_vote",
arguments: [
FunctionArgumentMetadata {
name: "approve",
ty: "bool",
},
],
documentation: [
" As a member, vote on the defender.",
"",
" The dispatch origin for this call must be _Signed_ and a member.",
"",
" Parameters:",
" - `approve`: A boolean which says if the candidate should be",
" approved (`true`) or rejected (`false`).",
"",
" # <weight>",
" - Key: M (len of members)",
" - One storage read O(M) and O(log M) search to check user is a member.",
" - One storage write to add vote to votes. O(1)",
" - One event.",
"",
" Total Complexity: O(M + logM)",
" # </weight>",
],
},
FunctionMetadata {
name: "payout",
arguments: [],
documentation: [
" Transfer the first matured payout for the sender and remove it from the records.",
"",
" NOTE: This extrinsic needs to be called multiple times to claim multiple matured payouts.",
"",
" Payment: The member will receive a payment equal to their first matured",
" payout to their free balance.",
"",
" The dispatch origin for this call must be _Signed_ and a member with",
" payouts remaining.",
"",
" # <weight>",
" Key: M (len of members), P (number of payouts for a particular member)",
" - One storage read O(M) and O(log M) search to check signer is a member.",
" - One storage read O(P) to get all payouts for a member.",
" - One storage read O(1) to get the current block number.",
" - One currency transfer call. O(X)",
" - One storage write or removal to update the member\'s payouts. O(P)",
"",
" Total Complexity: O(M + logM + P + X)",
" # </weight>",
],
},
FunctionMetadata {
name: "found",
arguments: [
FunctionArgumentMetadata {
name: "founder",
ty: "T::AccountId",
},
FunctionArgumentMetadata {
name: "max_members",
ty: "u32",
},
FunctionArgumentMetadata {
name: "rules",
ty: "Vec<u8>",
},
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment