{
    "magicNumber": "1635018093",
    "metadata": {
        "v11": {
            "modules": [
                {
                    "name": "System",
                    "storage": {
                        "prefix": "System",
                        "items": [
                            {
                                "name": "Account",
                                "modifier": "Default",
                                "type": {
                                    "map": {
                                        "hasher": "Blake2_128Concat",
                                        "key": "AccountId",
                                        "value": "AccountInfo",
                                        "linked": false
                                    }
                                },
                                "fallback": "0x000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
                                "docs": [
                                    " The full account information for a particular account ID."
                                ]
                            },
                            {
                                "name": "ExtrinsicCount",
                                "modifier": "Optional",
                                "type": {
                                    "plain": "u32"
                                },
                                "fallback": "0x00",
                                "docs": [
                                    " Total extrinsics count for the current block."
                                ]
                            },
                            {
                                "name": "AllExtrinsicsWeight",
                                "modifier": "Optional",
                                "type": {
                                    "plain": "Weight"
                                },
                                "fallback": "0x00",
                                "docs": [
                                    " Total weight for all extrinsics put together, for the current block."
                                ]
                            },
                            {
                                "name": "AllExtrinsicsLen",
                                "modifier": "Optional",
                                "type": {
                                    "plain": "u32"
                                },
                                "fallback": "0x00",
                                "docs": [
                                    " Total length (in bytes) for all extrinsics put together, for the current block."
                                ]
                            },
                            {
                                "name": "BlockHash",
                                "modifier": "Default",
                                "type": {
                                    "map": {
                                        "hasher": "Twox64Concat",
                                        "key": "BlockNumber",
                                        "value": "Hash",
                                        "linked": false
                                    }
                                },
                                "fallback": "0x0000000000000000000000000000000000000000000000000000000000000000",
                                "docs": [
                                    " Map of block numbers to block hashes."
                                ]
                            },
                            {
                                "name": "ExtrinsicData",
                                "modifier": "Default",
                                "type": {
                                    "map": {
                                        "hasher": "Twox64Concat",
                                        "key": "u32",
                                        "value": "Bytes",
                                        "linked": false
                                    }
                                },
                                "fallback": "0x00",
                                "docs": [
                                    " Extrinsics data for the current block (maps an extrinsic's index to its data)."
                                ]
                            },
                            {
                                "name": "Number",
                                "modifier": "Default",
                                "type": {
                                    "plain": "BlockNumber"
                                },
                                "fallback": "0x00000000",
                                "docs": [
                                    " The current block number being processed. Set by `execute_block`."
                                ]
                            },
                            {
                                "name": "ParentHash",
                                "modifier": "Default",
                                "type": {
                                    "plain": "Hash"
                                },
                                "fallback": "0x0000000000000000000000000000000000000000000000000000000000000000",
                                "docs": [
                                    " Hash of the previous block."
                                ]
                            },
                            {
                                "name": "ExtrinsicsRoot",
                                "modifier": "Default",
                                "type": {
                                    "plain": "Hash"
                                },
                                "fallback": "0x0000000000000000000000000000000000000000000000000000000000000000",
                                "docs": [
                                    " Extrinsics root of the current block, also part of the block header."
                                ]
                            },
                            {
                                "name": "Digest",
                                "modifier": "Default",
                                "type": {
                                    "plain": "DigestOf"
                                },
                                "fallback": "0x00",
                                "docs": [
                                    " Digest of the current block, also part of the block header."
                                ]
                            },
                            {
                                "name": "Events",
                                "modifier": "Default",
                                "type": {
                                    "plain": "Vec<EventRecord>"
                                },
                                "fallback": "0x00",
                                "docs": [
                                    " Events deposited for the current block."
                                ]
                            },
                            {
                                "name": "EventCount",
                                "modifier": "Default",
                                "type": {
                                    "plain": "EventIndex"
                                },
                                "fallback": "0x00000000",
                                "docs": [
                                    " The number of events in the `Events<T>` list."
                                ]
                            },
                            {
                                "name": "EventTopics",
                                "modifier": "Default",
                                "type": {
                                    "map": {
                                        "hasher": "Blake2_128Concat",
                                        "key": "Hash",
                                        "value": "Vec<(BlockNumber,EventIndex)>",
                                        "linked": false
                                    }
                                },
                                "fallback": "0x00",
                                "docs": [
                                    " 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",
                                "type": {
                                    "plain": "LastRuntimeUpgradeInfo"
                                },
                                "fallback": "0x00",
                                "docs": [
                                    " Stores the `spec_version` and `spec_name` of when the last runtime upgrade happened."
                                ]
                            },
                            {
                                "name": "ExecutionPhase",
                                "modifier": "Optional",
                                "type": {
                                    "plain": "Phase"
                                },
                                "fallback": "0x00",
                                "docs": [
                                    " The execution phase of the block."
                                ]
                            }
                        ]
                    },
                    "calls": [
                        {
                            "name": "fill_block",
                            "args": [
                                {
                                    "name": "_ratio",
                                    "type": "Perbill"
                                }
                            ],
                            "docs": [
                                " A dispatch that will fill the block weight up to the given ratio."
                            ]
                        },
                        {
                            "name": "remark",
                            "args": [
                                {
                                    "name": "_remark",
                                    "type": "Bytes"
                                }
                            ],
                            "docs": [
                                " Make some on-chain remark."
                            ]
                        },
                        {
                            "name": "set_heap_pages",
                            "args": [
                                {
                                    "name": "pages",
                                    "type": "u64"
                                }
                            ],
                            "docs": [
                                " Set the number of pages in the WebAssembly environment's heap."
                            ]
                        },
                        {
                            "name": "set_code",
                            "args": [
                                {
                                    "name": "code",
                                    "type": "Bytes"
                                }
                            ],
                            "docs": [
                                " Set the new runtime code."
                            ]
                        },
                        {
                            "name": "set_code_without_checks",
                            "args": [
                                {
                                    "name": "code",
                                    "type": "Bytes"
                                }
                            ],
                            "docs": [
                                " Set the new runtime code without doing any checks of the given `code`."
                            ]
                        },
                        {
                            "name": "set_changes_trie_config",
                            "args": [
                                {
                                    "name": "changes_trie_config",
                                    "type": "Option<ChangesTrieConfiguration>"
                                }
                            ],
                            "docs": [
                                " Set the new changes trie configuration."
                            ]
                        },
                        {
                            "name": "set_storage",
                            "args": [
                                {
                                    "name": "items",
                                    "type": "Vec<KeyValue>"
                                }
                            ],
                            "docs": [
                                " Set some items of storage."
                            ]
                        },
                        {
                            "name": "kill_storage",
                            "args": [
                                {
                                    "name": "keys",
                                    "type": "Vec<Key>"
                                }
                            ],
                            "docs": [
                                " Kill some items from storage."
                            ]
                        },
                        {
                            "name": "kill_prefix",
                            "args": [
                                {
                                    "name": "prefix",
                                    "type": "Key"
                                }
                            ],
                            "docs": [
                                " Kill all storage items with a key that starts with the given prefix."
                            ]
                        },
                        {
                            "name": "suicide",
                            "args": [],
                            "docs": [
                                " Kill the sending account, assuming there are no references outstanding and the composite",
                                " data is equal to its default value."
                            ]
                        }
                    ],
                    "events": [
                        {
                            "name": "ExtrinsicSuccess",
                            "args": [
                                "DispatchInfo"
                            ],
                            "docs": [
                                " An extrinsic completed successfully."
                            ]
                        },
                        {
                            "name": "ExtrinsicFailed",
                            "args": [
                                "DispatchError",
                                "DispatchInfo"
                            ],
                            "docs": [
                                " An extrinsic failed."
                            ]
                        },
                        {
                            "name": "CodeUpdated",
                            "args": [],
                            "docs": [
                                " `:code` was updated."
                            ]
                        },
                        {
                            "name": "NewAccount",
                            "args": [
                                "AccountId"
                            ],
                            "docs": [
                                " A new account was created."
                            ]
                        },
                        {
                            "name": "KilledAccount",
                            "args": [
                                "AccountId"
                            ],
                            "docs": [
                                " An account was reaped."
                            ]
                        }
                    ],
                    "constants": [],
                    "errors": [
                        {
                            "name": "InvalidSpecName",
                            "docs": [
                                " The name of specification does not match between the current runtime",
                                " and the new runtime."
                            ]
                        },
                        {
                            "name": "SpecVersionNeedsToIncrease",
                            "docs": [
                                " The specification version is not allowed to decrease between the current runtime",
                                " and the new runtime."
                            ]
                        },
                        {
                            "name": "FailedToExtractRuntimeVersion",
                            "docs": [
                                " Failed to extract the runtime version from the new runtime.",
                                "",
                                " Either calling `Core_version` or decoding `RuntimeVersion` failed."
                            ]
                        },
                        {
                            "name": "NonDefaultComposite",
                            "docs": [
                                " Suicide called when the account has non-default composite data."
                            ]
                        },
                        {
                            "name": "NonZeroRefCount",
                            "docs": [
                                " There is a non-zero reference count preventing the account from being purged."
                            ]
                        }
                    ]
                },
                {
                    "name": "RandomnessCollectiveFlip",
                    "storage": {
                        "prefix": "RandomnessCollectiveFlip",
                        "items": [
                            {
                                "name": "RandomMaterial",
                                "modifier": "Default",
                                "type": {
                                    "plain": "Vec<Hash>"
                                },
                                "fallback": "0x00",
                                "docs": [
                                    " 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,
                    "events": null,
                    "constants": [],
                    "errors": []
                },
                {
                    "name": "Babe",
                    "storage": {
                        "prefix": "Babe",
                        "items": [
                            {
                                "name": "EpochIndex",
                                "modifier": "Default",
                                "type": {
                                    "plain": "u64"
                                },
                                "fallback": "0x0000000000000000",
                                "docs": [
                                    " Current epoch index."
                                ]
                            },
                            {
                                "name": "Authorities",
                                "modifier": "Default",
                                "type": {
                                    "plain": "Vec<(AuthorityId,BabeAuthorityWeight)>"
                                },
                                "fallback": "0x00",
                                "docs": [
                                    " Current epoch authorities."
                                ]
                            },
                            {
                                "name": "GenesisSlot",
                                "modifier": "Default",
                                "type": {
                                    "plain": "u64"
                                },
                                "fallback": "0x0000000000000000",
                                "docs": [
                                    " The slot at which the first epoch actually started. This is 0",
                                    " until the first block of the chain."
                                ]
                            },
                            {
                                "name": "CurrentSlot",
                                "modifier": "Default",
                                "type": {
                                    "plain": "u64"
                                },
                                "fallback": "0x0000000000000000",
                                "docs": [
                                    " Current slot number."
                                ]
                            },
                            {
                                "name": "Randomness",
                                "modifier": "Default",
                                "type": {
                                    "plain": "Randomness"
                                },
                                "fallback": "0x0000000000000000000000000000000000000000000000000000000000000000",
                                "docs": [
                                    " 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",
                                "type": {
                                    "plain": "Randomness"
                                },
                                "fallback": "0x0000000000000000000000000000000000000000000000000000000000000000",
                                "docs": [
                                    " Next epoch randomness."
                                ]
                            },
                            {
                                "name": "SegmentIndex",
                                "modifier": "Default",
                                "type": {
                                    "plain": "u32"
                                },
                                "fallback": "0x00000000",
                                "docs": [
                                    " 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",
                                "type": {
                                    "map": {
                                        "hasher": "Twox64Concat",
                                        "key": "u32",
                                        "value": "Vec<RawVRFOutput>",
                                        "linked": false
                                    }
                                },
                                "fallback": "0x00",
                                "docs": []
                            },
                            {
                                "name": "Initialized",
                                "modifier": "Optional",
                                "type": {
                                    "plain": "MaybeVrf"
                                },
                                "fallback": "0x00",
                                "docs": [
                                    " Temporary value (cleared at block finalization) which is `Some`",
                                    " if per-block initialization has already been called for current block."
                                ]
                            },
                            {
                                "name": "Lateness",
                                "modifier": "Default",
                                "type": {
                                    "plain": "BlockNumber"
                                },
                                "fallback": "0x00000000",
                                "docs": [
                                    " How late the current block is compared to its parent.",
                                    "",
                                    " This entry is populated as part of block execution and is cleaned up",
                                    " on block finalization. Querying this storage entry outside of block",
                                    " execution context should always yield zero."
                                ]
                            }
                        ]
                    },
                    "calls": [],
                    "events": null,
                    "constants": [
                        {
                            "name": "EpochDuration",
                            "type": "u64",
                            "value": "0x5802000000000000",
                            "docs": [
                                " 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",
                            "type": "Moment",
                            "value": "0x7017000000000000",
                            "docs": [
                                " 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",
                        "items": [
                            {
                                "name": "Now",
                                "modifier": "Default",
                                "type": {
                                    "plain": "Moment"
                                },
                                "fallback": "0x0000000000000000",
                                "docs": [
                                    " Current time for the current block."
                                ]
                            },
                            {
                                "name": "DidUpdate",
                                "modifier": "Default",
                                "type": {
                                    "plain": "bool"
                                },
                                "fallback": "0x00",
                                "docs": [
                                    " Did the timestamp get updated in this block?"
                                ]
                            }
                        ]
                    },
                    "calls": [
                        {
                            "name": "set",
                            "args": [
                                {
                                    "name": "now",
                                    "type": "Compact<Moment>"
                                }
                            ],
                            "docs": [
                                " Set the current time.",
                                "",
                                " This call should be invoked exactly once per block. It will panic at the finalization",
                                " phase, if this call hasn't been invoked by that time.",
                                "",
                                " The timestamp should be greater than the previous one by the amount specified by",
                                " `MinimumPeriod`.",
                                "",
                                " The dispatch origin for this call must be `Inherent`."
                            ]
                        }
                    ],
                    "events": null,
                    "constants": [
                        {
                            "name": "MinimumPeriod",
                            "type": "Moment",
                            "value": "0xb80b000000000000",
                            "docs": [
                                " 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",
                        "items": [
                            {
                                "name": "Accounts",
                                "modifier": "Optional",
                                "type": {
                                    "map": {
                                        "hasher": "Blake2_128Concat",
                                        "key": "AccountIndex",
                                        "value": "(AccountId,BalanceOf)",
                                        "linked": false
                                    }
                                },
                                "fallback": "0x00",
                                "docs": [
                                    " The lookup from index to account."
                                ]
                            }
                        ]
                    },
                    "calls": [
                        {
                            "name": "claim",
                            "args": [
                                {
                                    "name": "index",
                                    "type": "AccountIndex"
                                }
                            ],
                            "docs": [
                                " Assign an previously unassigned index.",
                                "",
                                " Payment: `Deposit` is reserved from the sender account.",
                                "",
                                " The dispatch origin for this call must be _Signed_.",
                                "",
                                " - `index`: the index to be claimed. This must not be in use.",
                                "",
                                " Emits `IndexAssigned` if successful.",
                                "",
                                " # <weight>",
                                " - `O(1)`.",
                                " - One storage mutation (codec `O(1)`).",
                                " - One reserve operation.",
                                " - One event.",
                                " # </weight>"
                            ]
                        },
                        {
                            "name": "transfer",
                            "args": [
                                {
                                    "name": "new",
                                    "type": "AccountId"
                                },
                                {
                                    "name": "index",
                                    "type": "AccountIndex"
                                }
                            ],
                            "docs": [
                                " Assign an index already owned by the sender to another account. The balance reservation",
                                " is effectively transferred to the new account.",
                                "",
                                " The dispatch origin for this call must be _Signed_.",
                                "",
                                " - `index`: the index to be re-assigned. This must be owned by the sender.",
                                " - `new`: the new owner of the index. This function is a no-op if it is equal to sender.",
                                "",
                                " Emits `IndexAssigned` if successful.",
                                "",
                                " # <weight>",
                                " - `O(1)`.",
                                " - One storage mutation (codec `O(1)`).",
                                " - One transfer operation.",
                                " - One event.",
                                " # </weight>"
                            ]
                        },
                        {
                            "name": "free",
                            "args": [
                                {
                                    "name": "index",
                                    "type": "AccountIndex"
                                }
                            ],
                            "docs": [
                                " Free up an index owned by the sender.",
                                "",
                                " Payment: Any previous deposit placed for the index is unreserved in the sender account.",
                                "",
                                " The dispatch origin for this call must be _Signed_ and the sender must own the index.",
                                "",
                                " - `index`: the index to be freed. This must be owned by the sender.",
                                "",
                                " Emits `IndexFreed` if successful.",
                                "",
                                " # <weight>",
                                " - `O(1)`.",
                                " - One storage mutation (codec `O(1)`).",
                                " - One reserve operation.",
                                " - One event.",
                                " # </weight>"
                            ]
                        },
                        {
                            "name": "force_transfer",
                            "args": [
                                {
                                    "name": "new",
                                    "type": "AccountId"
                                },
                                {
                                    "name": "index",
                                    "type": "AccountIndex"
                                }
                            ],
                            "docs": [
                                " Force an index to an account. This doesn't require a deposit. If the index is already",
                                " held, then any deposit is reimbursed to its current owner.",
                                "",
                                " The dispatch origin for this call must be _Root_.",
                                "",
                                " - `index`: the index to be (re-)assigned.",
                                " - `new`: the new owner of the index. This function is a no-op if it is equal to sender.",
                                "",
                                " Emits `IndexAssigned` if successful.",
                                "",
                                " # <weight>",
                                " - `O(1)`.",
                                " - One storage mutation (codec `O(1)`).",
                                " - Up to one reserve operation.",
                                " - One event.",
                                " # </weight>"
                            ]
                        }
                    ],
                    "events": [
                        {
                            "name": "IndexAssigned",
                            "args": [
                                "AccountId",
                                "AccountIndex"
                            ],
                            "docs": [
                                " A account index was assigned."
                            ]
                        },
                        {
                            "name": "IndexFreed",
                            "args": [
                                "AccountIndex"
                            ],
                            "docs": [
                                " A account index has been freed up (unassigned)."
                            ]
                        }
                    ],
                    "constants": [],
                    "errors": []
                },
                {
                    "name": "Balances",
                    "storage": {
                        "prefix": "Balances",
                        "items": [
                            {
                                "name": "TotalIssuance",
                                "modifier": "Default",
                                "type": {
                                    "plain": "Balance"
                                },
                                "fallback": "0x00000000000000000000000000000000",
                                "docs": [
                                    " The total units issued in the system."
                                ]
                            },
                            {
                                "name": "Account",
                                "modifier": "Default",
                                "type": {
                                    "map": {
                                        "hasher": "Blake2_128Concat",
                                        "key": "AccountId",
                                        "value": "AccountData",
                                        "linked": false
                                    }
                                },
                                "fallback": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
                                "docs": [
                                    " 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",
                                "type": {
                                    "map": {
                                        "hasher": "Blake2_128Concat",
                                        "key": "AccountId",
                                        "value": "Vec<BalanceLock>",
                                        "linked": false
                                    }
                                },
                                "fallback": "0x00",
                                "docs": [
                                    " Any liquidity locks on some account balances.",
                                    " NOTE: Should only be accessed when setting, changing and freeing a lock."
                                ]
                            },
                            {
                                "name": "StorageVersion",
                                "modifier": "Default",
                                "type": {
                                    "plain": "Releases"
                                },
                                "fallback": "0x00",
                                "docs": [
                                    " Storage version of the pallet.",
                                    "",
                                    " This is set to v2.0.0 for new networks."
                                ]
                            }
                        ]
                    },
                    "calls": [
                        {
                            "name": "transfer",
                            "args": [
                                {
                                    "name": "dest",
                                    "type": "LookupSource"
                                },
                                {
                                    "name": "value",
                                    "type": "Compact<Balance>"
                                }
                            ],
                            "docs": [
                                " Transfer some liquid free balance to another account.",
                                "",
                                " `transfer` will set the `FreeBalance` of the sender and receiver.",
                                " It will decrease the total issuance of the system by the `TransferFee`.",
                                " If the sender's account is below the existential deposit as a result",
                                " of the transfer, the account will be reaped.",
                                "",
                                " The dispatch origin for this call must be `Signed` by the transactor.",
                                "",
                                " # <weight>",
                                " - Dependent on arguments but not critical, given proper implementations for",
                                "   input config types. See related functions below.",
                                " - It contains a limited number of reads and writes internally and no complex computation.",
                                "",
                                " Related functions:",
                                "",
                                "   - `ensure_can_withdraw` is always called internally but has a bounded complexity.",
                                "   - Transferring balances to accounts that did not exist before will cause",
                                "      `T::OnNewAccount::on_new_account` to be called.",
                                "   - Removing enough funds from an account will trigger `T::DustRemoval::on_unbalanced`.",
                                "   - `transfer_keep_alive` works the same way as `transfer`, but has an additional",
                                "     check that the transfer will not kill the origin account.",
                                "",
                                " # </weight>"
                            ]
                        },
                        {
                            "name": "set_balance",
                            "args": [
                                {
                                    "name": "who",
                                    "type": "LookupSource"
                                },
                                {
                                    "name": "new_free",
                                    "type": "Compact<Balance>"
                                },
                                {
                                    "name": "new_reserved",
                                    "type": "Compact<Balance>"
                                }
                            ],
                            "docs": [
                                " Set the balances of a given account.",
                                "",
                                " This will alter `FreeBalance` and `ReservedBalance` in storage. it will",
                                " also decrease the total issuance of the system (`TotalIssuance`).",
                                " If the new free or reserved balance is below the existential deposit,",
                                " it will reset the account nonce (`frame_system::AccountNonce`).",
                                "",
                                " The dispatch origin for this call is `root`.",
                                "",
                                " # <weight>",
                                " - Independent of the arguments.",
                                " - Contains a limited number of reads and writes.",
                                " # </weight>"
                            ]
                        },
                        {
                            "name": "force_transfer",
                            "args": [
                                {
                                    "name": "source",
                                    "type": "LookupSource"
                                },
                                {
                                    "name": "dest",
                                    "type": "LookupSource"
                                },
                                {
                                    "name": "value",
                                    "type": "Compact<Balance>"
                                }
                            ],
                            "docs": [
                                " Exactly as `transfer`, except the origin must be root and the source account may be",
                                " specified."
                            ]
                        },
                        {
                            "name": "transfer_keep_alive",
                            "args": [
                                {
                                    "name": "dest",
                                    "type": "LookupSource"
                                },
                                {
                                    "name": "value",
                                    "type": "Compact<Balance>"
                                }
                            ],
                            "docs": [
                                " Same as the [`transfer`] call, but with a check that the transfer will not kill the",
                                " origin account.",
                                "",
                                " 99% of the time you want [`transfer`] instead.",
                                "",
                                " [`transfer`]: struct.Module.html#method.transfer"
                            ]
                        }
                    ],
                    "events": [
                        {
                            "name": "Endowed",
                            "args": [
                                "AccountId",
                                "Balance"
                            ],
                            "docs": [
                                " An account was created with some free balance."
                            ]
                        },
                        {
                            "name": "DustLost",
                            "args": [
                                "AccountId",
                                "Balance"
                            ],
                            "docs": [
                                " An account was removed whose balance was non-zero but below ExistentialDeposit,",
                                " resulting in an outright loss."
                            ]
                        },
                        {
                            "name": "Transfer",
                            "args": [
                                "AccountId",
                                "AccountId",
                                "Balance"
                            ],
                            "docs": [
                                " Transfer succeeded (from, to, value)."
                            ]
                        },
                        {
                            "name": "BalanceSet",
                            "args": [
                                "AccountId",
                                "Balance",
                                "Balance"
                            ],
                            "docs": [
                                " A balance was set by root (who, free, reserved)."
                            ]
                        },
                        {
                            "name": "Deposit",
                            "args": [
                                "AccountId",
                                "Balance"
                            ],
                            "docs": [
                                " Some amount was deposited (e.g. for transaction fees)."
                            ]
                        }
                    ],
                    "constants": [
                        {
                            "name": "ExistentialDeposit",
                            "type": "Balance",
                            "value": "0x00e40b54020000000000000000000000",
                            "docs": [
                                " The minimum amount required to keep an account open."
                            ]
                        }
                    ],
                    "errors": [
                        {
                            "name": "VestingBalance",
                            "docs": [
                                " Vesting balance too high to send value"
                            ]
                        },
                        {
                            "name": "LiquidityRestrictions",
                            "docs": [
                                " Account liquidity restrictions prevent withdrawal"
                            ]
                        },
                        {
                            "name": "Overflow",
                            "docs": [
                                " Got an overflow after adding"
                            ]
                        },
                        {
                            "name": "InsufficientBalance",
                            "docs": [
                                " Balance too low to send value"
                            ]
                        },
                        {
                            "name": "ExistentialDeposit",
                            "docs": [
                                " Value too low to create account due to existential deposit"
                            ]
                        },
                        {
                            "name": "KeepAlive",
                            "docs": [
                                " Transfer/payment would kill account"
                            ]
                        },
                        {
                            "name": "ExistingVestingSchedule",
                            "docs": [
                                " A vesting schedule already exists for this account"
                            ]
                        },
                        {
                            "name": "DeadAccount",
                            "docs": [
                                " Beneficiary account must pre-exist"
                            ]
                        }
                    ]
                },
                {
                    "name": "TransactionPayment",
                    "storage": {
                        "prefix": "TransactionPayment",
                        "items": [
                            {
                                "name": "NextFeeMultiplier",
                                "modifier": "Default",
                                "type": {
                                    "plain": "Multiplier"
                                },
                                "fallback": "0x0000000000000000",
                                "docs": []
                            }
                        ]
                    },
                    "calls": null,
                    "events": null,
                    "constants": [
                        {
                            "name": "TransactionBaseFee",
                            "type": "BalanceOf",
                            "value": "0x00e40b54020000000000000000000000",
                            "docs": [
                                " The fee to be paid for making a transaction; the base."
                            ]
                        },
                        {
                            "name": "TransactionByteFee",
                            "type": "BalanceOf",
                            "value": "0x00e1f505000000000000000000000000",
                            "docs": [
                                " The fee to be paid for making a transaction; the per-byte portion."
                            ]
                        }
                    ],
                    "errors": []
                },
                {
                    "name": "Authorship",
                    "storage": {
                        "prefix": "Authorship",
                        "items": [
                            {
                                "name": "Uncles",
                                "modifier": "Default",
                                "type": {
                                    "plain": "Vec<UncleEntryItem>"
                                },
                                "fallback": "0x00",
                                "docs": [
                                    " Uncles"
                                ]
                            },
                            {
                                "name": "Author",
                                "modifier": "Optional",
                                "type": {
                                    "plain": "AccountId"
                                },
                                "fallback": "0x00",
                                "docs": [
                                    " Author of current block."
                                ]
                            },
                            {
                                "name": "DidSetUncles",
                                "modifier": "Default",
                                "type": {
                                    "plain": "bool"
                                },
                                "fallback": "0x00",
                                "docs": [
                                    " Whether uncles were already set in this block."
                                ]
                            }
                        ]
                    },
                    "calls": [
                        {
                            "name": "set_uncles",
                            "args": [
                                {
                                    "name": "new_uncles",
                                    "type": "Vec<Header>"
                                }
                            ],
                            "docs": [
                                " Provide a set of uncles."
                            ]
                        }
                    ],
                    "events": null,
                    "constants": [],
                    "errors": [
                        {
                            "name": "InvalidUncleParent",
                            "docs": [
                                " The uncle parent not in the chain."
                            ]
                        },
                        {
                            "name": "UnclesAlreadySet",
                            "docs": [
                                " Uncles already set in the block."
                            ]
                        },
                        {
                            "name": "TooManyUncles",
                            "docs": [
                                " Too many uncles."
                            ]
                        },
                        {
                            "name": "GenesisUncle",
                            "docs": [
                                " The uncle is genesis."
                            ]
                        },
                        {
                            "name": "TooHighUncle",
                            "docs": [
                                " The uncle is too high in chain."
                            ]
                        },
                        {
                            "name": "UncleAlreadyIncluded",
                            "docs": [
                                " The uncle is already included."
                            ]
                        },
                        {
                            "name": "OldUncle",
                            "docs": [
                                " The uncle isn't recent enough to be included."
                            ]
                        }
                    ]
                },
                {
                    "name": "Staking",
                    "storage": {
                        "prefix": "Staking",
                        "items": [
                            {
                                "name": "HistoryDepth",
                                "modifier": "Default",
                                "type": {
                                    "plain": "u32"
                                },
                                "fallback": "0x54000000",
                                "docs": [
                                    " Number of eras to keep in history.",
                                    "",
                                    " Information is kept for eras in `[current_era - history_depth; current_era]`.",
                                    "",
                                    " Must be more than the number of eras delayed by session otherwise.",
                                    " I.e. active era must always be in history.",
                                    " I.e. `active_era > current_era - history_depth` must be guaranteed."
                                ]
                            },
                            {
                                "name": "ValidatorCount",
                                "modifier": "Default",
                                "type": {
                                    "plain": "u32"
                                },
                                "fallback": "0x00000000",
                                "docs": [
                                    " The ideal number of staking participants."
                                ]
                            },
                            {
                                "name": "MinimumValidatorCount",
                                "modifier": "Default",
                                "type": {
                                    "plain": "u32"
                                },
                                "fallback": "0x04000000",
                                "docs": [
                                    " Minimum number of staking participants before emergency conditions are imposed."
                                ]
                            },
                            {
                                "name": "Invulnerables",
                                "modifier": "Default",
                                "type": {
                                    "plain": "Vec<AccountId>"
                                },
                                "fallback": "0x00",
                                "docs": [
                                    " 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",
                                "type": {
                                    "map": {
                                        "hasher": "Twox64Concat",
                                        "key": "AccountId",
                                        "value": "AccountId",
                                        "linked": false
                                    }
                                },
                                "fallback": "0x00",
                                "docs": [
                                    " Map from all locked \"stash\" accounts to the controller account."
                                ]
                            },
                            {
                                "name": "Ledger",
                                "modifier": "Optional",
                                "type": {
                                    "map": {
                                        "hasher": "Blake2_128Concat",
                                        "key": "AccountId",
                                        "value": "StakingLedger",
                                        "linked": false
                                    }
                                },
                                "fallback": "0x00",
                                "docs": [
                                    " Map from all (unlocked) \"controller\" accounts to the info regarding the staking."
                                ]
                            },
                            {
                                "name": "Payee",
                                "modifier": "Default",
                                "type": {
                                    "map": {
                                        "hasher": "Twox64Concat",
                                        "key": "AccountId",
                                        "value": "RewardDestination",
                                        "linked": false
                                    }
                                },
                                "fallback": "0x00",
                                "docs": [
                                    " Where the reward payment should be made. Keyed by stash."
                                ]
                            },
                            {
                                "name": "Validators",
                                "modifier": "Default",
                                "type": {
                                    "map": {
                                        "hasher": "Twox64Concat",
                                        "key": "AccountId",
                                        "value": "ValidatorPrefs",
                                        "linked": false
                                    }
                                },
                                "fallback": "0x00",
                                "docs": [
                                    " The map from (wannabe) validator stash key to the preferences of that validator."
                                ]
                            },
                            {
                                "name": "Nominators",
                                "modifier": "Optional",
                                "type": {
                                    "map": {
                                        "hasher": "Twox64Concat",
                                        "key": "AccountId",
                                        "value": "Nominations",
                                        "linked": false
                                    }
                                },
                                "fallback": "0x00",
                                "docs": [
                                    " The map from nominator stash key to the set of stash keys of all validators to nominate."
                                ]
                            },
                            {
                                "name": "CurrentEra",
                                "modifier": "Optional",
                                "type": {
                                    "plain": "EraIndex"
                                },
                                "fallback": "0x00",
                                "docs": [
                                    " The current era index.",
                                    "",
                                    " This is the latest planned era, depending on how the Session pallet queues the validator",
                                    " set, it might be active or not."
                                ]
                            },
                            {
                                "name": "ActiveEra",
                                "modifier": "Optional",
                                "type": {
                                    "plain": "ActiveEraInfo"
                                },
                                "fallback": "0x00",
                                "docs": [
                                    " 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",
                                "type": {
                                    "map": {
                                        "hasher": "Twox64Concat",
                                        "key": "EraIndex",
                                        "value": "SessionIndex",
                                        "linked": false
                                    }
                                },
                                "fallback": "0x00",
                                "docs": [
                                    " The session index at which the era start for the last `HISTORY_DEPTH` eras."
                                ]
                            },
                            {
                                "name": "ErasStakers",
                                "modifier": "Default",
                                "type": {
                                    "doubleMap": {
                                        "hasher": "Twox64Concat",
                                        "key1": "EraIndex",
                                        "key2": "AccountId",
                                        "value": "Exposure",
                                        "key2Hasher": "Twox64Concat"
                                    }
                                },
                                "fallback": "0x000000",
                                "docs": [
                                    " 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",
                                "type": {
                                    "doubleMap": {
                                        "hasher": "Twox64Concat",
                                        "key1": "EraIndex",
                                        "key2": "AccountId",
                                        "value": "Exposure",
                                        "key2Hasher": "Twox64Concat"
                                    }
                                },
                                "fallback": "0x000000",
                                "docs": [
                                    " Clipped Exposure of validator at era.",
                                    "",
                                    " This is similar to [`ErasStakers`] but number of nominators exposed is reduced to the",
                                    " `T::MaxNominatorRewardedPerValidator` biggest stakers.",
                                    " (Note: the field `total` and `own` of the exposure remains unchanged).",
                                    " This is used to limit the i/o cost for the nominator payout.",
                                    "",
                                    " This is keyed fist by the era index to allow bulk deletion and then the stash account.",
                                    "",
                                    " Is it removed after `HISTORY_DEPTH` eras.",
                                    " If stakers hasn't been set or has been removed then empty exposure is returned."
                                ]
                            },
                            {
                                "name": "ErasValidatorPrefs",
                                "modifier": "Default",
                                "type": {
                                    "doubleMap": {
                                        "hasher": "Twox64Concat",
                                        "key1": "EraIndex",
                                        "key2": "AccountId",
                                        "value": "ValidatorPrefs",
                                        "key2Hasher": "Twox64Concat"
                                    }
                                },
                                "fallback": "0x00",
                                "docs": [
                                    " Similar to `ErasStakers`, this holds the preferences of validators.",
                                    "",
                                    " This is keyed first by the era index to allow bulk deletion and then the stash account.",
                                    "",
                                    " Is it removed after `HISTORY_DEPTH` eras."
                                ]
                            },
                            {
                                "name": "ErasValidatorReward",
                                "modifier": "Optional",
                                "type": {
                                    "map": {
                                        "hasher": "Twox64Concat",
                                        "key": "EraIndex",
                                        "value": "BalanceOf",
                                        "linked": false
                                    }
                                },
                                "fallback": "0x00",
                                "docs": [
                                    " 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",
                                "type": {
                                    "map": {
                                        "hasher": "Twox64Concat",
                                        "key": "EraIndex",
                                        "value": "EraRewardPoints",
                                        "linked": false
                                    }
                                },
                                "fallback": "0x0000000000",
                                "docs": [
                                    " 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",
                                "type": {
                                    "map": {
                                        "hasher": "Twox64Concat",
                                        "key": "EraIndex",
                                        "value": "BalanceOf",
                                        "linked": false
                                    }
                                },
                                "fallback": "0x00000000000000000000000000000000",
                                "docs": [
                                    " 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",
                                "type": {
                                    "plain": "Forcing"
                                },
                                "fallback": "0x00",
                                "docs": [
                                    " Mode of era forcing."
                                ]
                            },
                            {
                                "name": "SlashRewardFraction",
                                "modifier": "Default",
                                "type": {
                                    "plain": "Perbill"
                                },
                                "fallback": "0x00000000",
                                "docs": [
                                    " 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",
                                "type": {
                                    "plain": "BalanceOf"
                                },
                                "fallback": "0x00000000000000000000000000000000",
                                "docs": [
                                    " The amount of currency given to reporters of a slash event which was",
                                    " canceled by extraordinary circumstances (e.g. governance)."
                                ]
                            },
                            {
                                "name": "UnappliedSlashes",
                                "modifier": "Default",
                                "type": {
                                    "map": {
                                        "hasher": "Twox64Concat",
                                        "key": "EraIndex",
                                        "value": "Vec<UnappliedSlash>",
                                        "linked": false
                                    }
                                },
                                "fallback": "0x00",
                                "docs": [
                                    " All unapplied slashes that are queued for later."
                                ]
                            },
                            {
                                "name": "BondedEras",
                                "modifier": "Default",
                                "type": {
                                    "plain": "Vec<(EraIndex,SessionIndex)>"
                                },
                                "fallback": "0x00",
                                "docs": [
                                    " 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",
                                "type": {
                                    "doubleMap": {
                                        "hasher": "Twox64Concat",
                                        "key1": "EraIndex",
                                        "key2": "AccountId",
                                        "value": "(Perbill,BalanceOf)",
                                        "key2Hasher": "Twox64Concat"
                                    }
                                },
                                "fallback": "0x00",
                                "docs": [
                                    " All slashing events on validators, mapped by era to the highest slash proportion",
                                    " and slash value of the era."
                                ]
                            },
                            {
                                "name": "NominatorSlashInEra",
                                "modifier": "Optional",
                                "type": {
                                    "doubleMap": {
                                        "hasher": "Twox64Concat",
                                        "key1": "EraIndex",
                                        "key2": "AccountId",
                                        "value": "BalanceOf",
                                        "key2Hasher": "Twox64Concat"
                                    }
                                },
                                "fallback": "0x00",
                                "docs": [
                                    " All slashing events on nominators, mapped by era to the highest slash value of the era."
                                ]
                            },
                            {
                                "name": "SlashingSpans",
                                "modifier": "Optional",
                                "type": {
                                    "map": {
                                        "hasher": "Twox64Concat",
                                        "key": "AccountId",
                                        "value": "SlashingSpans",
                                        "linked": false
                                    }
                                },
                                "fallback": "0x00",
                                "docs": [
                                    " Slashing spans for stash accounts."
                                ]
                            },
                            {
                                "name": "SpanSlash",
                                "modifier": "Default",
                                "type": {
                                    "map": {
                                        "hasher": "Twox64Concat",
                                        "key": "(AccountId,SpanIndex)",
                                        "value": "SpanRecord",
                                        "linked": false
                                    }
                                },
                                "fallback": "0x0000000000000000000000000000000000000000000000000000000000000000",
                                "docs": [
                                    " 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",
                                "type": {
                                    "plain": "EraIndex"
                                },
                                "fallback": "0x00",
                                "docs": [
                                    " The earliest era for which we have a pending, unapplied slash."
                                ]
                            },
                            {
                                "name": "SnapshotValidators",
                                "modifier": "Optional",
                                "type": {
                                    "plain": "Vec<AccountId>"
                                },
                                "fallback": "0x00",
                                "docs": [
                                    " Snapshot of validators at the beginning of the current election window. This should only",
                                    " have a value when [`EraElectionStatus`] == `ElectionStatus::Open(_)`."
                                ]
                            },
                            {
                                "name": "SnapshotNominators",
                                "modifier": "Optional",
                                "type": {
                                    "plain": "Vec<AccountId>"
                                },
                                "fallback": "0x00",
                                "docs": [
                                    " Snapshot of nominators at the beginning of the current election window. This should only",
                                    " have a value when [`EraElectionStatus`] == `ElectionStatus::Open(_)`."
                                ]
                            },
                            {
                                "name": "QueuedElected",
                                "modifier": "Optional",
                                "type": {
                                    "plain": "ElectionResult"
                                },
                                "fallback": "0x00",
                                "docs": [
                                    " The next validator set. At the end of an era, if this is available (potentially from the",
                                    " result of an offchain worker), it is immediately used. Otherwise, the on-chain election",
                                    " is executed."
                                ]
                            },
                            {
                                "name": "QueuedScore",
                                "modifier": "Optional",
                                "type": {
                                    "plain": "PhragmenScore"
                                },
                                "fallback": "0x00",
                                "docs": [
                                    " The score of the current [`QueuedElected`]."
                                ]
                            },
                            {
                                "name": "EraElectionStatus",
                                "modifier": "Default",
                                "type": {
                                    "plain": "ElectionStatus"
                                },
                                "fallback": "0x00",
                                "docs": [
                                    " Flag to control the execution of the offchain election. When `Open(_)`, we accept",
                                    " solutions to be submitted."
                                ]
                            },
                            {
                                "name": "IsCurrentSessionFinal",
                                "modifier": "Default",
                                "type": {
                                    "plain": "bool"
                                },
                                "fallback": "0x00",
                                "docs": [
                                    " True if the current planned session is final."
                                ]
                            },
                            {
                                "name": "StorageVersion",
                                "modifier": "Default",
                                "type": {
                                    "plain": "Releases"
                                },
                                "fallback": "0x02",
                                "docs": [
                                    " True if network has been upgraded to this version.",
                                    " Storage version of the pallet.",
                                    "",
                                    " This is set to v3.0.0 for new networks."
                                ]
                            },
                            {
                                "name": "MigrateEra",
                                "modifier": "Optional",
                                "type": {
                                    "plain": "EraIndex"
                                },
                                "fallback": "0x00",
                                "docs": [
                                    " The era where we migrated from Lazy Payouts to Simple Payouts"
                                ]
                            }
                        ]
                    },
                    "calls": [
                        {
                            "name": "bond",
                            "args": [
                                {
                                    "name": "controller",
                                    "type": "LookupSource"
                                },
                                {
                                    "name": "value",
                                    "type": "Compact<BalanceOf>"
                                },
                                {
                                    "name": "payee",
                                    "type": "RewardDestination"
                                }
                            ],
                            "docs": [
                                " Take the origin account as a stash and lock up `value` of its balance. `controller` will",
                                " be the account that controls it.",
                                "",
                                " `value` must be more than the `minimum_balance` specified by `T::Currency`.",
                                "",
                                " The dispatch origin for this call must be _Signed_ by the stash account.",
                                "",
                                " Emits `Bonded`.",
                                "",
                                " # <weight>",
                                " - Independent of the arguments. Moderate complexity.",
                                " - O(1).",
                                " - Three extra DB entries.",
                                "",
                                " NOTE: Two of the storage writes (`Self::bonded`, `Self::payee`) are _never_ cleaned",
                                " unless the `origin` falls below _existential deposit_ and gets removed as dust.",
                                " # </weight>"
                            ]
                        },
                        {
                            "name": "bond_extra",
                            "args": [
                                {
                                    "name": "max_additional",
                                    "type": "Compact<BalanceOf>"
                                }
                            ],
                            "docs": [
                                " 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",
                            "args": [
                                {
                                    "name": "value",
                                    "type": "Compact<BalanceOf>"
                                }
                            ],
                            "docs": [
                                " Schedule a portion of the stash to be unlocked ready for transfer out after the bond",
                                " period ends. If this leaves an amount actively bonded less than",
                                " T::Currency::minimum_balance(), then it is increased to the full amount.",
                                "",
                                " 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",
                            "args": [],
                            "docs": [
                                " Remove any unlocked chunks from the `unlocking` queue from our management.",
                                "",
                                " This essentially frees up that balance to be used by the stash account to do",
                                " whatever it wants.",
                                "",
                                " The dispatch origin for this call must be _Signed_ by the controller, 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",
                            "args": [
                                {
                                    "name": "prefs",
                                    "type": "ValidatorPrefs"
                                }
                            ],
                            "docs": [
                                " Declare the desire to validate for the origin controller.",
                                "",
                                " Effects will be felt at the beginning of the next era.",
                                "",
                                " The dispatch origin for this call must be _Signed_ by the controller, not the stash.",
                                "",
                                " # <weight>",
                                " - Independent of the arguments. Insignificant complexity.",
                                " - Contains a limited number of reads.",
                                " - Writes are limited to the `origin` account key.",
                                " # </weight>"
                            ]
                        },
                        {
                            "name": "nominate",
                            "args": [
                                {
                                    "name": "targets",
                                    "type": "Vec<LookupSource>"
                                }
                            ],
                            "docs": [
                                " Declare the desire to nominate `targets` for the origin controller.",
                                "",
                                " Effects will be felt at the beginning of the next era.",
                                "",
                                " The dispatch origin for this call must be _Signed_ by the controller, not the stash.",
                                "",
                                " # <weight>",
                                " - The transaction's complexity is proportional to the size of `targets`,",
                                " which is capped at CompactAssignments::LIMIT.",
                                " - Both the reads and writes follow a similar pattern.",
                                " # </weight>"
                            ]
                        },
                        {
                            "name": "chill",
                            "args": [],
                            "docs": [
                                " Declare no desire to either validate or nominate.",
                                "",
                                " Effects will be felt at the beginning of the next era.",
                                "",
                                " The dispatch origin for this call must be _Signed_ by the controller, not the stash.",
                                "",
                                " # <weight>",
                                " - Independent of the arguments. Insignificant complexity.",
                                " - Contains one read.",
                                " - Writes are limited to the `origin` account key.",
                                " # </weight>"
                            ]
                        },
                        {
                            "name": "set_payee",
                            "args": [
                                {
                                    "name": "payee",
                                    "type": "RewardDestination"
                                }
                            ],
                            "docs": [
                                " (Re-)set the payment target for a controller.",
                                "",
                                " Effects will be felt at the beginning of the next era.",
                                "",
                                " The dispatch origin for this call must be _Signed_ by the controller, not the stash.",
                                "",
                                " # <weight>",
                                " - Independent of the arguments. Insignificant complexity.",
                                " - Contains a limited number of reads.",
                                " - Writes are limited to the `origin` account key.",
                                " # </weight>"
                            ]
                        },
                        {
                            "name": "set_controller",
                            "args": [
                                {
                                    "name": "controller",
                                    "type": "LookupSource"
                                }
                            ],
                            "docs": [
                                " (Re-)set the controller of a stash.",
                                "",
                                " Effects will be felt at the beginning of the next era.",
                                "",
                                " The dispatch origin for this call must be _Signed_ by the stash, not the controller.",
                                "",
                                " # <weight>",
                                " - Independent of the arguments. Insignificant complexity.",
                                " - Contains a limited number of reads.",
                                " - Writes are limited to the `origin` account key.",
                                " # </weight>"
                            ]
                        },
                        {
                            "name": "set_validator_count",
                            "args": [
                                {
                                    "name": "new",
                                    "type": "Compact<u32>"
                                }
                            ],
                            "docs": [
                                " The ideal number of validators."
                            ]
                        },
                        {
                            "name": "force_no_eras",
                            "args": [],
                            "docs": [
                                " Force there to be no new eras indefinitely.",
                                "",
                                " # <weight>",
                                " - No arguments.",
                                " # </weight>"
                            ]
                        },
                        {
                            "name": "force_new_era",
                            "args": [],
                            "docs": [
                                " Force there to be a new era at the end of the next session. After this, it will be",
                                " reset to normal (non-forced) behaviour.",
                                "",
                                " # <weight>",
                                " - No arguments.",
                                " # </weight>"
                            ]
                        },
                        {
                            "name": "set_invulnerables",
                            "args": [
                                {
                                    "name": "validators",
                                    "type": "Vec<AccountId>"
                                }
                            ],
                            "docs": [
                                " Set the validators who cannot be slashed (if any)."
                            ]
                        },
                        {
                            "name": "force_unstake",
                            "args": [
                                {
                                    "name": "stash",
                                    "type": "AccountId"
                                }
                            ],
                            "docs": [
                                " Force a current staker to become completely unstaked, immediately."
                            ]
                        },
                        {
                            "name": "force_new_era_always",
                            "args": [],
                            "docs": [
                                " Force there to be a new era at the end of sessions indefinitely.",
                                "",
                                " # <weight>",
                                " - One storage write",
                                " # </weight>"
                            ]
                        },
                        {
                            "name": "cancel_deferred_slash",
                            "args": [
                                {
                                    "name": "era",
                                    "type": "EraIndex"
                                },
                                {
                                    "name": "slash_indices",
                                    "type": "Vec<u32>"
                                }
                            ],
                            "docs": [
                                " 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",
                            "args": [
                                {
                                    "name": "era",
                                    "type": "EraIndex"
                                },
                                {
                                    "name": "validators",
                                    "type": "Vec<(AccountId,u32)>"
                                }
                            ],
                            "docs": [
                                " **This extrinsic will be removed after `MigrationEra + HistoryDepth` has passed, giving",
                                " opportunity for users to claim all rewards before moving to Simple Payouts. After this",
                                " time, you should use `payout_stakers` instead.**",
                                "",
                                " 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",
                            "args": [
                                {
                                    "name": "era",
                                    "type": "EraIndex"
                                }
                            ],
                            "docs": [
                                " **This extrinsic will be removed after `MigrationEra + HistoryDepth` has passed, giving",
                                " opportunity for users to claim all rewards before moving to Simple Payouts. After this",
                                " time, you should use `payout_stakers` instead.**",
                                "",
                                " 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": "payout_stakers",
                            "args": [
                                {
                                    "name": "validator_stash",
                                    "type": "AccountId"
                                },
                                {
                                    "name": "era",
                                    "type": "EraIndex"
                                }
                            ],
                            "docs": [
                                " Pay out all the stakers behind a single validator for a single era.",
                                "",
                                " - `validator_stash` is the stash account of the validator. Their nominators, up to",
                                "   `T::MaxNominatorRewardedPerValidator`, will also receive their rewards.",
                                " - `era` may be any era between `[current_era - history_depth; current_era]`.",
                                "",
                                " The origin of this call must be _Signed_. Any account can call this function, even if",
                                " it is not one of the stakers.",
                                "",
                                " # <weight>",
                                " - Time complexity: at most O(MaxNominatorRewardedPerValidator).",
                                " - Contains a limited number of reads and writes.",
                                " # </weight>"
                            ]
                        },
                        {
                            "name": "rebond",
                            "args": [
                                {
                                    "name": "value",
                                    "type": "Compact<BalanceOf>"
                                }
                            ],
                            "docs": [
                                " 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",
                            "args": [
                                {
                                    "name": "new_history_depth",
                                    "type": "Compact<EraIndex>"
                                }
                            ],
                            "docs": [
                                " Set history_depth value.",
                                "",
                                " Origin must be root."
                            ]
                        },
                        {
                            "name": "reap_stash",
                            "args": [
                                {
                                    "name": "stash",
                                    "type": "AccountId"
                                }
                            ],
                            "docs": [
                                " 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."
                            ]
                        },
                        {
                            "name": "submit_election_solution",
                            "args": [
                                {
                                    "name": "winners",
                                    "type": "Vec<ValidatorIndex>"
                                },
                                {
                                    "name": "compact_assignments",
                                    "type": "CompactAssignments"
                                },
                                {
                                    "name": "score",
                                    "type": "PhragmenScore"
                                },
                                {
                                    "name": "era",
                                    "type": "EraIndex"
                                }
                            ],
                            "docs": [
                                " Submit a phragmen result to the chain. If the solution:",
                                "",
                                " 1. is valid.",
                                " 2. has a better score than a potentially existing solution on chain.",
                                "",
                                " then, it will be _put_ on chain.",
                                "",
                                " A solution consists of two pieces of data:",
                                "",
                                " 1. `winners`: a flat vector of all the winners of the round.",
                                " 2. `assignments`: the compact version of an assignment vector that encodes the edge",
                                "    weights.",
                                "",
                                " Both of which may be computed using [`phragmen`], or any other algorithm.",
                                "",
                                " Additionally, the submitter must provide:",
                                "",
                                " - The `score` that they claim their solution has.",
                                "",
                                " Both validators and nominators will be represented by indices in the solution. The",
                                " indices should respect the corresponding types ([`ValidatorIndex`] and",
                                " [`NominatorIndex`]). Moreover, they should be valid when used to index into",
                                " [`SnapshotValidators`] and [`SnapshotNominators`]. Any invalid index will cause the",
                                " solution to be rejected. These two storage items are set during the election window and",
                                " may be used to determine the indices.",
                                "",
                                " A solution is valid if:",
                                "",
                                " 0. It is submitted when [`EraElectionStatus`] is `Open`.",
                                " 1. Its claimed score is equal to the score computed on-chain.",
                                " 2. Presents the correct number of winners.",
                                " 3. All indexes must be value according to the snapshot vectors. All edge values must",
                                "    also be correct and should not overflow the granularity of the ratio type (i.e. 256",
                                "    or billion).",
                                " 4. For each edge, all targets are actually nominated by the voter.",
                                " 5. Has correct self-votes.",
                                "",
                                " A solutions score is consisted of 3 parameters:",
                                "",
                                " 1. `min { support.total }` for each support of a winner. This value should be maximized.",
                                " 2. `sum { support.total }` for each support of a winner. This value should be minimized.",
                                " 3. `sum { support.total^2 }` for each support of a winner. This value should be",
                                "    minimized (to ensure less variance)",
                                "",
                                " # <weight>",
                                " E: number of edges. m: size of winner committee. n: number of nominators. d: edge degree",
                                " (16 for now) v: number of on-chain validator candidates.",
                                "",
                                " NOTE: given a solution which is reduced, we can enable a new check the ensure `|E| < n +",
                                " m`. We don't do this _yet_, but our offchain worker code executes it nonetheless.",
                                "",
                                " major steps (all done in `check_and_replace_solution`):",
                                "",
                                " - Storage: O(1) read `ElectionStatus`.",
                                " - Storage: O(1) read `PhragmenScore`.",
                                " - Storage: O(1) read `ValidatorCount`.",
                                " - Storage: O(1) length read from `SnapshotValidators`.",
                                "",
                                " - Storage: O(v) reads of `AccountId` to fetch `snapshot_validators`.",
                                " - Memory: O(m) iterations to map winner index to validator id.",
                                " - Storage: O(n) reads `AccountId` to fetch `snapshot_nominators`.",
                                " - Memory: O(n + m) reads to map index to `AccountId` for un-compact.",
                                "",
                                " - Storage: O(e) accountid reads from `Nomination` to read correct nominations.",
                                " - Storage: O(e) calls into `slashable_balance_of_extended` to convert ratio to staked.",
                                "",
                                " - Memory: build_support_map. O(e).",
                                " - Memory: evaluate_support: O(E).",
                                "",
                                " - Storage: O(e) writes to `QueuedElected`.",
                                " - Storage: O(1) write to `QueuedScore`",
                                "",
                                " The weight of this call is 1/10th of the blocks total weight.",
                                " # </weight>"
                            ]
                        },
                        {
                            "name": "submit_election_solution_unsigned",
                            "args": [
                                {
                                    "name": "winners",
                                    "type": "Vec<ValidatorIndex>"
                                },
                                {
                                    "name": "compact_assignments",
                                    "type": "CompactAssignments"
                                },
                                {
                                    "name": "score",
                                    "type": "PhragmenScore"
                                },
                                {
                                    "name": "era",
                                    "type": "EraIndex"
                                }
                            ],
                            "docs": [
                                " Unsigned version of `submit_election_solution`.",
                                "",
                                " Note that this must pass the [`ValidateUnsigned`] check which only allows transactions",
                                " from the local node to be included. In other words, only the block author can include a",
                                " transaction in the block."
                            ]
                        }
                    ],
                    "events": [
                        {
                            "name": "Reward",
                            "args": [
                                "AccountId",
                                "Balance"
                            ],
                            "docs": [
                                " The staker has been rewarded by this amount. `AccountId` is the stash account."
                            ]
                        },
                        {
                            "name": "Slash",
                            "args": [
                                "AccountId",
                                "Balance"
                            ],
                            "docs": [
                                " One validator (and its nominators) has been slashed by the given amount."
                            ]
                        },
                        {
                            "name": "OldSlashingReportDiscarded",
                            "args": [
                                "SessionIndex"
                            ],
                            "docs": [
                                " An old slashing report from a prior era was discarded because it could",
                                " not be processed."
                            ]
                        },
                        {
                            "name": "StakingElection",
                            "args": [
                                "ElectionCompute"
                            ],
                            "docs": [
                                " A new set of stakers was elected with the given computation method."
                            ]
                        },
                        {
                            "name": "Bonded",
                            "args": [
                                "AccountId",
                                "Balance"
                            ],
                            "docs": [
                                " 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",
                            "args": [
                                "AccountId",
                                "Balance"
                            ],
                            "docs": [
                                " An account has unbonded this amount."
                            ]
                        },
                        {
                            "name": "Withdrawn",
                            "args": [
                                "AccountId",
                                "Balance"
                            ],
                            "docs": [
                                " An account has called `withdraw_unbonded` and removed unbonding chunks worth `Balance`",
                                " from the unlocking queue."
                            ]
                        }
                    ],
                    "constants": [
                        {
                            "name": "SessionsPerEra",
                            "type": "SessionIndex",
                            "value": "0x06000000",
                            "docs": [
                                " Number of sessions per era."
                            ]
                        },
                        {
                            "name": "BondingDuration",
                            "type": "EraIndex",
                            "value": "0x1c000000",
                            "docs": [
                                " Number of eras that staked funds must remain bonded for."
                            ]
                        }
                    ],
                    "errors": [
                        {
                            "name": "NotController",
                            "docs": [
                                " Not a controller account."
                            ]
                        },
                        {
                            "name": "NotStash",
                            "docs": [
                                " Not a stash account."
                            ]
                        },
                        {
                            "name": "AlreadyBonded",
                            "docs": [
                                " Stash is already bonded."
                            ]
                        },
                        {
                            "name": "AlreadyPaired",
                            "docs": [
                                " Controller is already paired."
                            ]
                        },
                        {
                            "name": "EmptyTargets",
                            "docs": [
                                " Targets cannot be empty."
                            ]
                        },
                        {
                            "name": "DuplicateIndex",
                            "docs": [
                                " Duplicate index."
                            ]
                        },
                        {
                            "name": "InvalidSlashIndex",
                            "docs": [
                                " Slash record index out of bounds."
                            ]
                        },
                        {
                            "name": "InsufficientValue",
                            "docs": [
                                " Can not bond with value less than minimum balance."
                            ]
                        },
                        {
                            "name": "NoMoreChunks",
                            "docs": [
                                " Can not schedule more unlock chunks."
                            ]
                        },
                        {
                            "name": "NoUnlockChunk",
                            "docs": [
                                " Can not rebond without unlocking chunks."
                            ]
                        },
                        {
                            "name": "FundedTarget",
                            "docs": [
                                " Attempting to target a stash that still has funds."
                            ]
                        },
                        {
                            "name": "InvalidEraToReward",
                            "docs": [
                                " Invalid era to reward."
                            ]
                        },
                        {
                            "name": "InvalidNumberOfNominations",
                            "docs": [
                                " Invalid number of nominations."
                            ]
                        },
                        {
                            "name": "NotSortedAndUnique",
                            "docs": [
                                " Items are not sorted and unique."
                            ]
                        },
                        {
                            "name": "AlreadyClaimed",
                            "docs": [
                                " Rewards for this era have already been claimed for this validator."
                            ]
                        },
                        {
                            "name": "PhragmenEarlySubmission",
                            "docs": [
                                " The submitted result is received out of the open window."
                            ]
                        },
                        {
                            "name": "PhragmenWeakSubmission",
                            "docs": [
                                " The submitted result is not as good as the one stored on chain."
                            ]
                        },
                        {
                            "name": "SnapshotUnavailable",
                            "docs": [
                                " The snapshot data of the current window is missing."
                            ]
                        },
                        {
                            "name": "PhragmenBogusWinnerCount",
                            "docs": [
                                " Incorrect number of winners were presented."
                            ]
                        },
                        {
                            "name": "PhragmenBogusWinner",
                            "docs": [
                                " One of the submitted winners is not an active candidate on chain (index is out of range",
                                " in snapshot)."
                            ]
                        },
                        {
                            "name": "PhragmenBogusCompact",
                            "docs": [
                                " Error while building the assignment type from the compact. This can happen if an index",
                                " is invalid, or if the weights _overflow_."
                            ]
                        },
                        {
                            "name": "PhragmenBogusNominator",
                            "docs": [
                                " One of the submitted nominators is not an active nominator on chain."
                            ]
                        },
                        {
                            "name": "PhragmenBogusNomination",
                            "docs": [
                                " One of the submitted nominators has an edge to which they have not voted on chain."
                            ]
                        },
                        {
                            "name": "PhragmenSlashedNomination",
                            "docs": [
                                " One of the submitted nominators has an edge which is submitted before the last non-zero",
                                " slash of the target."
                            ]
                        },
                        {
                            "name": "PhragmenBogusSelfVote",
                            "docs": [
                                " A self vote must only be originated from a validator to ONLY themselves."
                            ]
                        },
                        {
                            "name": "PhragmenBogusEdge",
                            "docs": [
                                " The submitted result has unknown edges that are not among the presented winners."
                            ]
                        },
                        {
                            "name": "PhragmenBogusScore",
                            "docs": [
                                " The claimed score does not match with the one computed from the data."
                            ]
                        }
                    ]
                },
                {
                    "name": "Offences",
                    "storage": {
                        "prefix": "Offences",
                        "items": [
                            {
                                "name": "Reports",
                                "modifier": "Optional",
                                "type": {
                                    "map": {
                                        "hasher": "Twox64Concat",
                                        "key": "ReportIdOf",
                                        "value": "OffenceDetails",
                                        "linked": false
                                    }
                                },
                                "fallback": "0x00",
                                "docs": [
                                    " The primary structure that holds all offence records keyed by report identifiers."
                                ]
                            },
                            {
                                "name": "DeferredOffences",
                                "modifier": "Default",
                                "type": {
                                    "plain": "Vec<DeferredOffenceOf>"
                                },
                                "fallback": "0x00",
                                "docs": [
                                    " Deferred reports that have been rejected by the offence handler and need to be submitted",
                                    " at a later time."
                                ]
                            },
                            {
                                "name": "ConcurrentReportsIndex",
                                "modifier": "Default",
                                "type": {
                                    "doubleMap": {
                                        "hasher": "Twox64Concat",
                                        "key1": "Kind",
                                        "key2": "OpaqueTimeSlot",
                                        "value": "Vec<ReportIdOf>",
                                        "key2Hasher": "Twox64Concat"
                                    }
                                },
                                "fallback": "0x00",
                                "docs": [
                                    " A vector of reports of the same kind that happened at the same time slot."
                                ]
                            },
                            {
                                "name": "ReportsByKindIndex",
                                "modifier": "Default",
                                "type": {
                                    "map": {
                                        "hasher": "Twox64Concat",
                                        "key": "Kind",
                                        "value": "Bytes",
                                        "linked": false
                                    }
                                },
                                "fallback": "0x00",
                                "docs": [
                                    " 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": [],
                    "events": [
                        {
                            "name": "Offence",
                            "args": [
                                "Kind",
                                "OpaqueTimeSlot",
                                "bool"
                            ],
                            "docs": [
                                " There is an offence reported of the given `kind` happened at the `session_index` and",
                                " (kind-specific) time slot. This event is not deposited for duplicate slashes. last",
                                " element indicates of the offence was applied (true) or queued (false)."
                            ]
                        }
                    ],
                    "constants": [],
                    "errors": []
                },
                {
                    "name": "Historical",
                    "storage": null,
                    "calls": null,
                    "events": null,
                    "constants": [],
                    "errors": []
                },
                {
                    "name": "Session",
                    "storage": {
                        "prefix": "Session",
                        "items": [
                            {
                                "name": "Validators",
                                "modifier": "Default",
                                "type": {
                                    "plain": "Vec<ValidatorId>"
                                },
                                "fallback": "0x00",
                                "docs": [
                                    " The current set of validators."
                                ]
                            },
                            {
                                "name": "CurrentIndex",
                                "modifier": "Default",
                                "type": {
                                    "plain": "SessionIndex"
                                },
                                "fallback": "0x00000000",
                                "docs": [
                                    " Current index of the session."
                                ]
                            },
                            {
                                "name": "QueuedChanged",
                                "modifier": "Default",
                                "type": {
                                    "plain": "bool"
                                },
                                "fallback": "0x00",
                                "docs": [
                                    " True if the underlying economic identities or weighting behind the validators",
                                    " has changed in the queued validator set."
                                ]
                            },
                            {
                                "name": "QueuedKeys",
                                "modifier": "Default",
                                "type": {
                                    "plain": "Vec<(ValidatorId,Keys)>"
                                },
                                "fallback": "0x00",
                                "docs": [
                                    " 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",
                                "type": {
                                    "plain": "Vec<u32>"
                                },
                                "fallback": "0x00",
                                "docs": [
                                    " Indices of disabled validators.",
                                    "",
                                    " The set is cleared when `on_session_ending` returns a new set of identities."
                                ]
                            },
                            {
                                "name": "NextKeys",
                                "modifier": "Optional",
                                "type": {
                                    "map": {
                                        "hasher": "Twox64Concat",
                                        "key": "ValidatorId",
                                        "value": "Keys",
                                        "linked": false
                                    }
                                },
                                "fallback": "0x00",
                                "docs": [
                                    " The next session keys for a validator."
                                ]
                            },
                            {
                                "name": "KeyOwner",
                                "modifier": "Optional",
                                "type": {
                                    "map": {
                                        "hasher": "Twox64Concat",
                                        "key": "(KeyTypeId,Bytes)",
                                        "value": "ValidatorId",
                                        "linked": false
                                    }
                                },
                                "fallback": "0x00",
                                "docs": [
                                    " The owner of a key. The key is the `KeyTypeId` + the encoded key."
                                ]
                            }
                        ]
                    },
                    "calls": [
                        {
                            "name": "set_keys",
                            "args": [
                                {
                                    "name": "keys",
                                    "type": "Keys"
                                },
                                {
                                    "name": "proof",
                                    "type": "Bytes"
                                }
                            ],
                            "docs": [
                                " Sets the session key(s) of the function caller to `keys`.",
                                " Allows an account to set its session key prior to becoming a validator.",
                                " This doesn't take effect until the next session.",
                                "",
                                " The dispatch origin of this function must be signed.",
                                "",
                                " # <weight>",
                                " - 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",
                            "args": [],
                            "docs": [
                                " Removes any session key(s) of the function caller.",
                                " This doesn't take effect until the next session.",
                                "",
                                " The dispatch origin of this function must be signed.",
                                "",
                                " # <weight>",
                                " - O(N) in number of key types.",
                                " - Removes N + 1 DB entries.",
                                " - Reduces system account refs by one on success.",
                                " # </weight>"
                            ]
                        }
                    ],
                    "events": [
                        {
                            "name": "NewSession",
                            "args": [
                                "SessionIndex"
                            ],
                            "docs": [
                                " 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",
                            "docs": [
                                " Invalid ownership proof."
                            ]
                        },
                        {
                            "name": "NoAssociatedValidatorId",
                            "docs": [
                                " No associated validator ID for account."
                            ]
                        },
                        {
                            "name": "DuplicatedKey",
                            "docs": [
                                " Registered duplicate key."
                            ]
                        },
                        {
                            "name": "NoKeys",
                            "docs": [
                                " No keys are associated with this account."
                            ]
                        }
                    ]
                },
                {
                    "name": "FinalityTracker",
                    "storage": {
                        "prefix": "FinalityTracker",
                        "items": [
                            {
                                "name": "RecentHints",
                                "modifier": "Default",
                                "type": {
                                    "plain": "Vec<BlockNumber>"
                                },
                                "fallback": "0x00",
                                "docs": [
                                    " Recent hints."
                                ]
                            },
                            {
                                "name": "OrderedHints",
                                "modifier": "Default",
                                "type": {
                                    "plain": "Vec<BlockNumber>"
                                },
                                "fallback": "0x00",
                                "docs": [
                                    " Ordered recent hints."
                                ]
                            },
                            {
                                "name": "Median",
                                "modifier": "Default",
                                "type": {
                                    "plain": "BlockNumber"
                                },
                                "fallback": "0x00000000",
                                "docs": [
                                    " The median."
                                ]
                            },
                            {
                                "name": "Update",
                                "modifier": "Optional",
                                "type": {
                                    "plain": "BlockNumber"
                                },
                                "fallback": "0x00",
                                "docs": [
                                    " Final hint to apply in the block. `None` means \"same as parent\"."
                                ]
                            },
                            {
                                "name": "Initialized",
                                "modifier": "Default",
                                "type": {
                                    "plain": "bool"
                                },
                                "fallback": "0x00",
                                "docs": []
                            }
                        ]
                    },
                    "calls": [
                        {
                            "name": "final_hint",
                            "args": [
                                {
                                    "name": "hint",
                                    "type": "Compact<BlockNumber>"
                                }
                            ],
                            "docs": [
                                " Hint that the author of this block thinks the best finalized",
                                " block is the given number."
                            ]
                        }
                    ],
                    "events": null,
                    "constants": [
                        {
                            "name": "WindowSize",
                            "type": "BlockNumber",
                            "value": "0x65000000",
                            "docs": [
                                " The number of recent samples to keep from this chain. Default is 101."
                            ]
                        },
                        {
                            "name": "ReportLatency",
                            "type": "BlockNumber",
                            "value": "0xe8030000",
                            "docs": [
                                " The delay after which point things become suspicious. Default is 1000."
                            ]
                        }
                    ],
                    "errors": [
                        {
                            "name": "AlreadyUpdated",
                            "docs": [
                                " Final hint must be updated only once in the block"
                            ]
                        },
                        {
                            "name": "BadHint",
                            "docs": [
                                " Finalized height above block number"
                            ]
                        }
                    ]
                },
                {
                    "name": "Grandpa",
                    "storage": {
                        "prefix": "GrandpaFinality",
                        "items": [
                            {
                                "name": "State",
                                "modifier": "Default",
                                "type": {
                                    "plain": "StoredState"
                                },
                                "fallback": "0x00",
                                "docs": [
                                    " State of the current authority set."
                                ]
                            },
                            {
                                "name": "PendingChange",
                                "modifier": "Optional",
                                "type": {
                                    "plain": "StoredPendingChange"
                                },
                                "fallback": "0x00",
                                "docs": [
                                    " Pending change: (signaled at, scheduled change)."
                                ]
                            },
                            {
                                "name": "NextForced",
                                "modifier": "Optional",
                                "type": {
                                    "plain": "BlockNumber"
                                },
                                "fallback": "0x00",
                                "docs": [
                                    " next block number where we can force a change."
                                ]
                            },
                            {
                                "name": "Stalled",
                                "modifier": "Optional",
                                "type": {
                                    "plain": "(BlockNumber,BlockNumber)"
                                },
                                "fallback": "0x00",
                                "docs": [
                                    " `true` if we are currently stalled."
                                ]
                            },
                            {
                                "name": "CurrentSetId",
                                "modifier": "Default",
                                "type": {
                                    "plain": "SetId"
                                },
                                "fallback": "0x0000000000000000",
                                "docs": [
                                    " 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",
                                "type": {
                                    "map": {
                                        "hasher": "Twox64Concat",
                                        "key": "SetId",
                                        "value": "SessionIndex",
                                        "linked": false
                                    }
                                },
                                "fallback": "0x00",
                                "docs": [
                                    " A mapping from grandpa set ID to the index of the *most recent* session for which its",
                                    " members were responsible."
                                ]
                            }
                        ]
                    },
                    "calls": [
                        {
                            "name": "report_misbehavior",
                            "args": [
                                {
                                    "name": "_report",
                                    "type": "Bytes"
                                }
                            ],
                            "docs": [
                                " Report some misbehavior."
                            ]
                        }
                    ],
                    "events": [
                        {
                            "name": "NewAuthorities",
                            "args": [
                                "AuthorityList"
                            ],
                            "docs": [
                                " New authority set has been applied."
                            ]
                        },
                        {
                            "name": "Paused",
                            "args": [],
                            "docs": [
                                " Current authority set has been paused."
                            ]
                        },
                        {
                            "name": "Resumed",
                            "args": [],
                            "docs": [
                                " Current authority set has been resumed."
                            ]
                        }
                    ],
                    "constants": [],
                    "errors": [
                        {
                            "name": "PauseFailed",
                            "docs": [
                                " Attempt to signal GRANDPA pause when the authority set isn't live",
                                " (either paused or already pending pause)."
                            ]
                        },
                        {
                            "name": "ResumeFailed",
                            "docs": [
                                " Attempt to signal GRANDPA resume when the authority set isn't paused",
                                " (either live or already pending resume)."
                            ]
                        },
                        {
                            "name": "ChangePending",
                            "docs": [
                                " Attempt to signal GRANDPA change with one already pending."
                            ]
                        },
                        {
                            "name": "TooSoon",
                            "docs": [
                                " Cannot signal forced change so soon after last."
                            ]
                        }
                    ]
                },
                {
                    "name": "ImOnline",
                    "storage": {
                        "prefix": "ImOnline",
                        "items": [
                            {
                                "name": "HeartbeatAfter",
                                "modifier": "Default",
                                "type": {
                                    "plain": "BlockNumber"
                                },
                                "fallback": "0x00000000",
                                "docs": [
                                    " 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",
                                "type": {
                                    "plain": "Vec<AuthorityId>"
                                },
                                "fallback": "0x00",
                                "docs": [
                                    " The current set of keys that may issue a heartbeat."
                                ]
                            },
                            {
                                "name": "ReceivedHeartbeats",
                                "modifier": "Optional",
                                "type": {
                                    "doubleMap": {
                                        "hasher": "Twox64Concat",
                                        "key1": "SessionIndex",
                                        "key2": "AuthIndex",
                                        "value": "Bytes",
                                        "key2Hasher": "Twox64Concat"
                                    }
                                },
                                "fallback": "0x00",
                                "docs": [
                                    " For each session index, we keep a mapping of `AuthIndex` to",
                                    " `offchain::OpaqueNetworkState`."
                                ]
                            },
                            {
                                "name": "AuthoredBlocks",
                                "modifier": "Default",
                                "type": {
                                    "doubleMap": {
                                        "hasher": "Twox64Concat",
                                        "key1": "SessionIndex",
                                        "key2": "ValidatorId",
                                        "value": "u32",
                                        "key2Hasher": "Twox64Concat"
                                    }
                                },
                                "fallback": "0x00000000",
                                "docs": [
                                    " For each session index, we keep a mapping of `T::ValidatorId` to the",
                                    " number of blocks authored by the given authority."
                                ]
                            }
                        ]
                    },
                    "calls": [
                        {
                            "name": "heartbeat",
                            "args": [
                                {
                                    "name": "heartbeat",
                                    "type": "Heartbeat"
                                },
                                {
                                    "name": "_signature",
                                    "type": "Signature"
                                }
                            ],
                            "docs": []
                        }
                    ],
                    "events": [
                        {
                            "name": "HeartbeatReceived",
                            "args": [
                                "AuthorityId"
                            ],
                            "docs": [
                                " A new heartbeat was received from `AuthorityId`"
                            ]
                        },
                        {
                            "name": "AllGood",
                            "args": [],
                            "docs": [
                                " At the end of the session, no offence was committed."
                            ]
                        },
                        {
                            "name": "SomeOffline",
                            "args": [
                                "Vec<IdentificationTuple>"
                            ],
                            "docs": [
                                " At the end of the session, at least once validator was found to be offline."
                            ]
                        }
                    ],
                    "constants": [],
                    "errors": [
                        {
                            "name": "InvalidKey",
                            "docs": [
                                " Non existent public key."
                            ]
                        },
                        {
                            "name": "DuplicatedHeartbeat",
                            "docs": [
                                " Duplicated heartbeat."
                            ]
                        }
                    ]
                },
                {
                    "name": "AuthorityDiscovery",
                    "storage": null,
                    "calls": [],
                    "events": null,
                    "constants": [],
                    "errors": []
                },
                {
                    "name": "Parachains",
                    "storage": {
                        "prefix": "Parachains",
                        "items": [
                            {
                                "name": "Authorities",
                                "modifier": "Default",
                                "type": {
                                    "plain": "Vec<ValidatorId>"
                                },
                                "fallback": "0x00",
                                "docs": [
                                    " All authorities' keys at the moment."
                                ]
                            },
                            {
                                "name": "Code",
                                "modifier": "Optional",
                                "type": {
                                    "map": {
                                        "hasher": "Twox64Concat",
                                        "key": "ParaId",
                                        "value": "Bytes",
                                        "linked": false
                                    }
                                },
                                "fallback": "0x00",
                                "docs": [
                                    " The parachains registered at present."
                                ]
                            },
                            {
                                "name": "Heads",
                                "modifier": "Optional",
                                "type": {
                                    "map": {
                                        "hasher": "Twox64Concat",
                                        "key": "ParaId",
                                        "value": "Bytes",
                                        "linked": false
                                    }
                                },
                                "fallback": "0x00",
                                "docs": [
                                    " The heads of the parachains registered at present."
                                ]
                            },
                            {
                                "name": "RelayDispatchQueue",
                                "modifier": "Default",
                                "type": {
                                    "map": {
                                        "hasher": "Twox64Concat",
                                        "key": "ParaId",
                                        "value": "Vec<UpwardMessage>",
                                        "linked": false
                                    }
                                },
                                "fallback": "0x00",
                                "docs": [
                                    " Messages ready to be dispatched onto the relay chain. It is subject to",
                                    " `MAX_MESSAGE_COUNT` and `WATERMARK_MESSAGE_SIZE`."
                                ]
                            },
                            {
                                "name": "RelayDispatchQueueSize",
                                "modifier": "Default",
                                "type": {
                                    "map": {
                                        "hasher": "Twox64Concat",
                                        "key": "ParaId",
                                        "value": "(u32,u32)",
                                        "linked": false
                                    }
                                },
                                "fallback": "0x0000000000000000",
                                "docs": [
                                    " 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",
                                    " second if the total length (in bytes) of the message payloads."
                                ]
                            },
                            {
                                "name": "NeedsDispatch",
                                "modifier": "Default",
                                "type": {
                                    "plain": "Vec<ParaId>"
                                },
                                "fallback": "0x00",
                                "docs": [
                                    " The ordered list of ParaIds that have a `RelayDispatchQueue` entry."
                                ]
                            },
                            {
                                "name": "DidUpdate",
                                "modifier": "Optional",
                                "type": {
                                    "plain": "Vec<ParaId>"
                                },
                                "fallback": "0x00",
                                "docs": [
                                    " `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",
                            "args": [
                                {
                                    "name": "heads",
                                    "type": "Vec<AttestedCandidate>"
                                }
                            ],
                            "docs": [
                                " Provide candidate receipts for parachains, in ascending order by id."
                            ]
                        },
                        {
                            "name": "report_double_vote",
                            "args": [
                                {
                                    "name": "report",
                                    "type": "DoubleVoteReport"
                                }
                            ],
                            "docs": [
                                " Provide a proof that some validator has commited a double-vote.",
                                "",
                                " The weight is 0; in order to avoid DoS a `SignedExtension` validation",
                                " is implemented."
                            ]
                        }
                    ],
                    "events": null,
                    "constants": [],
                    "errors": [
                        {
                            "name": "TooManyHeadUpdates",
                            "docs": [
                                " Parachain heads must be updated only once in the block."
                            ]
                        },
                        {
                            "name": "TooManyParaCandidates",
                            "docs": [
                                " Too many parachain candidates."
                            ]
                        },
                        {
                            "name": "HeadsOutOfOrder",
                            "docs": [
                                " Proposed heads must be ascending order by parachain ID without duplicate."
                            ]
                        },
                        {
                            "name": "UnregisteredPara",
                            "docs": [
                                " Candidate is for an unregistered parachain."
                            ]
                        },
                        {
                            "name": "InvalidCollator",
                            "docs": [
                                " Invalid collator."
                            ]
                        },
                        {
                            "name": "QueueFull",
                            "docs": [
                                " The message queue is full. Messages will be added when there is space."
                            ]
                        },
                        {
                            "name": "InvalidMessageOrigin",
                            "docs": [
                                " The message origin is invalid."
                            ]
                        },
                        {
                            "name": "NoValidatorGroup",
                            "docs": [
                                " No validator group for parachain."
                            ]
                        },
                        {
                            "name": "NotEnoughValidityVotes",
                            "docs": [
                                " Not enough validity votes for candidate."
                            ]
                        },
                        {
                            "name": "VotesExceedsAuthorities",
                            "docs": [
                                " The number of attestations exceeds the number of authorities."
                            ]
                        },
                        {
                            "name": "WrongValidatorAttesting",
                            "docs": [
                                " Attesting validator not on this chain's validation duty."
                            ]
                        },
                        {
                            "name": "InvalidSignature",
                            "docs": [
                                " Invalid signature from attester."
                            ]
                        },
                        {
                            "name": "UntaggedVotes",
                            "docs": [
                                " Extra untagged validity votes along with candidate."
                            ]
                        },
                        {
                            "name": "ParentMismatch",
                            "docs": [
                                " Wrong parent head for parachain receipt."
                            ]
                        },
                        {
                            "name": "HeadDataTooLarge",
                            "docs": [
                                " Head data was too large."
                            ]
                        },
                        {
                            "name": "CannotPayFees",
                            "docs": [
                                " Para does not have enough balance to pay fees."
                            ]
                        },
                        {
                            "name": "UnexpectedRelayParent",
                            "docs": [
                                " Unexpected relay-parent for a candidate receipt."
                            ]
                        }
                    ]
                },
                {
                    "name": "Attestations",
                    "storage": {
                        "prefix": "Attestations",
                        "items": [
                            {
                                "name": "RecentParaBlocks",
                                "modifier": "Optional",
                                "type": {
                                    "map": {
                                        "hasher": "Twox64Concat",
                                        "key": "BlockNumber",
                                        "value": "IncludedBlocks",
                                        "linked": false
                                    }
                                },
                                "fallback": "0x00",
                                "docs": [
                                    " A mapping from modular block number (n % AttestationPeriod)",
                                    " to session index and the list of candidate hashes."
                                ]
                            },
                            {
                                "name": "ParaBlockAttestations",
                                "modifier": "Optional",
                                "type": {
                                    "doubleMap": {
                                        "hasher": "Twox64Concat",
                                        "key1": "BlockNumber",
                                        "key2": "Hash",
                                        "value": "BlockAttestations",
                                        "key2Hasher": "Identity"
                                    }
                                },
                                "fallback": "0x00",
                                "docs": [
                                    " Attestations on a recent parachain block."
                                ]
                            },
                            {
                                "name": "DidUpdate",
                                "modifier": "Default",
                                "type": {
                                    "plain": "bool"
                                },
                                "fallback": "0x00",
                                "docs": []
                            }
                        ]
                    },
                    "calls": [
                        {
                            "name": "more_attestations",
                            "args": [
                                {
                                    "name": "_more",
                                    "type": "MoreAttestations"
                                }
                            ],
                            "docs": [
                                " Provide candidate receipts for parachains, in ascending order by id."
                            ]
                        }
                    ],
                    "events": null,
                    "constants": [],
                    "errors": [
                        {
                            "name": "TooManyAttestations",
                            "docs": [
                                " More attestations can be added only once in a block."
                            ]
                        }
                    ]
                },
                {
                    "name": "Registrar",
                    "storage": {
                        "prefix": "Registrar",
                        "items": [
                            {
                                "name": "Parachains",
                                "modifier": "Default",
                                "type": {
                                    "plain": "Vec<ParaId>"
                                },
                                "fallback": "0x00",
                                "docs": []
                            },
                            {
                                "name": "ThreadCount",
                                "modifier": "Default",
                                "type": {
                                    "plain": "u32"
                                },
                                "fallback": "0x00000000",
                                "docs": [
                                    " The number of threads to schedule per block."
                                ]
                            },
                            {
                                "name": "SelectedThreads",
                                "modifier": "Default",
                                "type": {
                                    "plain": "Vec<Vec<(ParaId,CollatorId)>>"
                                },
                                "fallback": "0x00",
                                "docs": [
                                    " 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",
                                "type": {
                                    "plain": "Vec<(ParaId,Option<(CollatorId,Retriable)>)>"
                                },
                                "fallback": "0x00",
                                "docs": [
                                    " 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",
                                "type": {
                                    "plain": "ParaId"
                                },
                                "fallback": "0xe8030000",
                                "docs": [
                                    " The next unused ParaId value. Start this high in order to keep low numbers for",
                                    " system-level chains."
                                ]
                            },
                            {
                                "name": "PendingSwap",
                                "modifier": "Optional",
                                "type": {
                                    "map": {
                                        "hasher": "Twox64Concat",
                                        "key": "ParaId",
                                        "value": "ParaId",
                                        "linked": false
                                    }
                                },
                                "fallback": "0x00",
                                "docs": [
                                    " Pending swap operations."
                                ]
                            },
                            {
                                "name": "Paras",
                                "modifier": "Optional",
                                "type": {
                                    "map": {
                                        "hasher": "Twox64Concat",
                                        "key": "ParaId",
                                        "value": "ParaInfo",
                                        "linked": false
                                    }
                                },
                                "fallback": "0x00",
                                "docs": [
                                    " Map of all registered parathreads/chains."
                                ]
                            },
                            {
                                "name": "RetryQueue",
                                "modifier": "Default",
                                "type": {
                                    "plain": "Vec<Vec<(ParaId,CollatorId)>>"
                                },
                                "fallback": "0x00",
                                "docs": [
                                    " The current queue for parathreads that should be retried."
                                ]
                            },
                            {
                                "name": "Debtors",
                                "modifier": "Default",
                                "type": {
                                    "map": {
                                        "hasher": "Twox64Concat",
                                        "key": "ParaId",
                                        "value": "AccountId",
                                        "linked": false
                                    }
                                },
                                "fallback": "0x0000000000000000000000000000000000000000000000000000000000000000",
                                "docs": [
                                    " Users who have paid a parathread's deposit"
                                ]
                            }
                        ]
                    },
                    "calls": [
                        {
                            "name": "register_para",
                            "args": [
                                {
                                    "name": "id",
                                    "type": "Compact<ParaId>"
                                },
                                {
                                    "name": "info",
                                    "type": "ParaInfo"
                                },
                                {
                                    "name": "code",
                                    "type": "Bytes"
                                },
                                {
                                    "name": "initial_head_data",
                                    "type": "Bytes"
                                }
                            ],
                            "docs": [
                                " 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",
                            "args": [
                                {
                                    "name": "id",
                                    "type": "Compact<ParaId>"
                                }
                            ],
                            "docs": [
                                " Deregister a parachain with given id"
                            ]
                        },
                        {
                            "name": "set_thread_count",
                            "args": [
                                {
                                    "name": "count",
                                    "type": "u32"
                                }
                            ],
                            "docs": [
                                " 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",
                            "args": [
                                {
                                    "name": "code",
                                    "type": "Bytes"
                                },
                                {
                                    "name": "initial_head_data",
                                    "type": "Bytes"
                                }
                            ],
                            "docs": [
                                " 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",
                            "args": [
                                {
                                    "name": "_id",
                                    "type": "Compact<ParaId>"
                                },
                                {
                                    "name": "_collator",
                                    "type": "CollatorId"
                                },
                                {
                                    "name": "_head_hash",
                                    "type": "Hash"
                                }
                            ],
                            "docs": [
                                " 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",
                            "args": [],
                            "docs": [
                                " 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",
                            "args": [
                                {
                                    "name": "other",
                                    "type": "Compact<ParaId>"
                                }
                            ],
                            "docs": [
                                " 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."
                            ]
                        }
                    ],
                    "events": [
                        {
                            "name": "ParathreadRegistered",
                            "args": [
                                "ParaId"
                            ],
                            "docs": [
                                " A parathread was registered; its new ID is supplied."
                            ]
                        },
                        {
                            "name": "ParathreadDeregistered",
                            "args": [
                                "ParaId"
                            ],
                            "docs": [
                                " The parathread of the supplied ID was de-registered."
                            ]
                        }
                    ],
                    "constants": [],
                    "errors": [
                        {
                            "name": "ParaAlreadyExists",
                            "docs": [
                                " Parachain already exists."
                            ]
                        },
                        {
                            "name": "InvalidChainId",
                            "docs": [
                                " Invalid parachain ID."
                            ]
                        },
                        {
                            "name": "InvalidThreadId",
                            "docs": [
                                " Invalid parathread ID."
                            ]
                        },
                        {
                            "name": "CodeTooLarge",
                            "docs": [
                                " Invalid para code size."
                            ]
                        },
                        {
                            "name": "HeadDataTooLarge",
                            "docs": [
                                " Invalid para head data size."
                            ]
                        }
                    ]
                },
                {
                    "name": "Utility",
                    "storage": {
                        "prefix": "Utility",
                        "items": [
                            {
                                "name": "Multisigs",
                                "modifier": "Optional",
                                "type": {
                                    "doubleMap": {
                                        "hasher": "Twox64Concat",
                                        "key1": "AccountId",
                                        "key2": "[u8;32]",
                                        "value": "Multisig",
                                        "key2Hasher": "Blake2_128Concat"
                                    }
                                },
                                "fallback": "0x00",
                                "docs": [
                                    " The set of open multisig operations."
                                ]
                            }
                        ]
                    },
                    "calls": [
                        {
                            "name": "batch",
                            "args": [
                                {
                                    "name": "calls",
                                    "type": "Vec<Call>"
                                }
                            ],
                            "docs": [
                                " 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",
                            "args": [
                                {
                                    "name": "index",
                                    "type": "u16"
                                },
                                {
                                    "name": "call",
                                    "type": "Call"
                                }
                            ],
                            "docs": [
                                " 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",
                            "args": [
                                {
                                    "name": "threshold",
                                    "type": "u16"
                                },
                                {
                                    "name": "other_signatories",
                                    "type": "Vec<AccountId>"
                                },
                                {
                                    "name": "maybe_timepoint",
                                    "type": "Option<Timepoint>"
                                },
                                {
                                    "name": "call",
                                    "type": "Call"
                                }
                            ],
                            "docs": [
                                " Register approval for a dispatch to be made from a deterministic composite account if",
                                " approved by a total of `threshold - 1` of `other_signatories`.",
                                "",
                                " If there are enough, then dispatch the call.",
                                "",
                                " Payment: `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",
                            "args": [
                                {
                                    "name": "threshold",
                                    "type": "u16"
                                },
                                {
                                    "name": "other_signatories",
                                    "type": "Vec<AccountId>"
                                },
                                {
                                    "name": "maybe_timepoint",
                                    "type": "Option<Timepoint>"
                                },
                                {
                                    "name": "call_hash",
                                    "type": "[u8;32]"
                                }
                            ],
                            "docs": [
                                " Register approval for a dispatch to be made from a deterministic composite account if",
                                " approved by a total of `threshold - 1` of `other_signatories`.",
                                "",
                                " Payment: `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",
                            "args": [
                                {
                                    "name": "threshold",
                                    "type": "u16"
                                },
                                {
                                    "name": "other_signatories",
                                    "type": "Vec<AccountId>"
                                },
                                {
                                    "name": "timepoint",
                                    "type": "Timepoint"
                                },
                                {
                                    "name": "call_hash",
                                    "type": "[u8;32]"
                                }
                            ],
                            "docs": [
                                " Cancel a pre-existing, on-going multisig transaction. Any deposit reserved previously",
                                " for this operation will be unreserved on success.",
                                "",
                                " The dispatch origin for this call must be _Signed_.",
                                "",
                                " - `threshold`: The total number of approvals for this dispatch before it is executed.",
                                " - `other_signatories`: The accounts (other than the sender) who can approve this",
                                " dispatch. May not be empty.",
                                " - `timepoint`: The timepoint (block number and transaction index) of the first approval",
                                " transaction for this dispatch.",
                                " - `call_hash`: The hash of the call to be executed.",
                                "",
                                " # <weight>",
                                " - `O(S)`.",
                                " - Up to one balance-reserve or unreserve operation.",
                                " - One passthrough operation, one insert, both `O(S)` where `S` is the number of",
                                "   signatories. `S` is capped by `MaxSignatories`, with weight being proportional.",
                                " - One encode & hash, both of complexity `O(S)`.",
                                " - One event.",
                                " - I/O: 1 read `O(S)`, one remove.",
                                " - Storage: removes one item.",
                                " # </weight>"
                            ]
                        }
                    ],
                    "events": [
                        {
                            "name": "BatchInterrupted",
                            "args": [
                                "u32",
                                "DispatchError"
                            ],
                            "docs": [
                                " Batch of dispatches did not complete fully. Index of first failing dispatch given, as",
                                " well as the error."
                            ]
                        },
                        {
                            "name": "BatchCompleted",
                            "args": [],
                            "docs": [
                                " Batch of dispatches completed fully with no error."
                            ]
                        },
                        {
                            "name": "NewMultisig",
                            "args": [
                                "AccountId",
                                "AccountId"
                            ],
                            "docs": [
                                " A new multisig operation has begun. First param is the account that is approving,",
                                " second is the multisig account."
                            ]
                        },
                        {
                            "name": "MultisigApproval",
                            "args": [
                                "AccountId",
                                "Timepoint",
                                "AccountId"
                            ],
                            "docs": [
                                " A multisig operation has been approved by someone. First param is the account that is",
                                " approving, third is the multisig account."
                            ]
                        },
                        {
                            "name": "MultisigExecuted",
                            "args": [
                                "AccountId",
                                "Timepoint",
                                "AccountId",
                                "DispatchResult"
                            ],
                            "docs": [
                                " A multisig operation has been executed. First param is the account that is",
                                " approving, third is the multisig account."
                            ]
                        },
                        {
                            "name": "MultisigCancelled",
                            "args": [
                                "AccountId",
                                "Timepoint",
                                "AccountId"
                            ],
                            "docs": [
                                " A multisig operation has been cancelled. First param is the account that is",
                                " cancelling, third is the multisig account."
                            ]
                        }
                    ],
                    "constants": [],
                    "errors": [
                        {
                            "name": "ZeroThreshold",
                            "docs": [
                                " Threshold is too low (zero)."
                            ]
                        },
                        {
                            "name": "AlreadyApproved",
                            "docs": [
                                " Call is already approved by this signatory."
                            ]
                        },
                        {
                            "name": "NoApprovalsNeeded",
                            "docs": [
                                " Call doesn't need any (more) approvals."
                            ]
                        },
                        {
                            "name": "TooFewSignatories",
                            "docs": [
                                " There are too few signatories in the list."
                            ]
                        },
                        {
                            "name": "TooManySignatories",
                            "docs": [
                                " There are too many signatories in the list."
                            ]
                        },
                        {
                            "name": "SignatoriesOutOfOrder",
                            "docs": [
                                " The signatories were provided out of order; they should be ordered."
                            ]
                        },
                        {
                            "name": "SenderInSignatories",
                            "docs": [
                                " The sender was contained in the other signatories; it shouldn't be."
                            ]
                        },
                        {
                            "name": "NotFound",
                            "docs": [
                                " Multisig operation not found when attempting to cancel."
                            ]
                        },
                        {
                            "name": "NotOwner",
                            "docs": [
                                " Only the account that originally created the multisig is able to cancel it."
                            ]
                        },
                        {
                            "name": "NoTimepoint",
                            "docs": [
                                " No timepoint was given, yet the multisig operation is already underway."
                            ]
                        },
                        {
                            "name": "WrongTimepoint",
                            "docs": [
                                " A different timepoint was given to the multisig operation that is underway."
                            ]
                        },
                        {
                            "name": "UnexpectedTimepoint",
                            "docs": [
                                " A timepoint was given, yet no multisig operation is underway."
                            ]
                        }
                    ]
                },
                {
                    "name": "Identity",
                    "storage": {
                        "prefix": "Identity",
                        "items": [
                            {
                                "name": "IdentityOf",
                                "modifier": "Optional",
                                "type": {
                                    "map": {
                                        "hasher": "Twox64Concat",
                                        "key": "AccountId",
                                        "value": "Registration",
                                        "linked": false
                                    }
                                },
                                "fallback": "0x00",
                                "docs": [
                                    " Information that is pertinent to identify the entity behind an account."
                                ]
                            },
                            {
                                "name": "SuperOf",
                                "modifier": "Optional",
                                "type": {
                                    "map": {
                                        "hasher": "Blake2_128Concat",
                                        "key": "AccountId",
                                        "value": "(AccountId,Data)",
                                        "linked": false
                                    }
                                },
                                "fallback": "0x00",
                                "docs": [
                                    " 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",
                                "type": {
                                    "map": {
                                        "hasher": "Twox64Concat",
                                        "key": "AccountId",
                                        "value": "(BalanceOf,Vec<AccountId>)",
                                        "linked": false
                                    }
                                },
                                "fallback": "0x0000000000000000000000000000000000",
                                "docs": [
                                    " Alternative \"sub\" identities of this account.",
                                    "",
                                    " The first item is the deposit, the second is a vector of the accounts."
                                ]
                            },
                            {
                                "name": "Registrars",
                                "modifier": "Default",
                                "type": {
                                    "plain": "Vec<Option<RegistrarInfo>>"
                                },
                                "fallback": "0x00",
                                "docs": [
                                    " 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",
                            "args": [
                                {
                                    "name": "account",
                                    "type": "AccountId"
                                }
                            ],
                            "docs": [
                                " 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",
                            "args": [
                                {
                                    "name": "info",
                                    "type": "IdentityInfo"
                                }
                            ],
                            "docs": [
                                " Set an account's identity information and reserve the appropriate deposit.",
                                "",
                                " If the account already has identity information, the deposit is taken as part payment",
                                " for the new deposit.",
                                "",
                                " The dispatch origin for this call must be _Signed_ 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",
                            "args": [
                                {
                                    "name": "subs",
                                    "type": "Vec<(AccountId,Data)>"
                                }
                            ],
                            "docs": [
                                " Set the sub-accounts of the sender.",
                                "",
                                " Payment: Any aggregate balance reserved by previous `set_subs` calls will be returned",
                                " and an amount `SubAccountDeposit` will be reserved for each item in `subs`.",
                                "",
                                " The dispatch origin for this call must be _Signed_ and the sender must have a registered",
                                " identity.",
                                "",
                                " - `subs`: The identity's 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",
                            "args": [],
                            "docs": [
                                " 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",
                            "args": [
                                {
                                    "name": "reg_index",
                                    "type": "Compact<RegistrarIndex>"
                                },
                                {
                                    "name": "max_fee",
                                    "type": "Compact<BalanceOf>"
                                }
                            ],
                            "docs": [
                                " Request a judgement from a registrar.",
                                "",
                                " Payment: At most `max_fee` will be reserved for payment to the registrar if judgement",
                                " given.",
                                "",
                                " The dispatch origin for this call must be _Signed_ and the sender must have a",
                                " registered identity.",
                                "",
                                " - `reg_index`: The index of the registrar whose judgement is requested.",
                                " - `max_fee`: The maximum fee that may be paid. This should just be auto-populated as:",
                                "",
                                " ```nocompile",
                                " Self::registrars(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",
                            "args": [
                                {
                                    "name": "reg_index",
                                    "type": "RegistrarIndex"
                                }
                            ],
                            "docs": [
                                " Cancel a previous request.",
                                "",
                                " Payment: A previously reserved deposit is returned on success.",
                                "",
                                " The dispatch origin for this call must be _Signed_ and the sender must have a",
                                " registered identity.",
                                "",
                                " - `reg_index`: The index of the registrar whose judgement is no longer requested.",
                                "",
                                " Emits `JudgementUnrequested` if successful.",
                                "",
                                " # <weight>",
                                " - `O(R + X)`.",
                                " - One balance-reserve operation.",
                                " - One storage mutation `O(R + X)`.",
                                " - One event.",
                                " # </weight>"
                            ]
                        },
                        {
                            "name": "set_fee",
                            "args": [
                                {
                                    "name": "index",
                                    "type": "Compact<RegistrarIndex>"
                                },
                                {
                                    "name": "fee",
                                    "type": "Compact<BalanceOf>"
                                }
                            ],
                            "docs": [
                                " Set the fee required for a judgement to be requested from a registrar.",
                                "",
                                " The dispatch origin for this call must be _Signed_ and the sender must be the account",
                                " of the registrar whose index is `index`.",
                                "",
                                " - `index`: the index of the registrar whose fee is to be set.",
                                " - `fee`: the new fee.",
                                "",
                                " # <weight>",
                                " - `O(R)`.",
                                " - One storage mutation `O(R)`.",
                                " # </weight>"
                            ]
                        },
                        {
                            "name": "set_account_id",
                            "args": [
                                {
                                    "name": "index",
                                    "type": "Compact<RegistrarIndex>"
                                },
                                {
                                    "name": "new",
                                    "type": "AccountId"
                                }
                            ],
                            "docs": [
                                " Change the account associated with a registrar.",
                                "",
                                " The dispatch origin for this call must be _Signed_ and the sender must be the account",
                                " of the registrar whose index is `index`.",
                                "",
                                " - `index`: the index of the registrar whose fee is to be set.",
                                " - `new`: the new account ID.",
                                "",
                                " # <weight>",
                                " - `O(R)`.",
                                " - One storage mutation `O(R)`.",
                                " # </weight>"
                            ]
                        },
                        {
                            "name": "set_fields",
                            "args": [
                                {
                                    "name": "index",
                                    "type": "Compact<RegistrarIndex>"
                                },
                                {
                                    "name": "fields",
                                    "type": "IdentityFields"
                                }
                            ],
                            "docs": [
                                " Set the field information for a registrar.",
                                "",
                                " The dispatch origin for this call must be _Signed_ and the sender must be the account",
                                " of the registrar whose index is `index`.",
                                "",
                                " - `index`: the index of the registrar whose fee is to be set.",
                                " - `fields`: the fields that the registrar concerns themselves with.",
                                "",
                                " # <weight>",
                                " - `O(R)`.",
                                " - One storage mutation `O(R)`.",
                                " # </weight>"
                            ]
                        },
                        {
                            "name": "provide_judgement",
                            "args": [
                                {
                                    "name": "reg_index",
                                    "type": "Compact<RegistrarIndex>"
                                },
                                {
                                    "name": "target",
                                    "type": "LookupSource"
                                },
                                {
                                    "name": "judgement",
                                    "type": "Judgement"
                                }
                            ],
                            "docs": [
                                " Provide a judgement for an account's identity.",
                                "",
                                " The dispatch origin for this call must be _Signed_ and the sender must be the account",
                                " of the registrar whose index is `reg_index`.",
                                "",
                                " - `reg_index`: the index of the registrar whose judgement is being made.",
                                " - `target`: the account whose identity the judgement is upon. This must be an account",
                                "   with a registered identity.",
                                " - `judgement`: the judgement of the registrar of index `reg_index` about `target`.",
                                "",
                                " Emits `JudgementGiven` if successful.",
                                "",
                                " # <weight>",
                                " - `O(R + X)`.",
                                " - One balance-transfer operation.",
                                " - Up to one account-lookup operation.",
                                " - Storage: 1 read `O(R)`, 1 mutate `O(R + X)`.",
                                " - One event.",
                                " # </weight>"
                            ]
                        },
                        {
                            "name": "kill_identity",
                            "args": [
                                {
                                    "name": "target",
                                    "type": "LookupSource"
                                }
                            ],
                            "docs": [
                                " Remove an account's identity and sub-account information and slash the deposits.",
                                "",
                                " Payment: Reserved balances from `set_subs` and `set_identity` are slashed and handled by",
                                " `Slash`. Verification request deposits are not returned; they should be cancelled",
                                " manually using `cancel_request`.",
                                "",
                                " The dispatch origin for this call must 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>"
                            ]
                        }
                    ],
                    "events": [
                        {
                            "name": "IdentitySet",
                            "args": [
                                "AccountId"
                            ],
                            "docs": [
                                " A name was set or reset (which will remove all judgements)."
                            ]
                        },
                        {
                            "name": "IdentityCleared",
                            "args": [
                                "AccountId",
                                "Balance"
                            ],
                            "docs": [
                                " A name was cleared, and the given balance returned."
                            ]
                        },
                        {
                            "name": "IdentityKilled",
                            "args": [
                                "AccountId",
                                "Balance"
                            ],
                            "docs": [
                                " A name was removed and the given balance slashed."
                            ]
                        },
                        {
                            "name": "JudgementRequested",
                            "args": [
                                "AccountId",
                                "RegistrarIndex"
                            ],
                            "docs": [
                                " A judgement was asked from a registrar."
                            ]
                        },
                        {
                            "name": "JudgementUnrequested",
                            "args": [
                                "AccountId",
                                "RegistrarIndex"
                            ],
                            "docs": [
                                " A judgement request was retracted."
                            ]
                        },
                        {
                            "name": "JudgementGiven",
                            "args": [
                                "AccountId",
                                "RegistrarIndex"
                            ],
                            "docs": [
                                " A judgement was given by a registrar."
                            ]
                        },
                        {
                            "name": "RegistrarAdded",
                            "args": [
                                "RegistrarIndex"
                            ],
                            "docs": [
                                " A registrar was added."
                            ]
                        }
                    ],
                    "constants": [],
                    "errors": [
                        {
                            "name": "TooManySubAccounts",
                            "docs": [
                                " Too many subs-accounts."
                            ]
                        },
                        {
                            "name": "NotFound",
                            "docs": [
                                " Account isn't found."
                            ]
                        },
                        {
                            "name": "NotNamed",
                            "docs": [
                                " Account isn't named."
                            ]
                        },
                        {
                            "name": "EmptyIndex",
                            "docs": [
                                " Empty index."
                            ]
                        },
                        {
                            "name": "FeeChanged",
                            "docs": [
                                " Fee is changed."
                            ]
                        },
                        {
                            "name": "NoIdentity",
                            "docs": [
                                " No identity found."
                            ]
                        },
                        {
                            "name": "StickyJudgement",
                            "docs": [
                                " Sticky judgement."
                            ]
                        },
                        {
                            "name": "JudgementGiven",
                            "docs": [
                                " Judgement given."
                            ]
                        },
                        {
                            "name": "InvalidJudgement",
                            "docs": [
                                " Invalid judgement."
                            ]
                        },
                        {
                            "name": "InvalidIndex",
                            "docs": [
                                " The index is invalid."
                            ]
                        },
                        {
                            "name": "InvalidTarget",
                            "docs": [
                                " The target is invalid."
                            ]
                        },
                        {
                            "name": "TooManyFields",
                            "docs": [
                                " Too many additional fields."
                            ]
                        }
                    ]
                },
                {
                    "name": "Recovery",
                    "storage": {
                        "prefix": "Recovery",
                        "items": [
                            {
                                "name": "Recoverable",
                                "modifier": "Optional",
                                "type": {
                                    "map": {
                                        "hasher": "Twox64Concat",
                                        "key": "AccountId",
                                        "value": "RecoveryConfig",
                                        "linked": false
                                    }
                                },
                                "fallback": "0x00",
                                "docs": [
                                    " The set of recoverable accounts and their recovery configuration."
                                ]
                            },
                            {
                                "name": "ActiveRecoveries",
                                "modifier": "Optional",
                                "type": {
                                    "doubleMap": {
                                        "hasher": "Twox64Concat",
                                        "key1": "AccountId",
                                        "key2": "AccountId",
                                        "value": "ActiveRecovery",
                                        "key2Hasher": "Twox64Concat"
                                    }
                                },
                                "fallback": "0x00",
                                "docs": [
                                    " 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",
                                "type": {
                                    "map": {
                                        "hasher": "Blake2_128Concat",
                                        "key": "AccountId",
                                        "value": "AccountId",
                                        "linked": false
                                    }
                                },
                                "fallback": "0x00",
                                "docs": [
                                    " The list of allowed proxy accounts.",
                                    "",
                                    " Map from the user who can access it to the recovered account."
                                ]
                            }
                        ]
                    },
                    "calls": [
                        {
                            "name": "as_recovered",
                            "args": [
                                {
                                    "name": "account",
                                    "type": "AccountId"
                                },
                                {
                                    "name": "call",
                                    "type": "Call"
                                }
                            ],
                            "docs": [
                                " Send a call through a recovered account.",
                                "",
                                " The dispatch origin for this call must be _Signed_ and registered to",
                                " be able to make calls on behalf of the recovered account.",
                                "",
                                " Parameters:",
                                " - `account`: The recovered account you want to make a call on-behalf-of.",
                                " - `call`: The call you want to make with the recovered account.",
                                "",
                                " # <weight>",
                                " - The weight of the `call` + 10,000.",
                                " - One storage lookup to check account is recovered by `who`. O(1)",
                                " # </weight>"
                            ]
                        },
                        {
                            "name": "set_recovered",
                            "args": [
                                {
                                    "name": "lost",
                                    "type": "AccountId"
                                },
                                {
                                    "name": "rescuer",
                                    "type": "AccountId"
                                }
                            ],
                            "docs": [
                                " Allow ROOT to bypass the recovery process and set an a rescuer account",
                                " for a lost account directly.",
                                "",
                                " The dispatch origin for this call must be _ROOT_.",
                                "",
                                " Parameters:",
                                " - `lost`: The \"lost account\" to be recovered.",
                                " - `rescuer`: The \"rescuer account\" which can call as the lost account.",
                                "",
                                " # <weight>",
                                " - One storage write O(1)",
                                " - One event",
                                " # </weight>"
                            ]
                        },
                        {
                            "name": "create_recovery",
                            "args": [
                                {
                                    "name": "friends",
                                    "type": "Vec<AccountId>"
                                },
                                {
                                    "name": "threshold",
                                    "type": "u16"
                                },
                                {
                                    "name": "delay_period",
                                    "type": "BlockNumber"
                                }
                            ],
                            "docs": [
                                " Create a recovery configuration for your account. This makes your account recoverable.",
                                "",
                                " Payment: `ConfigDepositBase` + `FriendDepositFactor` * #_of_friends balance",
                                " will be reserved for storing the recovery configuration. This deposit is returned",
                                " in full when the user calls `remove_recovery`.",
                                "",
                                " The dispatch origin for this call must be _Signed_.",
                                "",
                                " Parameters:",
                                " - `friends`: A list of friends you trust to vouch for recovery attempts.",
                                "   Should be ordered and contain no duplicate values.",
                                " - `threshold`: The number of friends that must vouch for a recovery attempt",
                                "   before the account can be recovered. Should be less than or equal to",
                                "   the length of the list of friends.",
                                " - `delay_period`: The number of blocks after a recovery attempt is initialized",
                                "   that needs to pass before the account can be recovered.",
                                "",
                                " # <weight>",
                                " - Key: F (len of friends)",
                                " - One storage read to check that account is not already recoverable. O(1).",
                                " - A check that the friends list is sorted and unique. O(F)",
                                " - One currency reserve operation. O(X)",
                                " - One storage write. O(1). Codec O(F).",
                                " - One event.",
                                "",
                                " Total Complexity: O(F + X)",
                                " # </weight>"
                            ]
                        },
                        {
                            "name": "initiate_recovery",
                            "args": [
                                {
                                    "name": "account",
                                    "type": "AccountId"
                                }
                            ],
                            "docs": [
                                " Initiate the process for recovering a recoverable account.",
                                "",
                                " Payment: `RecoveryDeposit` balance will be reserved for initiating the",
                                " recovery process. This deposit will always be repatriated to the account",
                                " trying to be recovered. See `close_recovery`.",
                                "",
                                " The dispatch origin for this call must be _Signed_.",
                                "",
                                " Parameters:",
                                " - `account`: The lost account that you want to recover. This account",
                                "   needs to be recoverable (i.e. have a recovery configuration).",
                                "",
                                " # <weight>",
                                " - One storage read to check that account is recoverable. O(F)",
                                " - One storage read to check that this recovery process hasn't already started. O(1)",
                                " - One currency reserve operation. O(X)",
                                " - One storage read to get the current block number. O(1)",
                                " - One storage write. O(1).",
                                " - One event.",
                                "",
                                " Total Complexity: O(F + X)",
                                " # </weight>"
                            ]
                        },
                        {
                            "name": "vouch_recovery",
                            "args": [
                                {
                                    "name": "lost",
                                    "type": "AccountId"
                                },
                                {
                                    "name": "rescuer",
                                    "type": "AccountId"
                                }
                            ],
                            "docs": [
                                " Allow a \"friend\" of a recoverable account to vouch for an active recovery",
                                " process for that account.",
                                "",
                                " The dispatch origin for this call must be _Signed_ and must be a \"friend\"",
                                " for the recoverable account.",
                                "",
                                " Parameters:",
                                " - `lost`: The lost account that you want to recover.",
                                " - `rescuer`: The account trying to rescue the lost account that you",
                                "   want to vouch for.",
                                "",
                                " The combination of these two parameters must point to an active recovery",
                                " process.",
                                "",
                                " # <weight>",
                                " Key: F (len of friends in config), V (len of vouching friends)",
                                " - One storage read to get the recovery configuration. O(1), Codec O(F)",
                                " - One storage read to get the active recovery process. O(1), Codec O(V)",
                                " - One binary search to confirm caller is a friend. O(logF)",
                                " - One binary search to confirm caller has not already vouched. O(logV)",
                                " - One storage write. O(1), Codec O(V).",
                                " - One event.",
                                "",
                                " Total Complexity: O(F + logF + V + logV)",
                                " # </weight>"
                            ]
                        },
                        {
                            "name": "claim_recovery",
                            "args": [
                                {
                                    "name": "account",
                                    "type": "AccountId"
                                }
                            ],
                            "docs": [
                                " Allow a successful rescuer to claim their recovered account.",
                                "",
                                " The dispatch origin for this call must be _Signed_ and must be a \"rescuer\"",
                                " who has successfully completed the account recovery process: collected",
                                " `threshold` or more vouches, waited `delay_period` blocks since initiation.",
                                "",
                                " Parameters:",
                                " - `account`: The lost account that you want to claim has been successfully",
                                "   recovered by you.",
                                "",
                                " # <weight>",
                                " Key: F (len of friends in config), V (len of vouching friends)",
                                " - One storage read to get the recovery configuration. O(1), Codec O(F)",
                                " - One storage read to get the active recovery process. O(1), Codec O(V)",
                                " - One storage read to get the current block number. O(1)",
                                " - One storage write. O(1), Codec O(V).",
                                " - One event.",
                                "",
                                " Total Complexity: O(F + V)",
                                " # </weight>"
                            ]
                        },
                        {
                            "name": "close_recovery",
                            "args": [
                                {
                                    "name": "rescuer",
                                    "type": "AccountId"
                                }
                            ],
                            "docs": [
                                " As the controller of a recoverable account, close an active recovery",
                                " process for your account.",
                                "",
                                " Payment: By calling this function, the recoverable account will receive",
                                " the recovery deposit `RecoveryDeposit` placed by the rescuer.",
                                "",
                                " The dispatch origin for this call must be _Signed_ and must be a",
                                " recoverable account with an active recovery process for it.",
                                "",
                                " Parameters:",
                                " - `rescuer`: The account trying to rescue this recoverable account.",
                                "",
                                " # <weight>",
                                " Key: V (len of vouching friends)",
                                " - One storage read/remove to get the active recovery process. O(1), Codec O(V)",
                                " - One balance call to repatriate reserved. O(X)",
                                " - One event.",
                                "",
                                " Total Complexity: O(V + X)",
                                " # </weight>"
                            ]
                        },
                        {
                            "name": "remove_recovery",
                            "args": [],
                            "docs": [
                                " Remove the recovery process for your account. Recovered accounts are still accessible.",
                                "",
                                " NOTE: The user must make sure to call `close_recovery` on all active",
                                " recovery attempts before calling this function else it will fail.",
                                "",
                                " Payment: By calling this function the recoverable account will unreserve",
                                " their recovery configuration deposit.",
                                " (`ConfigDepositBase` + `FriendDepositFactor` * #_of_friends)",
                                "",
                                " The dispatch origin for this call must be _Signed_ and must be a",
                                " recoverable account (i.e. has a recovery configuration).",
                                "",
                                " # <weight>",
                                " Key: F (len of friends)",
                                " - One storage read to get the prefix iterator for active recoveries. O(1)",
                                " - One storage read/remove to get the recovery configuration. O(1), Codec O(F)",
                                " - One balance call to unreserved. O(X)",
                                " - One event.",
                                "",
                                " Total Complexity: O(F + X)",
                                " # </weight>"
                            ]
                        },
                        {
                            "name": "cancel_recovered",
                            "args": [
                                {
                                    "name": "account",
                                    "type": "AccountId"
                                }
                            ],
                            "docs": [
                                " Cancel the ability to use `as_recovered` for `account`.",
                                "",
                                " The dispatch origin for this call must be _Signed_ and registered to",
                                " be able to make calls on behalf of the recovered account.",
                                "",
                                " Parameters:",
                                " - `account`: The recovered account you are able to call on-behalf-of.",
                                "",
                                " # <weight>",
                                " - One storage mutation to check account is recovered by `who`. O(1)",
                                " # </weight>"
                            ]
                        }
                    ],
                    "events": [
                        {
                            "name": "RecoveryCreated",
                            "args": [
                                "AccountId"
                            ],
                            "docs": [
                                " A recovery process has been set up for an account"
                            ]
                        },
                        {
                            "name": "RecoveryInitiated",
                            "args": [
                                "AccountId",
                                "AccountId"
                            ],
                            "docs": [
                                " A recovery process has been initiated for account_1 by account_2"
                            ]
                        },
                        {
                            "name": "RecoveryVouched",
                            "args": [
                                "AccountId",
                                "AccountId",
                                "AccountId"
                            ],
                            "docs": [
                                " A recovery process for account_1 by account_2 has been vouched for by account_3"
                            ]
                        },
                        {
                            "name": "RecoveryClosed",
                            "args": [
                                "AccountId",
                                "AccountId"
                            ],
                            "docs": [
                                " A recovery process for account_1 by account_2 has been closed"
                            ]
                        },
                        {
                            "name": "AccountRecovered",
                            "args": [
                                "AccountId",
                                "AccountId"
                            ],
                            "docs": [
                                " Account_1 has been successfully recovered by account_2"
                            ]
                        },
                        {
                            "name": "RecoveryRemoved",
                            "args": [
                                "AccountId"
                            ],
                            "docs": [
                                " A recovery process has been removed for an account"
                            ]
                        }
                    ],
                    "constants": [],
                    "errors": [
                        {
                            "name": "NotAllowed",
                            "docs": [
                                " User is not allowed to make a call on behalf of this account"
                            ]
                        },
                        {
                            "name": "ZeroThreshold",
                            "docs": [
                                " Threshold must be greater than zero"
                            ]
                        },
                        {
                            "name": "NotEnoughFriends",
                            "docs": [
                                " Friends list must be greater than zero and threshold"
                            ]
                        },
                        {
                            "name": "MaxFriends",
                            "docs": [
                                " Friends list must be less than max friends"
                            ]
                        },
                        {
                            "name": "NotSorted",
                            "docs": [
                                " Friends list must be sorted and free of duplicates"
                            ]
                        },
                        {
                            "name": "NotRecoverable",
                            "docs": [
                                " This account is not set up for recovery"
                            ]
                        },
                        {
                            "name": "AlreadyRecoverable",
                            "docs": [
                                " This account is already set up for recovery"
                            ]
                        },
                        {
                            "name": "AlreadyStarted",
                            "docs": [
                                " A recovery process has already started for this account"
                            ]
                        },
                        {
                            "name": "NotStarted",
                            "docs": [
                                " A recovery process has not started for this rescuer"
                            ]
                        },
                        {
                            "name": "NotFriend",
                            "docs": [
                                " This account is not a friend who can vouch"
                            ]
                        },
                        {
                            "name": "DelayPeriod",
                            "docs": [
                                " The friend must wait until the delay period to vouch for this recovery"
                            ]
                        },
                        {
                            "name": "AlreadyVouched",
                            "docs": [
                                " This user has already vouched for this recovery"
                            ]
                        },
                        {
                            "name": "Threshold",
                            "docs": [
                                " The threshold for recovering this account has not been met"
                            ]
                        },
                        {
                            "name": "StillActive",
                            "docs": [
                                " There are still active recovery attempts that need to be closed"
                            ]
                        },
                        {
                            "name": "Overflow",
                            "docs": [
                                " There was an overflow in a calculation"
                            ]
                        },
                        {
                            "name": "AlreadyProxy",
                            "docs": [
                                " This account is already set up for recovery"
                            ]
                        }
                    ]
                },
                {
                    "name": "Vesting",
                    "storage": {
                        "prefix": "Vesting",
                        "items": [
                            {
                                "name": "Vesting",
                                "modifier": "Optional",
                                "type": {
                                    "map": {
                                        "hasher": "Blake2_128Concat",
                                        "key": "AccountId",
                                        "value": "VestingInfo",
                                        "linked": false
                                    }
                                },
                                "fallback": "0x00",
                                "docs": [
                                    " Information regarding the vesting of a given account."
                                ]
                            }
                        ]
                    },
                    "calls": [
                        {
                            "name": "vest",
                            "args": [],
                            "docs": [
                                " 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",
                            "args": [
                                {
                                    "name": "target",
                                    "type": "LookupSource"
                                }
                            ],
                            "docs": [
                                " 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",
                            "args": [
                                {
                                    "name": "target",
                                    "type": "LookupSource"
                                },
                                {
                                    "name": "schedule",
                                    "type": "VestingInfo"
                                }
                            ],
                            "docs": [
                                " 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>"
                            ]
                        }
                    ],
                    "events": [
                        {
                            "name": "VestingUpdated",
                            "args": [
                                "AccountId",
                                "Balance"
                            ],
                            "docs": [
                                " 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",
                            "args": [
                                "AccountId"
                            ],
                            "docs": [
                                " An account (given) has become fully vested. No further vesting can happen."
                            ]
                        }
                    ],
                    "constants": [
                        {
                            "name": "MinVestedTransfer",
                            "type": "BalanceOf",
                            "value": "0x00407a10f35a00000000000000000000",
                            "docs": [
                                " The minimum amount to be transferred to create a new vesting schedule."
                            ]
                        }
                    ],
                    "errors": [
                        {
                            "name": "NotVesting",
                            "docs": [
                                " The account given is not vesting."
                            ]
                        },
                        {
                            "name": "ExistingVestingSchedule",
                            "docs": [
                                " An existing vesting schedule already exists for this account that cannot be clobbered."
                            ]
                        },
                        {
                            "name": "AmountLow",
                            "docs": [
                                " Amount being transferred is too low to create a vesting schedule."
                            ]
                        }
                    ]
                },
                {
                    "name": "Scheduler",
                    "storage": {
                        "prefix": "Scheduler",
                        "items": [
                            {
                                "name": "Agenda",
                                "modifier": "Default",
                                "type": {
                                    "map": {
                                        "hasher": "Twox64Concat",
                                        "key": "BlockNumber",
                                        "value": "Vec<Option<Scheduled>>",
                                        "linked": false
                                    }
                                },
                                "fallback": "0x00",
                                "docs": [
                                    " Items to be executed, indexed by the block number that they should be executed on."
                                ]
                            },
                            {
                                "name": "Lookup",
                                "modifier": "Optional",
                                "type": {
                                    "map": {
                                        "hasher": "Twox64Concat",
                                        "key": "Bytes",
                                        "value": "TaskAddress",
                                        "linked": false
                                    }
                                },
                                "fallback": "0x00",
                                "docs": [
                                    " Lookup from identity to the block number and index of the task."
                                ]
                            }
                        ]
                    },
                    "calls": [],
                    "events": [
                        {
                            "name": "Scheduled",
                            "args": [
                                "BlockNumber"
                            ],
                            "docs": []
                        },
                        {
                            "name": "Dispatched",
                            "args": [
                                "TaskAddress",
                                "Option<Bytes>",
                                "DispatchResult"
                            ],
                            "docs": []
                        }
                    ],
                    "constants": [],
                    "errors": []
                },
                {
                    "name": "Sudo",
                    "storage": {
                        "prefix": "Sudo",
                        "items": [
                            {
                                "name": "Key",
                                "modifier": "Default",
                                "type": {
                                    "plain": "AccountId"
                                },
                                "fallback": "0x0000000000000000000000000000000000000000000000000000000000000000",
                                "docs": [
                                    " The `AccountId` of the sudo key."
                                ]
                            }
                        ]
                    },
                    "calls": [
                        {
                            "name": "sudo",
                            "args": [
                                {
                                    "name": "call",
                                    "type": "Call"
                                }
                            ],
                            "docs": [
                                " Authenticates the sudo key and dispatches a function call with `Root` origin.",
                                "",
                                " The dispatch origin for this call must be _Signed_.",
                                "",
                                " # <weight>",
                                " - O(1).",
                                " - Limited storage reads.",
                                " - One DB write (event).",
                                " - Weight of derivative `call` execution + 10,000.",
                                " # </weight>"
                            ]
                        },
                        {
                            "name": "set_key",
                            "args": [
                                {
                                    "name": "new",
                                    "type": "LookupSource"
                                }
                            ],
                            "docs": [
                                " Authenticates the current sudo key and sets the given AccountId (`new`) as the new sudo key.",
                                "",
                                " The dispatch origin for this call must be _Signed_.",
                                "",
                                " # <weight>",
                                " - O(1).",
                                " - Limited storage reads.",
                                " - One DB change.",
                                " # </weight>"
                            ]
                        },
                        {
                            "name": "sudo_as",
                            "args": [
                                {
                                    "name": "who",
                                    "type": "LookupSource"
                                },
                                {
                                    "name": "call",
                                    "type": "Call"
                                }
                            ],
                            "docs": [
                                " Authenticates the sudo key and dispatches a function call with `Signed` origin from",
                                " a given account.",
                                "",
                                " The dispatch origin for this call must be _Signed_.",
                                "",
                                " # <weight>",
                                " - O(1).",
                                " - Limited storage reads.",
                                " - One DB write (event).",
                                " - Weight of derivative `call` execution + 10,000.",
                                " # </weight>"
                            ]
                        }
                    ],
                    "events": [
                        {
                            "name": "Sudid",
                            "args": [
                                "bool"
                            ],
                            "docs": [
                                " A sudo just took place."
                            ]
                        },
                        {
                            "name": "KeyChanged",
                            "args": [
                                "AccountId"
                            ],
                            "docs": [
                                " The sudoer just switched identity; the old key is supplied."
                            ]
                        },
                        {
                            "name": "SudoAsDone",
                            "args": [
                                "bool"
                            ],
                            "docs": [
                                " A sudo just took place."
                            ]
                        }
                    ],
                    "constants": [],
                    "errors": [
                        {
                            "name": "RequireSudo",
                            "docs": [
                                " Sender must be the Sudo account"
                            ]
                        }
                    ]
                }
            ],
            "extrinsic": {
                "version": "4",
                "signedExtensions": [
                    "RestrictFunctionality",
                    "CheckVersion",
                    "CheckGenesis",
                    "CheckEra",
                    "CheckNonce",
                    "CheckWeight",
                    "ChargeTransactionPayment",
                    "LimitParathreadCommits",
                    "ValidateDoubleVoteReports"
                ]
            }
        }
    }
}
