{
  "V13": {
    "modules": [
      {
        "name": "System",
        "storage": {
          "prefix": "System",
          "entries": [
            {
              "name": "Account",
              "modifier": "Default",
              "ty": {
                "Map": {
                  "hasher": "Blake2_128Concat",
                  "key": "T::AccountId",
                  "value": "AccountInfo<T::Index, T::AccountData>",
                  "unused": false
                }
              },
              "default": [
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0
              ],
              "documentation": [
                " The full account information for a particular account ID."
              ]
            },
            {
              "name": "ExtrinsicCount",
              "modifier": "Optional",
              "ty": {
                "Plain": "u32"
              },
              "default": [
                0
              ],
              "documentation": [
                " Total extrinsics count for the current block."
              ]
            },
            {
              "name": "BlockWeight",
              "modifier": "Default",
              "ty": {
                "Plain": "ConsumedWeight"
              },
              "default": [
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0
              ],
              "documentation": [
                " The current weight for the block."
              ]
            },
            {
              "name": "AllExtrinsicsLen",
              "modifier": "Optional",
              "ty": {
                "Plain": "u32"
              },
              "default": [
                0
              ],
              "documentation": [
                " Total length (in bytes) for all extrinsics put together, for the current block."
              ]
            },
            {
              "name": "BlockHash",
              "modifier": "Default",
              "ty": {
                "Map": {
                  "hasher": "Twox64Concat",
                  "key": "T::BlockNumber",
                  "value": "T::Hash",
                  "unused": false
                }
              },
              "default": [
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0
              ],
              "documentation": [
                " Map of block numbers to block hashes."
              ]
            },
            {
              "name": "ExtrinsicData",
              "modifier": "Default",
              "ty": {
                "Map": {
                  "hasher": "Twox64Concat",
                  "key": "u32",
                  "value": "Vec<u8>",
                  "unused": false
                }
              },
              "default": [
                0
              ],
              "documentation": [
                " Extrinsics data for the current block (maps an extrinsic's index to its data)."
              ]
            },
            {
              "name": "Number",
              "modifier": "Default",
              "ty": {
                "Plain": "T::BlockNumber"
              },
              "default": [
                0,
                0,
                0,
                0
              ],
              "documentation": [
                " The current block number being processed. Set by `execute_block`."
              ]
            },
            {
              "name": "ParentHash",
              "modifier": "Default",
              "ty": {
                "Plain": "T::Hash"
              },
              "default": [
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0
              ],
              "documentation": [
                " Hash of the previous block."
              ]
            },
            {
              "name": "Digest",
              "modifier": "Default",
              "ty": {
                "Plain": "DigestOf<T>"
              },
              "default": [
                0
              ],
              "documentation": [
                " Digest of the current block, also part of the block header."
              ]
            },
            {
              "name": "Events",
              "modifier": "Default",
              "ty": {
                "Plain": "Vec<EventRecord<T::Event, T::Hash>>"
              },
              "default": [
                0
              ],
              "documentation": [
                " Events deposited for the current block."
              ]
            },
            {
              "name": "EventCount",
              "modifier": "Default",
              "ty": {
                "Plain": "EventIndex"
              },
              "default": [
                0,
                0,
                0,
                0
              ],
              "documentation": [
                " The number of events in the `Events<T>` list."
              ]
            },
            {
              "name": "EventTopics",
              "modifier": "Default",
              "ty": {
                "Map": {
                  "hasher": "Blake2_128Concat",
                  "key": "T::Hash",
                  "value": "Vec<(T::BlockNumber, EventIndex)>",
                  "unused": false
                }
              },
              "default": [
                0
              ],
              "documentation": [
                " Mapping between a topic (represented by T::Hash) and a vector of indexes",
                " of events in the `<Events<T>>` list.",
                "",
                " All topic vectors have deterministic storage locations depending on the topic. This",
                " allows light-clients to leverage the changes trie storage tracking mechanism and",
                " in case of changes fetch the list of events of interest.",
                "",
                " The value has the type `(T::BlockNumber, EventIndex)` because if we used only just",
                " the `EventIndex` then in case if the topic has the same contents on the next block",
                " no notification will be triggered thus the event might be lost."
              ]
            },
            {
              "name": "LastRuntimeUpgrade",
              "modifier": "Optional",
              "ty": {
                "Plain": "LastRuntimeUpgradeInfo"
              },
              "default": [
                0
              ],
              "documentation": [
                " Stores the `spec_version` and `spec_name` of when the last runtime upgrade happened."
              ]
            },
            {
              "name": "UpgradedToU32RefCount",
              "modifier": "Default",
              "ty": {
                "Plain": "bool"
              },
              "default": [
                0
              ],
              "documentation": [
                " True if we have upgraded so that `type RefCount` is `u32`. False (default) if not."
              ]
            },
            {
              "name": "UpgradedToTripleRefCount",
              "modifier": "Default",
              "ty": {
                "Plain": "bool"
              },
              "default": [
                0
              ],
              "documentation": [
                " True if we have upgraded so that AccountInfo contains three types of `RefCount`. False",
                " (default) if not."
              ]
            },
            {
              "name": "ExecutionPhase",
              "modifier": "Optional",
              "ty": {
                "Plain": "Phase"
              },
              "default": [
                0
              ],
              "documentation": [
                " The execution phase of the block."
              ]
            }
          ]
        },
        "calls": [
          {
            "name": "fill_block",
            "arguments": [
              {
                "name": "_ratio",
                "ty": "Perbill"
              }
            ],
            "documentation": [
              " A dispatch that will fill the block weight up to the given ratio."
            ]
          },
          {
            "name": "remark",
            "arguments": [
              {
                "name": "_remark",
                "ty": "Vec<u8>"
              }
            ],
            "documentation": [
              " Make some on-chain remark.",
              "",
              " # <weight>",
              " - `O(1)`",
              " # </weight>"
            ]
          },
          {
            "name": "set_heap_pages",
            "arguments": [
              {
                "name": "pages",
                "ty": "u64"
              }
            ],
            "documentation": [
              " Set the number of pages in the WebAssembly environment's heap.",
              "",
              " # <weight>",
              " - `O(1)`",
              " - 1 storage write.",
              " - Base Weight: 1.405 µs",
              " - 1 write to HEAP_PAGES",
              " # </weight>"
            ]
          },
          {
            "name": "set_code",
            "arguments": [
              {
                "name": "code",
                "ty": "Vec<u8>"
              }
            ],
            "documentation": [
              " Set the new runtime code.",
              "",
              " # <weight>",
              " - `O(C + S)` where `C` length of `code` and `S` complexity of `can_set_code`",
              " - 1 storage write (codec `O(C)`).",
              " - 1 call to `can_set_code`: `O(S)` (calls `sp_io::misc::runtime_version` which is expensive).",
              " - 1 event.",
              " The weight of this function is dependent on the runtime, but generally this is very expensive.",
              " We will treat this as a full block.",
              " # </weight>"
            ]
          },
          {
            "name": "set_code_without_checks",
            "arguments": [
              {
                "name": "code",
                "ty": "Vec<u8>"
              }
            ],
            "documentation": [
              " Set the new runtime code without doing any checks of the given `code`.",
              "",
              " # <weight>",
              " - `O(C)` where `C` length of `code`",
              " - 1 storage write (codec `O(C)`).",
              " - 1 event.",
              " The weight of this function is dependent on the runtime. We will treat this as a full block.",
              " # </weight>"
            ]
          },
          {
            "name": "set_changes_trie_config",
            "arguments": [
              {
                "name": "changes_trie_config",
                "ty": "Option<ChangesTrieConfiguration>"
              }
            ],
            "documentation": [
              " Set the new changes trie configuration.",
              "",
              " # <weight>",
              " - `O(1)`",
              " - 1 storage write or delete (codec `O(1)`).",
              " - 1 call to `deposit_log`: Uses `append` API, so O(1)",
              " - Base Weight: 7.218 µs",
              " - DB Weight:",
              "     - Writes: Changes Trie, System Digest",
              " # </weight>"
            ]
          },
          {
            "name": "set_storage",
            "arguments": [
              {
                "name": "items",
                "ty": "Vec<KeyValue>"
              }
            ],
            "documentation": [
              " Set some items of storage.",
              "",
              " # <weight>",
              " - `O(I)` where `I` length of `items`",
              " - `I` storage writes (`O(1)`).",
              " - Base Weight: 0.568 * i µs",
              " - Writes: Number of items",
              " # </weight>"
            ]
          },
          {
            "name": "kill_storage",
            "arguments": [
              {
                "name": "keys",
                "ty": "Vec<Key>"
              }
            ],
            "documentation": [
              " Kill some items from storage.",
              "",
              " # <weight>",
              " - `O(IK)` where `I` length of `keys` and `K` length of one key",
              " - `I` storage deletions.",
              " - Base Weight: .378 * i µs",
              " - Writes: Number of items",
              " # </weight>"
            ]
          },
          {
            "name": "kill_prefix",
            "arguments": [
              {
                "name": "prefix",
                "ty": "Key"
              },
              {
                "name": "_subkeys",
                "ty": "u32"
              }
            ],
            "documentation": [
              " Kill all storage items with a key that starts with the given prefix.",
              "",
              " **NOTE:** We rely on the Root origin to provide us the number of subkeys under",
              " the prefix we are removing to accurately calculate the weight of this function.",
              "",
              " # <weight>",
              " - `O(P)` where `P` amount of keys with prefix `prefix`",
              " - `P` storage deletions.",
              " - Base Weight: 0.834 * P µs",
              " - Writes: Number of subkeys + 1",
              " # </weight>"
            ]
          },
          {
            "name": "remark_with_event",
            "arguments": [
              {
                "name": "remark",
                "ty": "Vec<u8>"
              }
            ],
            "documentation": [
              " Make some on-chain remark and emit event.",
              "",
              " # <weight>",
              " - `O(b)` where b is the length of the remark.",
              " - 1 event.",
              " # </weight>"
            ]
          }
        ],
        "event": [
          {
            "name": "ExtrinsicSuccess",
            "arguments": [
              "DispatchInfo"
            ],
            "documentation": [
              " An extrinsic completed successfully. \\[info\\]"
            ]
          },
          {
            "name": "ExtrinsicFailed",
            "arguments": [
              "DispatchError",
              "DispatchInfo"
            ],
            "documentation": [
              " An extrinsic failed. \\[error, info\\]"
            ]
          },
          {
            "name": "CodeUpdated",
            "arguments": [],
            "documentation": [
              " `:code` was updated."
            ]
          },
          {
            "name": "NewAccount",
            "arguments": [
              "AccountId"
            ],
            "documentation": [
              " A new \\[account\\] was created."
            ]
          },
          {
            "name": "KilledAccount",
            "arguments": [
              "AccountId"
            ],
            "documentation": [
              " An \\[account\\] was reaped."
            ]
          },
          {
            "name": "Remarked",
            "arguments": [
              "AccountId",
              "Hash"
            ],
            "documentation": [
              " On on-chain remark happened. \\[origin, remark_hash\\]"
            ]
          }
        ],
        "constants": [
          {
            "name": "BlockWeights",
            "ty": "limits::BlockWeights",
            "value": [
              0,
              242,
              5,
              42,
              1,
              0,
              0,
              0,
              0,
              32,
              74,
              169,
              209,
              1,
              0,
              0,
              64,
              89,
              115,
              7,
              0,
              0,
              0,
              0,
              1,
              192,
              110,
              150,
              166,
              46,
              1,
              0,
              0,
              1,
              0,
              152,
              247,
              62,
              93,
              1,
              0,
              0,
              1,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              64,
              89,
              115,
              7,
              0,
              0,
              0,
              0,
              1,
              192,
              246,
              232,
              16,
              163,
              1,
              0,
              0,
              1,
              0,
              32,
              74,
              169,
              209,
              1,
              0,
              0,
              1,
              0,
              136,
              82,
              106,
              116,
              0,
              0,
              0,
              64,
              89,
              115,
              7,
              0,
              0,
              0,
              0,
              0,
              0,
              0
            ],
            "documentation": [
              " Block & extrinsics weights: base values and limits."
            ]
          },
          {
            "name": "BlockLength",
            "ty": "limits::BlockLength",
            "value": [
              0,
              0,
              60,
              0,
              0,
              0,
              80,
              0,
              0,
              0,
              80,
              0
            ],
            "documentation": [
              " The maximum length of a block (in bytes)."
            ]
          },
          {
            "name": "BlockHashCount",
            "ty": "T::BlockNumber",
            "value": [
              96,
              9,
              0,
              0
            ],
            "documentation": [
              " Maximum number of block number to block hash mappings to keep (oldest pruned first)."
            ]
          },
          {
            "name": "DbWeight",
            "ty": "RuntimeDbWeight",
            "value": [
              64,
              120,
              125,
              1,
              0,
              0,
              0,
              0,
              0,
              225,
              245,
              5,
              0,
              0,
              0,
              0
            ],
            "documentation": [
              " The weight of runtime database operations the runtime can invoke."
            ]
          },
          {
            "name": "Version",
            "ty": "RuntimeVersion",
            "value": [
              52,
              110,
              111,
              100,
              101,
              45,
              116,
              101,
              109,
              112,
              108,
              97,
              116,
              101,
              52,
              110,
              111,
              100,
              101,
              45,
              116,
              101,
              109,
              112,
              108,
              97,
              116,
              101,
              1,
              0,
              0,
              0,
              100,
              0,
              0,
              0,
              1,
              0,
              0,
              0,
              40,
              223,
              106,
              203,
              104,
              153,
              7,
              96,
              155,
              3,
              0,
              0,
              0,
              55,
              227,
              151,
              252,
              124,
              145,
              245,
              228,
              1,
              0,
              0,
              0,
              64,
              254,
              58,
              212,
              1,
              248,
              149,
              154,
              5,
              0,
              0,
              0,
              210,
              188,
              152,
              151,
              238,
              208,
              143,
              21,
              2,
              0,
              0,
              0,
              247,
              139,
              39,
              139,
              229,
              63,
              69,
              76,
              2,
              0,
              0,
              0,
              221,
              113,
              141,
              92,
              197,
              50,
              98,
              212,
              1,
              0,
              0,
              0,
              171,
              60,
              5,
              114,
              41,
              31,
              235,
              139,
              1,
              0,
              0,
              0,
              237,
              153,
              197,
              172,
              178,
              94,
              237,
              245,
              2,
              0,
              0,
              0,
              188,
              157,
              137,
              144,
              79,
              91,
              146,
              63,
              1,
              0,
              0,
              0,
              55,
              200,
              187,
              19,
              80,
              169,
              162,
              168,
              1,
              0,
              0,
              0,
              1,
              0,
              0,
              0
            ],
            "documentation": [
              " Get the chain's current version."
            ]
          },
          {
            "name": "SS58Prefix",
            "ty": "u8",
            "value": [
              42
            ],
            "documentation": [
              " The designated SS85 prefix of this chain.",
              "",
              " This replaces the \"ss58Format\" property declared in the chain spec. Reason is",
              " that the runtime should know about the prefix in order to make use of it as",
              " an identifier of the chain."
            ]
          }
        ],
        "errors": [
          {
            "name": "InvalidSpecName",
            "documentation": [
              " The name of specification does not match between the current runtime",
              " and the new runtime."
            ]
          },
          {
            "name": "SpecVersionNeedsToIncrease",
            "documentation": [
              " The specification version is not allowed to decrease between the current runtime",
              " and the new runtime."
            ]
          },
          {
            "name": "FailedToExtractRuntimeVersion",
            "documentation": [
              " Failed to extract the runtime version from the new runtime.",
              "",
              " Either calling `Core_version` or decoding `RuntimeVersion` failed."
            ]
          },
          {
            "name": "NonDefaultComposite",
            "documentation": [
              " Suicide called when the account has non-default composite data."
            ]
          },
          {
            "name": "NonZeroRefCount",
            "documentation": [
              " There is a non-zero reference count preventing the account from being purged."
            ]
          }
        ],
        "index": 0
      },
      {
        "name": "RandomnessCollectiveFlip",
        "storage": {
          "prefix": "RandomnessCollectiveFlip",
          "entries": [
            {
              "name": "RandomMaterial",
              "modifier": "Default",
              "ty": {
                "Plain": "Vec<T::Hash>"
              },
              "default": [
                0
              ],
              "documentation": [
                " Series of block headers from the last 81 blocks that acts as random seed material. This",
                " is arranged as a ring buffer with `block_number % 81` being the index into the `Vec` of",
                " the oldest hash."
              ]
            }
          ]
        },
        "calls": [],
        "event": null,
        "constants": [],
        "errors": [],
        "index": 1
      },
      {
        "name": "Timestamp",
        "storage": {
          "prefix": "Timestamp",
          "entries": [
            {
              "name": "Now",
              "modifier": "Default",
              "ty": {
                "Plain": "T::Moment"
              },
              "default": [
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0
              ],
              "documentation": [
                " Current time for the current block."
              ]
            },
            {
              "name": "DidUpdate",
              "modifier": "Default",
              "ty": {
                "Plain": "bool"
              },
              "default": [
                0
              ],
              "documentation": [
                " Did the timestamp get updated in this block?"
              ]
            }
          ]
        },
        "calls": [
          {
            "name": "set",
            "arguments": [
              {
                "name": "now",
                "ty": "Compact<T::Moment>"
              }
            ],
            "documentation": [
              " Set the current time.",
              "",
              " This call should be invoked exactly once per block. It will panic at the finalization",
              " phase, if this call hasn't been invoked by that time.",
              "",
              " The timestamp should be greater than the previous one by the amount specified by",
              " `MinimumPeriod`.",
              "",
              " The dispatch origin for this call must be `Inherent`.",
              "",
              " # <weight>",
              " - `O(1)` (Note that implementations of `OnTimestampSet` must also be `O(1)`)",
              " - 1 storage read and 1 storage mutation (codec `O(1)`). (because of `DidUpdate::take` in `on_finalize`)",
              " - 1 event handler `on_timestamp_set`. Must be `O(1)`.",
              " # </weight>"
            ]
          }
        ],
        "event": null,
        "constants": [
          {
            "name": "MinimumPeriod",
            "ty": "T::Moment",
            "value": [
              184,
              11,
              0,
              0,
              0,
              0,
              0,
              0
            ],
            "documentation": [
              " The minimum period between blocks. Beware that this is different to the *expected* period",
              " that the block production apparatus provides. Your chosen consensus system will generally",
              " work with this to determine a sensible block time. e.g. For Aura, it will be double this",
              " period on default settings."
            ]
          }
        ],
        "errors": [],
        "index": 2
      },
      {
        "name": "Aura",
        "storage": null,
        "calls": null,
        "event": null,
        "constants": [],
        "errors": [],
        "index": 3
      },
      {
        "name": "Grandpa",
        "storage": {
          "prefix": "GrandpaFinality",
          "entries": [
            {
              "name": "State",
              "modifier": "Default",
              "ty": {
                "Plain": "StoredState<T::BlockNumber>"
              },
              "default": [
                0
              ],
              "documentation": [
                " State of the current authority set."
              ]
            },
            {
              "name": "PendingChange",
              "modifier": "Optional",
              "ty": {
                "Plain": "StoredPendingChange<T::BlockNumber>"
              },
              "default": [
                0
              ],
              "documentation": [
                " Pending change: (signaled at, scheduled change)."
              ]
            },
            {
              "name": "NextForced",
              "modifier": "Optional",
              "ty": {
                "Plain": "T::BlockNumber"
              },
              "default": [
                0
              ],
              "documentation": [
                " next block number where we can force a change."
              ]
            },
            {
              "name": "Stalled",
              "modifier": "Optional",
              "ty": {
                "Plain": "(T::BlockNumber, T::BlockNumber)"
              },
              "default": [
                0
              ],
              "documentation": [
                " `true` if we are currently stalled."
              ]
            },
            {
              "name": "CurrentSetId",
              "modifier": "Default",
              "ty": {
                "Plain": "SetId"
              },
              "default": [
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0
              ],
              "documentation": [
                " The number of changes (both in terms of keys and underlying economic responsibilities)",
                " in the \"set\" of Grandpa validators from genesis."
              ]
            },
            {
              "name": "SetIdSession",
              "modifier": "Optional",
              "ty": {
                "Map": {
                  "hasher": "Twox64Concat",
                  "key": "SetId",
                  "value": "SessionIndex",
                  "unused": false
                }
              },
              "default": [
                0
              ],
              "documentation": [
                " A mapping from grandpa set ID to the index of the *most recent* session for which its",
                " members were responsible.",
                "",
                " TWOX-NOTE: `SetId` is not under user control."
              ]
            }
          ]
        },
        "calls": [
          {
            "name": "report_equivocation",
            "arguments": [
              {
                "name": "equivocation_proof",
                "ty": "EquivocationProof<T::Hash, T::BlockNumber>"
              },
              {
                "name": "key_owner_proof",
                "ty": "T::KeyOwnerProof"
              }
            ],
            "documentation": [
              " Report voter equivocation/misbehavior. This method will verify the",
              " equivocation proof and validate the given key ownership proof",
              " against the extracted offender. If both are valid, the offence",
              " will be reported."
            ]
          },
          {
            "name": "report_equivocation_unsigned",
            "arguments": [
              {
                "name": "equivocation_proof",
                "ty": "EquivocationProof<T::Hash, T::BlockNumber>"
              },
              {
                "name": "key_owner_proof",
                "ty": "T::KeyOwnerProof"
              }
            ],
            "documentation": [
              " Report voter equivocation/misbehavior. This method will verify the",
              " equivocation proof and validate the given key ownership proof",
              " against the extracted offender. If both are valid, the offence",
              " will be reported.",
              "",
              " This extrinsic must be called unsigned and it is expected that only",
              " block authors will call it (validated in `ValidateUnsigned`), as such",
              " if the block author is defined it will be defined as the equivocation",
              " reporter."
            ]
          },
          {
            "name": "note_stalled",
            "arguments": [
              {
                "name": "delay",
                "ty": "T::BlockNumber"
              },
              {
                "name": "best_finalized_block_number",
                "ty": "T::BlockNumber"
              }
            ],
            "documentation": [
              " Note that the current authority set of the GRANDPA finality gadget has",
              " stalled. This will trigger a forced authority set change at the beginning",
              " of the next session, to be enacted `delay` blocks after that. The delay",
              " should be high enough to safely assume that the block signalling the",
              " forced change will not be re-orged (e.g. 1000 blocks). The GRANDPA voters",
              " will start the new authority set using the given finalized block as base.",
              " Only callable by root."
            ]
          }
        ],
        "event": [
          {
            "name": "NewAuthorities",
            "arguments": [
              "AuthorityList"
            ],
            "documentation": [
              " New authority set has been applied. \\[authority_set\\]"
            ]
          },
          {
            "name": "Paused",
            "arguments": [],
            "documentation": [
              " Current authority set has been paused."
            ]
          },
          {
            "name": "Resumed",
            "arguments": [],
            "documentation": [
              " Current authority set has been resumed."
            ]
          }
        ],
        "constants": [],
        "errors": [
          {
            "name": "PauseFailed",
            "documentation": [
              " Attempt to signal GRANDPA pause when the authority set isn't live",
              " (either paused or already pending pause)."
            ]
          },
          {
            "name": "ResumeFailed",
            "documentation": [
              " Attempt to signal GRANDPA resume when the authority set isn't paused",
              " (either live or already pending resume)."
            ]
          },
          {
            "name": "ChangePending",
            "documentation": [
              " Attempt to signal GRANDPA change with one already pending."
            ]
          },
          {
            "name": "TooSoon",
            "documentation": [
              " Cannot signal forced change so soon after last."
            ]
          },
          {
            "name": "InvalidKeyOwnershipProof",
            "documentation": [
              " A key ownership proof provided as part of an equivocation report is invalid."
            ]
          },
          {
            "name": "InvalidEquivocationProof",
            "documentation": [
              " An equivocation proof provided as part of an equivocation report is invalid."
            ]
          },
          {
            "name": "DuplicateOffenceReport",
            "documentation": [
              " A given equivocation report is valid but already previously reported."
            ]
          }
        ],
        "index": 4
      },
      {
        "name": "Balances",
        "storage": {
          "prefix": "Balances",
          "entries": [
            {
              "name": "TotalIssuance",
              "modifier": "Default",
              "ty": {
                "Plain": "T::Balance"
              },
              "default": [
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0
              ],
              "documentation": [
                " The total units issued in the system."
              ]
            },
            {
              "name": "Account",
              "modifier": "Default",
              "ty": {
                "Map": {
                  "hasher": "Blake2_128Concat",
                  "key": "T::AccountId",
                  "value": "AccountData<T::Balance>",
                  "unused": false
                }
              },
              "default": [
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0
              ],
              "documentation": [
                " The balance of an account.",
                "",
                " NOTE: This is only used in the case that this pallet is used to store balances."
              ]
            },
            {
              "name": "Locks",
              "modifier": "Default",
              "ty": {
                "Map": {
                  "hasher": "Blake2_128Concat",
                  "key": "T::AccountId",
                  "value": "Vec<BalanceLock<T::Balance>>",
                  "unused": false
                }
              },
              "default": [
                0
              ],
              "documentation": [
                " Any liquidity locks on some account balances.",
                " NOTE: Should only be accessed when setting, changing and freeing a lock."
              ]
            },
            {
              "name": "StorageVersion",
              "modifier": "Default",
              "ty": {
                "Plain": "Releases"
              },
              "default": [
                0
              ],
              "documentation": [
                " Storage version of the pallet.",
                "",
                " This is set to v2.0.0 for new networks."
              ]
            }
          ]
        },
        "calls": [
          {
            "name": "transfer",
            "arguments": [
              {
                "name": "dest",
                "ty": "<T::Lookup as StaticLookup>::Source"
              },
              {
                "name": "value",
                "ty": "Compact<T::Balance>"
              }
            ],
            "documentation": [
              " Transfer some liquid free balance to another account.",
              "",
              " `transfer` will set the `FreeBalance` of the sender and receiver.",
              " It will decrease the total issuance of the system by the `TransferFee`.",
              " If the sender's account is below the existential deposit as a result",
              " of the transfer, the account will be reaped.",
              "",
              " The dispatch origin for this call must be `Signed` by the transactor.",
              "",
              " # <weight>",
              " - Dependent on arguments but not critical, given proper implementations for",
              "   input config types. See related functions below.",
              " - It contains a limited number of reads and writes internally and no complex computation.",
              "",
              " Related functions:",
              "",
              "   - `ensure_can_withdraw` is always called internally but has a bounded complexity.",
              "   - Transferring balances to accounts that did not exist before will cause",
              "      `T::OnNewAccount::on_new_account` to be called.",
              "   - Removing enough funds from an account will trigger `T::DustRemoval::on_unbalanced`.",
              "   - `transfer_keep_alive` works the same way as `transfer`, but has an additional",
              "     check that the transfer will not kill the origin account.",
              " ---------------------------------",
              " - Base Weight: 73.64 µs, worst case scenario (account created, account removed)",
              " - DB Weight: 1 Read and 1 Write to destination account",
              " - Origin account is already in memory, so no DB operations for them.",
              " # </weight>"
            ]
          },
          {
            "name": "set_balance",
            "arguments": [
              {
                "name": "who",
                "ty": "<T::Lookup as StaticLookup>::Source"
              },
              {
                "name": "new_free",
                "ty": "Compact<T::Balance>"
              },
              {
                "name": "new_reserved",
                "ty": "Compact<T::Balance>"
              }
            ],
            "documentation": [
              " Set the balances of a given account.",
              "",
              " This will alter `FreeBalance` and `ReservedBalance` in storage. it will",
              " also decrease the total issuance of the system (`TotalIssuance`).",
              " If the new free or reserved balance is below the existential deposit,",
              " it will reset the account nonce (`frame_system::AccountNonce`).",
              "",
              " The dispatch origin for this call is `root`.",
              "",
              " # <weight>",
              " - Independent of the arguments.",
              " - Contains a limited number of reads and writes.",
              " ---------------------",
              " - Base Weight:",
              "     - Creating: 27.56 µs",
              "     - Killing: 35.11 µs",
              " - DB Weight: 1 Read, 1 Write to `who`",
              " # </weight>"
            ]
          },
          {
            "name": "force_transfer",
            "arguments": [
              {
                "name": "source",
                "ty": "<T::Lookup as StaticLookup>::Source"
              },
              {
                "name": "dest",
                "ty": "<T::Lookup as StaticLookup>::Source"
              },
              {
                "name": "value",
                "ty": "Compact<T::Balance>"
              }
            ],
            "documentation": [
              " Exactly as `transfer`, except the origin must be root and the source account may be",
              " specified.",
              " # <weight>",
              " - Same as transfer, but additional read and write because the source account is",
              "   not assumed to be in the overlay.",
              " # </weight>"
            ]
          },
          {
            "name": "transfer_keep_alive",
            "arguments": [
              {
                "name": "dest",
                "ty": "<T::Lookup as StaticLookup>::Source"
              },
              {
                "name": "value",
                "ty": "Compact<T::Balance>"
              }
            ],
            "documentation": [
              " Same as the [`transfer`] call, but with a check that the transfer will not kill the",
              " origin account.",
              "",
              " 99% of the time you want [`transfer`] instead.",
              "",
              " [`transfer`]: struct.Pallet.html#method.transfer",
              " # <weight>",
              " - Cheaper than transfer because account cannot be killed.",
              " - Base Weight: 51.4 µs",
              " - DB Weight: 1 Read and 1 Write to dest (sender is in overlay already)",
              " #</weight>"
            ]
          }
        ],
        "event": [
          {
            "name": "Endowed",
            "arguments": [
              "AccountId",
              "Balance"
            ],
            "documentation": [
              " An account was created with some free balance. \\[account, free_balance\\]"
            ]
          },
          {
            "name": "DustLost",
            "arguments": [
              "AccountId",
              "Balance"
            ],
            "documentation": [
              " An account was removed whose balance was non-zero but below ExistentialDeposit,",
              " resulting in an outright loss. \\[account, balance\\]"
            ]
          },
          {
            "name": "Transfer",
            "arguments": [
              "AccountId",
              "AccountId",
              "Balance"
            ],
            "documentation": [
              " Transfer succeeded. \\[from, to, value\\]"
            ]
          },
          {
            "name": "BalanceSet",
            "arguments": [
              "AccountId",
              "Balance",
              "Balance"
            ],
            "documentation": [
              " A balance was set by root. \\[who, free, reserved\\]"
            ]
          },
          {
            "name": "Deposit",
            "arguments": [
              "AccountId",
              "Balance"
            ],
            "documentation": [
              " Some amount was deposited (e.g. for transaction fees). \\[who, deposit\\]"
            ]
          },
          {
            "name": "Reserved",
            "arguments": [
              "AccountId",
              "Balance"
            ],
            "documentation": [
              " Some balance was reserved (moved from free to reserved). \\[who, value\\]"
            ]
          },
          {
            "name": "Unreserved",
            "arguments": [
              "AccountId",
              "Balance"
            ],
            "documentation": [
              " Some balance was unreserved (moved from reserved to free). \\[who, value\\]"
            ]
          },
          {
            "name": "ReserveRepatriated",
            "arguments": [
              "AccountId",
              "AccountId",
              "Balance",
              "Status"
            ],
            "documentation": [
              " Some balance was moved from the reserve of the first account to the second account.",
              " Final argument indicates the destination balance type.",
              " \\[from, to, balance, destination_status\\]"
            ]
          }
        ],
        "constants": [
          {
            "name": "ExistentialDeposit",
            "ty": "T::Balance",
            "value": [
              244,
              1,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0
            ],
            "documentation": [
              " The minimum amount required to keep an account open."
            ]
          }
        ],
        "errors": [
          {
            "name": "VestingBalance",
            "documentation": [
              " Vesting balance too high to send value"
            ]
          },
          {
            "name": "LiquidityRestrictions",
            "documentation": [
              " Account liquidity restrictions prevent withdrawal"
            ]
          },
          {
            "name": "InsufficientBalance",
            "documentation": [
              " Balance too low to send value"
            ]
          },
          {
            "name": "ExistentialDeposit",
            "documentation": [
              " Value too low to create account due to existential deposit"
            ]
          },
          {
            "name": "KeepAlive",
            "documentation": [
              " Transfer/payment would kill account"
            ]
          },
          {
            "name": "ExistingVestingSchedule",
            "documentation": [
              " A vesting schedule already exists for this account"
            ]
          },
          {
            "name": "DeadAccount",
            "documentation": [
              " Beneficiary account must pre-exist"
            ]
          }
        ],
        "index": 5
      },
      {
        "name": "TransactionPayment",
        "storage": {
          "prefix": "TransactionPayment",
          "entries": [
            {
              "name": "NextFeeMultiplier",
              "modifier": "Default",
              "ty": {
                "Plain": "Multiplier"
              },
              "default": [
                0,
                0,
                100,
                167,
                179,
                182,
                224,
                13,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0
              ],
              "documentation": []
            },
            {
              "name": "StorageVersion",
              "modifier": "Default",
              "ty": {
                "Plain": "Releases"
              },
              "default": [
                0
              ],
              "documentation": []
            }
          ]
        },
        "calls": null,
        "event": null,
        "constants": [
          {
            "name": "TransactionByteFee",
            "ty": "BalanceOf<T>",
            "value": [
              1,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0
            ],
            "documentation": [
              " The fee to be paid for making a transaction; the per-byte portion."
            ]
          },
          {
            "name": "WeightToFee",
            "ty": "Vec<WeightToFeeCoefficient<BalanceOf<T>>>",
            "value": [
              4,
              1,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              1
            ],
            "documentation": [
              " The polynomial that is applied in order to derive fee from weight."
            ]
          }
        ],
        "errors": [],
        "index": 6
      },
      {
        "name": "Sudo",
        "storage": {
          "prefix": "Sudo",
          "entries": [
            {
              "name": "Key",
              "modifier": "Default",
              "ty": {
                "Plain": "T::AccountId"
              },
              "default": [
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0
              ],
              "documentation": [
                " The `AccountId` of the sudo key."
              ]
            }
          ]
        },
        "calls": [
          {
            "name": "sudo",
            "arguments": [
              {
                "name": "call",
                "ty": "Box<<T as Config>::Call>"
              }
            ],
            "documentation": [
              " 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": "sudo_unchecked_weight",
            "arguments": [
              {
                "name": "call",
                "ty": "Box<<T as Config>::Call>"
              },
              {
                "name": "_weight",
                "ty": "Weight"
              }
            ],
            "documentation": [
              " Authenticates the sudo key and dispatches a function call with `Root` origin.",
              " This function does not check the weight of the call, and instead allows the",
              " Sudo user to specify the weight of the call.",
              "",
              " The dispatch origin for this call must be _Signed_.",
              "",
              " # <weight>",
              " - O(1).",
              " - The weight of this call is defined by the caller.",
              " # </weight>"
            ]
          },
          {
            "name": "set_key",
            "arguments": [
              {
                "name": "new",
                "ty": "<T::Lookup as StaticLookup>::Source"
              }
            ],
            "documentation": [
              " 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",
            "arguments": [
              {
                "name": "who",
                "ty": "<T::Lookup as StaticLookup>::Source"
              },
              {
                "name": "call",
                "ty": "Box<<T as Config>::Call>"
              }
            ],
            "documentation": [
              " 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>"
            ]
          }
        ],
        "event": [
          {
            "name": "Sudid",
            "arguments": [
              "DispatchResult"
            ],
            "documentation": [
              " A sudo just took place. \\[result\\]"
            ]
          },
          {
            "name": "KeyChanged",
            "arguments": [
              "AccountId"
            ],
            "documentation": [
              " The \\[sudoer\\] just switched identity; the old key is supplied."
            ]
          },
          {
            "name": "SudoAsDone",
            "arguments": [
              "DispatchResult"
            ],
            "documentation": [
              " A sudo just took place. \\[result\\]"
            ]
          }
        ],
        "constants": [],
        "errors": [
          {
            "name": "RequireSudo",
            "documentation": [
              " Sender must be the Sudo account"
            ]
          }
        ],
        "index": 7
      },
      {
        "name": "TemplateModule",
        "storage": {
          "prefix": "TemplateModule",
          "entries": [
            {
              "name": "Something",
              "modifier": "Optional",
              "ty": {
                "Plain": "u32"
              },
              "default": [
                0
              ],
              "documentation": []
            }
          ]
        },
        "calls": [
          {
            "name": "do_something",
            "arguments": [
              {
                "name": "something",
                "ty": "u32"
              }
            ],
            "documentation": [
              " An example dispatchable that takes a singles value as a parameter, writes the value to",
              " storage and emits an event. This function must be dispatched by a signed extrinsic."
            ]
          },
          {
            "name": "cause_error",
            "arguments": [],
            "documentation": [
              " An example dispatchable that may throw a custom error."
            ]
          }
        ],
        "event": [
          {
            "name": "SomethingStored",
            "arguments": [
              "u32",
              "AccountId"
            ],
            "documentation": [
              " Event documentation should end with an array that provides descriptive names for event",
              " parameters. [something, who]"
            ]
          }
        ],
        "constants": [],
        "errors": [
          {
            "name": "NoneValue",
            "documentation": [
              " Error names should be descriptive."
            ]
          },
          {
            "name": "StorageOverflow",
            "documentation": [
              " Errors should have helpful documentation associated with them."
            ]
          }
        ],
        "index": 8
      }
    ],
    "extrinsic": {
      "version": 4,
      "signed_extensions": [
        "CheckSpecVersion",
        "CheckTxVersion",
        "CheckGenesis",
        "CheckMortality",
        "CheckNonce",
        "CheckWeight",
        "ChargeTransactionPayment"
      ]
    }
  }
}