RuntimeMetadataPrefixed(
    1635018093,
    V2(
        RuntimeMetadataV2 {
            modules: [
                ModuleMetadata {
                    name: "system",
                    prefix: "System",
                    storage: Some(
                        [
                            StorageFunctionMetadata {
                                name: "AccountNonce",
                                modifier: Default,
                                ty: Map {
                                    key: Custom(
                                        "sr_primitives",
                                        "AccountId"
                                    ),
                                    value: U64
                                },
                                default: [
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0
                                ],
                                documentation: []
                            },
                            StorageFunctionMetadata {
                                name: "ExtrinsicCount",
                                modifier: Optional,
                                ty: Plain(
                                    U32
                                ),
                                default: [
                                    0
                                ],
                                documentation: []
                            },
                            StorageFunctionMetadata {
                                name: "AllExtrinsicsLen",
                                modifier: Optional,
                                ty: Plain(
                                    U32
                                ),
                                default: [
                                    0
                                ],
                                documentation: []
                            },
                            StorageFunctionMetadata {
                                name: "BlockHash",
                                modifier: Default,
                                ty: Map {
                                    key: U64,
                                    value: H256
                                },
                                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: []
                            },
                            StorageFunctionMetadata {
                                name: "ExtrinsicData",
                                modifier: Default,
                                ty: Map {
                                    key: U32,
                                    value: Vector(
                                        U8
                                    )
                                },
                                default: [
                                    0
                                ],
                                documentation: []
                            },
                            StorageFunctionMetadata {
                                name: "RandomSeed",
                                modifier: Default,
                                ty: Plain(
                                    H256
                                ),
                                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: []
                            },
                            StorageFunctionMetadata {
                                name: "Number",
                                modifier: Default,
                                ty: Plain(
                                    U64
                                ),
                                default: [
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0
                                ],
                                documentation: [
                                    " The current block number being processed. Set by `execute_block`."
                                ]
                            },
                            StorageFunctionMetadata {
                                name: "ParentHash",
                                modifier: Default,
                                ty: Plain(
                                    H256
                                ),
                                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: []
                            },
                            StorageFunctionMetadata {
                                name: "ExtrinsicsRoot",
                                modifier: Default,
                                ty: Plain(
                                    H256
                                ),
                                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: []
                            },
                            StorageFunctionMetadata {
                                name: "Digest",
                                modifier: Default,
                                ty: Plain(
                                    CustomWithGenerics(
                                        "sr_primitives::generic::digest",
                                        "Digest",
                                        [
                                            Custom(
                                                "node_runtime",
                                                "Log"
                                            )
                                        ]
                                    )
                                ),
                                default: [
                                    0
                                ],
                                documentation: []
                            },
                            StorageFunctionMetadata {
                                name: "Events",
                                modifier: Default,
                                ty: Plain(
                                    Vector(
                                        CustomWithGenerics(
                                            "srml_system",
                                            "EventRecord",
                                            [
                                                Custom(
                                                    "node_runtime",
                                                    "Event"
                                                )
                                            ]
                                        )
                                    )
                                ),
                                default: [
                                    0
                                ],
                                documentation: []
                            }
                        ]
                    ),
                    calls: None,
                    event: Some(
                        [
                            EventMetadata {
                                name: "ExtrinsicSuccess",
                                arguments: [],
                                documentation: [
                                    " An extrinsic completed successfully."
                                ]
                            },
                            EventMetadata {
                                name: "ExtrinsicFailed",
                                arguments: [],
                                documentation: [
                                    " An extrinsic failed."
                                ]
                            }
                        ]
                    )
                },
                ModuleMetadata {
                    name: "aura",
                    prefix: "",
                    storage: None,
                    calls: None,
                    event: None
                },
                ModuleMetadata {
                    name: "timestamp",
                    prefix: "Timestamp",
                    storage: Some(
                        [
                            StorageFunctionMetadata {
                                name: "Now",
                                modifier: Default,
                                ty: Plain(
                                    U64
                                ),
                                default: [
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0
                                ],
                                documentation: [
                                    " Current time for the current block."
                                ]
                            },
                            StorageFunctionMetadata {
                                name: "BlockPeriod",
                                modifier: Default,
                                ty: Plain(
                                    U64
                                ),
                                default: [
                                    5,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0
                                ],
                                documentation: [
                                    " The minimum (and advised) period between blocks."
                                ]
                            },
                            StorageFunctionMetadata {
                                name: "DidUpdate",
                                modifier: Default,
                                ty: Plain(
                                    Bool
                                ),
                                default: [
                                    0
                                ],
                                documentation: [
                                    " Did the timestamp get updated in this block?"
                                ]
                            }
                        ]
                    ),
                    calls: Some(
                        [
                            FunctionMetadata {
                                name: "set",
                                arguments: [
                                    FunctionArgumentMetadata {
                                        name: "now",
                                        ty: Compact(
                                            U64
                                        )
                                    }
                                ],
                                documentation: [
                                    " Set the current time.",
                                    "",
                                    " Extrinsic with this call should be placed at the specific position in the each block",
                                    " (specified by the Trait::TIMESTAMP_SET_POSITION) typically at the start of the each block.",
                                    " 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 `block_period`."
                                ]
                            }
                        ]
                    ),
                    event: None
                },
                ModuleMetadata {
                    name: "consensus",
                    prefix: "Consensus",
                    storage: Some(
                        [
                            StorageFunctionMetadata {
                                name: "OriginalAuthorities",
                                modifier: Optional,
                                ty: Plain(
                                    Vector(
                                        Custom(
                                            "substrate_primitives::authority_id",
                                            "Ed25519AuthorityId"
                                        )
                                    )
                                ),
                                default: [
                                    0
                                ],
                                documentation: []
                            }
                        ]
                    ),
                    calls: Some(
                        [
                            FunctionMetadata {
                                name: "report_misbehavior",
                                arguments: [
                                    FunctionArgumentMetadata {
                                        name: "_report",
                                        ty: Vector(
                                            U8
                                        )
                                    }
                                ],
                                documentation: [
                                    " Report some misbehaviour."
                                ]
                            },
                            FunctionMetadata {
                                name: "note_offline",
                                arguments: [
                                    FunctionArgumentMetadata {
                                        name: "offline",
                                        ty: Unit
                                    }
                                ],
                                documentation: [
                                    " Note the previous block\'s validator missed their opportunity to propose a block."
                                ]
                            },
                            FunctionMetadata {
                                name: "remark",
                                arguments: [
                                    FunctionArgumentMetadata {
                                        name: "_remark",
                                        ty: Vector(
                                            U8
                                        )
                                    }
                                ],
                                documentation: [
                                    " Make some on-chain remark."
                                ]
                            },
                            FunctionMetadata {
                                name: "set_heap_pages",
                                arguments: [
                                    FunctionArgumentMetadata {
                                        name: "pages",
                                        ty: U64
                                    }
                                ],
                                documentation: [
                                    " Set the number of pages in the WebAssembly environment\'s heap."
                                ]
                            },
                            FunctionMetadata {
                                name: "set_code",
                                arguments: [
                                    FunctionArgumentMetadata {
                                        name: "new",
                                        ty: Vector(
                                            U8
                                        )
                                    }
                                ],
                                documentation: [
                                    " Set the new code."
                                ]
                            },
                            FunctionMetadata {
                                name: "set_storage",
                                arguments: [
                                    FunctionArgumentMetadata {
                                        name: "items",
                                        ty: Vector(
                                            Tuple(
                                                [
                                                    Vector(
                                                        U8
                                                    ),
                                                    Vector(
                                                        U8
                                                    )
                                                ]
                                            )
                                        )
                                    }
                                ],
                                documentation: [
                                    " Set some items of storage."
                                ]
                            }
                        ]
                    ),
                    event: None
                },
                ModuleMetadata {
                    name: "indices",
                    prefix: "Indices",
                    storage: Some(
                        [
                            StorageFunctionMetadata {
                                name: "NextEnumSet",
                                modifier: Default,
                                ty: Plain(
                                    U32
                                ),
                                default: [
                                    0,
                                    0,
                                    0,
                                    0
                                ],
                                documentation: [
                                    " The next free enumeration set."
                                ]
                            },
                            StorageFunctionMetadata {
                                name: "EnumSet",
                                modifier: Default,
                                ty: Map {
                                    key: U32,
                                    value: Vector(
                                        Custom(
                                            "sr_primitives",
                                            "AccountId"
                                        )
                                    )
                                },
                                default: [
                                    0
                                ],
                                documentation: [
                                    " The enumeration sets."
                                ]
                            }
                        ]
                    ),
                    calls: Some(
                        []
                    ),
                    event: Some(
                        [
                            EventMetadata {
                                name: "NewAccountIndex",
                                arguments: [
                                    Custom(
                                        "sr_primitives",
                                        "AccountId"
                                    ),
                                    U32
                                ],
                                documentation: [
                                    " A new account index was assigned.",
                                    "",
                                    " This event is not triggered when an existing index is reassigned",
                                    " to another `AccountId`."
                                ]
                            }
                        ]
                    )
                },
                ModuleMetadata {
                    name: "balances",
                    prefix: "Balances",
                    storage: Some(
                        [
                            StorageFunctionMetadata {
                                name: "TotalIssuance",
                                modifier: Default,
                                ty: Plain(
                                    U128
                                ),
                                default: [
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0
                                ],
                                documentation: [
                                    " The total amount of stake on the system."
                                ]
                            },
                            StorageFunctionMetadata {
                                name: "ExistentialDeposit",
                                modifier: Default,
                                ty: Plain(
                                    U128
                                ),
                                default: [
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0
                                ],
                                documentation: [
                                    " The minimum amount allowed to keep an account open."
                                ]
                            },
                            StorageFunctionMetadata {
                                name: "TransferFee",
                                modifier: Default,
                                ty: Plain(
                                    U128
                                ),
                                default: [
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0
                                ],
                                documentation: [
                                    " The fee required to make a transfer."
                                ]
                            },
                            StorageFunctionMetadata {
                                name: "CreationFee",
                                modifier: Default,
                                ty: Plain(
                                    U128
                                ),
                                default: [
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0
                                ],
                                documentation: [
                                    " The fee required to create an account. At least as big as ReclaimRebate."
                                ]
                            },
                            StorageFunctionMetadata {
                                name: "Vesting",
                                modifier: Optional,
                                ty: Map {
                                    key: Custom(
                                        "sr_primitives",
                                        "AccountId"
                                    ),
                                    value: CustomWithGenerics(
                                        "srml_balances",
                                        "VestingSchedule",
                                        [
                                            U128
                                        ]
                                    )
                                },
                                default: [
                                    0
                                ],
                                documentation: [
                                    " Information regarding the vesting of a given account."
                                ]
                            },
                            StorageFunctionMetadata {
                                name: "FreeBalance",
                                modifier: Default,
                                ty: Map {
                                    key: Custom(
                                        "sr_primitives",
                                        "AccountId"
                                    ),
                                    value: U128
                                },
                                default: [
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0
                                ],
                                documentation: [
                                    " The \'free\' balance of a given account.",
                                    "",
                                    " This is the only balance that matters in terms of most operations on tokens. It is",
                                    " alone used to determine the balance when in the contract execution environment. When this",
                                    " balance falls below the value of `ExistentialDeposit`, then the \'current account\' is",
                                    " deleted: specifically `FreeBalance`. Furthermore, `OnFreeBalanceZero` callback",
                                    " is invoked, giving a chance to external modules to cleanup data associated with",
                                    " the deleted account.",
                                    "",
                                    " `system::AccountNonce` is also deleted if `ReservedBalance` is also zero (it also gets",
                                    " collapsed to zero if it ever becomes less than `ExistentialDeposit`."
                                ]
                            },
                            StorageFunctionMetadata {
                                name: "ReservedBalance",
                                modifier: Default,
                                ty: Map {
                                    key: Custom(
                                        "sr_primitives",
                                        "AccountId"
                                    ),
                                    value: U128
                                },
                                default: [
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0
                                ],
                                documentation: [
                                    " The amount of the balance of a given account that is externally reserved; this can still get",
                                    " slashed, but gets slashed last of all.",
                                    "",
                                    " This balance is a \'reserve\' balance that other subsystems use in order to set aside tokens",
                                    " that are still \'owned\' by the account holder, but which are suspendable. (This is different",
                                    " and wholly unrelated to the `Bondage` system used in the staking module.)",
                                    "",
                                    " When this balance falls below the value of `ExistentialDeposit`, then this \'reserve account\'",
                                    " is deleted: specifically, `ReservedBalance`.",
                                    "",
                                    " `system::AccountNonce` is also deleted if `FreeBalance` is also zero (it also gets",
                                    " collapsed to zero if it ever becomes less than `ExistentialDeposit`."
                                ]
                            }
                        ]
                    ),
                    calls: Some(
                        [
                            FunctionMetadata {
                                name: "transfer",
                                arguments: [
                                    FunctionArgumentMetadata {
                                        name: "dest",
                                        ty: Custom(
                                            "srml_indices::address",
                                            "Address"
                                        )
                                    },
                                    FunctionArgumentMetadata {
                                        name: "value",
                                        ty: Compact(
                                            U128
                                        )
                                    }
                                ],
                                documentation: [
                                    " Transfer some liquid free balance to another staker."
                                ]
                            },
                            FunctionMetadata {
                                name: "set_balance",
                                arguments: [
                                    FunctionArgumentMetadata {
                                        name: "who",
                                        ty: Custom(
                                            "srml_indices::address",
                                            "Address"
                                        )
                                    },
                                    FunctionArgumentMetadata {
                                        name: "free",
                                        ty: Compact(
                                            U128
                                        )
                                    },
                                    FunctionArgumentMetadata {
                                        name: "reserved",
                                        ty: Compact(
                                            U128
                                        )
                                    }
                                ],
                                documentation: [
                                    " Set the balances of a given account."
                                ]
                            }
                        ]
                    ),
                    event: Some(
                        [
                            EventMetadata {
                                name: "NewAccount",
                                arguments: [
                                    Custom(
                                        "sr_primitives",
                                        "AccountId"
                                    ),
                                    U128
                                ],
                                documentation: [
                                    " A new account was created."
                                ]
                            },
                            EventMetadata {
                                name: "ReapedAccount",
                                arguments: [
                                    Custom(
                                        "sr_primitives",
                                        "AccountId"
                                    )
                                ],
                                documentation: [
                                    " An account was reaped."
                                ]
                            },
                            EventMetadata {
                                name: "Transfer",
                                arguments: [
                                    Custom(
                                        "sr_primitives",
                                        "AccountId"
                                    ),
                                    Custom(
                                        "sr_primitives",
                                        "AccountId"
                                    ),
                                    U128,
                                    U128
                                ],
                                documentation: [
                                    " Transfer succeeded (from, to, value, fees)."
                                ]
                            }
                        ]
                    )
                },
                ModuleMetadata {
                    name: "session",
                    prefix: "Session",
                    storage: Some(
                        [
                            StorageFunctionMetadata {
                                name: "Validators",
                                modifier: Default,
                                ty: Plain(
                                    Vector(
                                        Custom(
                                            "sr_primitives",
                                            "AccountId"
                                        )
                                    )
                                ),
                                default: [
                                    0
                                ],
                                documentation: [
                                    " The current set of validators."
                                ]
                            },
                            StorageFunctionMetadata {
                                name: "SessionLength",
                                modifier: Default,
                                ty: Plain(
                                    U64
                                ),
                                default: [
                                    232,
                                    3,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0
                                ],
                                documentation: [
                                    " Current length of the session."
                                ]
                            },
                            StorageFunctionMetadata {
                                name: "CurrentIndex",
                                modifier: Default,
                                ty: Plain(
                                    U64
                                ),
                                default: [
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0
                                ],
                                documentation: [
                                    " Current index of the session."
                                ]
                            },
                            StorageFunctionMetadata {
                                name: "CurrentStart",
                                modifier: Default,
                                ty: Plain(
                                    U64
                                ),
                                default: [
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0
                                ],
                                documentation: [
                                    " Timestamp when current session started."
                                ]
                            },
                            StorageFunctionMetadata {
                                name: "ForcingNewSession",
                                modifier: Optional,
                                ty: Plain(
                                    Bool
                                ),
                                default: [
                                    0
                                ],
                                documentation: [
                                    " New session is being forced is this entry exists; in which case, the boolean value is whether",
                                    " the new session should be considered a normal rotation (rewardable) or exceptional (slashable)."
                                ]
                            },
                            StorageFunctionMetadata {
                                name: "LastLengthChange",
                                modifier: Optional,
                                ty: Plain(
                                    U64
                                ),
                                default: [
                                    0
                                ],
                                documentation: [
                                    " Block at which the session length last changed."
                                ]
                            },
                            StorageFunctionMetadata {
                                name: "NextKeyFor",
                                modifier: Optional,
                                ty: Map {
                                    key: Custom(
                                        "sr_primitives",
                                        "AccountId"
                                    ),
                                    value: Custom(
                                        "substrate_primitives::authority_id",
                                        "Ed25519AuthorityId"
                                    )
                                },
                                default: [
                                    0
                                ],
                                documentation: [
                                    " The next key for a given validator."
                                ]
                            },
                            StorageFunctionMetadata {
                                name: "NextSessionLength",
                                modifier: Optional,
                                ty: Plain(
                                    U64
                                ),
                                default: [
                                    0
                                ],
                                documentation: [
                                    " The next session length."
                                ]
                            }
                        ]
                    ),
                    calls: Some(
                        [
                            FunctionMetadata {
                                name: "set_key",
                                arguments: [
                                    FunctionArgumentMetadata {
                                        name: "key",
                                        ty: Custom(
                                            "substrate_primitives::authority_id",
                                            "Ed25519AuthorityId"
                                        )
                                    }
                                ],
                                documentation: [
                                    " Sets the session key of `_validator` to `_key`. This doesn\'t take effect until the next",
                                    " session."
                                ]
                            },
                            FunctionMetadata {
                                name: "set_length",
                                arguments: [
                                    FunctionArgumentMetadata {
                                        name: "new",
                                        ty: Compact(
                                            U64
                                        )
                                    }
                                ],
                                documentation: [
                                    " Set a new session length. Won\'t kick in until the next session change (at current length)."
                                ]
                            },
                            FunctionMetadata {
                                name: "force_new_session",
                                arguments: [
                                    FunctionArgumentMetadata {
                                        name: "apply_rewards",
                                        ty: Bool
                                    }
                                ],
                                documentation: [
                                    " Forces a new session."
                                ]
                            }
                        ]
                    ),
                    event: Some(
                        [
                            EventMetadata {
                                name: "NewSession",
                                arguments: [
                                    U64
                                ],
                                documentation: [
                                    " New session has happened. Note that the argument is the session index, not the block",
                                    " number as the type might suggest."
                                ]
                            }
                        ]
                    )
                },
                ModuleMetadata {
                    name: "staking",
                    prefix: "Staking",
                    storage: Some(
                        [
                            StorageFunctionMetadata {
                                name: "ValidatorCount",
                                modifier: Default,
                                ty: Plain(
                                    U32
                                ),
                                default: [
                                    0,
                                    0,
                                    0,
                                    0
                                ],
                                documentation: [
                                    " The ideal number of staking participants."
                                ]
                            },
                            StorageFunctionMetadata {
                                name: "MinimumValidatorCount",
                                modifier: Default,
                                ty: Plain(
                                    U32
                                ),
                                default: [
                                    4,
                                    0,
                                    0,
                                    0
                                ],
                                documentation: [
                                    " Minimum number of staking participants before emergency conditions are imposed."
                                ]
                            },
                            StorageFunctionMetadata {
                                name: "SessionsPerEra",
                                modifier: Default,
                                ty: Plain(
                                    U64
                                ),
                                default: [
                                    232,
                                    3,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0
                                ],
                                documentation: [
                                    " The length of a staking era in sessions."
                                ]
                            },
                            StorageFunctionMetadata {
                                name: "SessionReward",
                                modifier: Default,
                                ty: Plain(
                                    Custom(
                                        "sr_primitives",
                                        "Perbill"
                                    )
                                ),
                                default: [
                                    60,
                                    0,
                                    0,
                                    0
                                ],
                                documentation: [
                                    " Maximum reward, per validator, that is provided per acceptable session."
                                ]
                            },
                            StorageFunctionMetadata {
                                name: "OfflineSlash",
                                modifier: Default,
                                ty: Plain(
                                    Custom(
                                        "sr_primitives",
                                        "Perbill"
                                    )
                                ),
                                default: [
                                    64,
                                    66,
                                    15,
                                    0
                                ],
                                documentation: [
                                    " Slash, per validator that is taken for the first time they are found to be offline."
                                ]
                            },
                            StorageFunctionMetadata {
                                name: "OfflineSlashGrace",
                                modifier: Default,
                                ty: Plain(
                                    U32
                                ),
                                default: [
                                    0,
                                    0,
                                    0,
                                    0
                                ],
                                documentation: [
                                    " Number of instances of offline reports before slashing begins for validators."
                                ]
                            },
                            StorageFunctionMetadata {
                                name: "BondingDuration",
                                modifier: Default,
                                ty: Plain(
                                    U64
                                ),
                                default: [
                                    232,
                                    3,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0
                                ],
                                documentation: [
                                    " The length of the bonding duration in blocks."
                                ]
                            },
                            StorageFunctionMetadata {
                                name: "Invulerables",
                                modifier: Default,
                                ty: Plain(
                                    Vector(
                                        Custom(
                                            "sr_primitives",
                                            "AccountId"
                                        )
                                    )
                                ),
                                default: [
                                    0
                                ],
                                documentation: [
                                    " Any validators that may never be slashed or forcible kicked. It\'s a Vec since they\'re easy to initialise",
                                    " and the performance hit is minimal (we expect no more than four invulnerables) and restricted to testnets."
                                ]
                            },
                            StorageFunctionMetadata {
                                name: "CurrentEra",
                                modifier: Default,
                                ty: Plain(
                                    U64
                                ),
                                default: [
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0
                                ],
                                documentation: [
                                    " The current era index."
                                ]
                            },
                            StorageFunctionMetadata {
                                name: "ValidatorPreferences",
                                modifier: Default,
                                ty: Map {
                                    key: Custom(
                                        "sr_primitives",
                                        "AccountId"
                                    ),
                                    value: CustomWithGenerics(
                                        "srml_staking",
                                        "ValidatorPrefs",
                                        [
                                            U128
                                        ]
                                    )
                                },
                                default: [
                                    12,
                                    0
                                ],
                                documentation: [
                                    " Preferences that a validator has."
                                ]
                            },
                            StorageFunctionMetadata {
                                name: "Intentions",
                                modifier: Default,
                                ty: Plain(
                                    Vector(
                                        Custom(
                                            "sr_primitives",
                                            "AccountId"
                                        )
                                    )
                                ),
                                default: [
                                    0
                                ],
                                documentation: [
                                    " All the accounts with a desire to stake."
                                ]
                            },
                            StorageFunctionMetadata {
                                name: "Nominating",
                                modifier: Optional,
                                ty: Map {
                                    key: Custom(
                                        "sr_primitives",
                                        "AccountId"
                                    ),
                                    value: Custom(
                                        "sr_primitives",
                                        "AccountId"
                                    )
                                },
                                default: [
                                    0
                                ],
                                documentation: [
                                    " All nominator -> nominee relationships."
                                ]
                            },
                            StorageFunctionMetadata {
                                name: "NominatorsFor",
                                modifier: Default,
                                ty: Map {
                                    key: Custom(
                                        "sr_primitives",
                                        "AccountId"
                                    ),
                                    value: Vector(
                                        Custom(
                                            "sr_primitives",
                                            "AccountId"
                                        )
                                    )
                                },
                                default: [
                                    0
                                ],
                                documentation: [
                                    " Nominators for a particular account."
                                ]
                            },
                            StorageFunctionMetadata {
                                name: "CurrentNominatorsFor",
                                modifier: Default,
                                ty: Map {
                                    key: Custom(
                                        "sr_primitives",
                                        "AccountId"
                                    ),
                                    value: Vector(
                                        Custom(
                                            "sr_primitives",
                                            "AccountId"
                                        )
                                    )
                                },
                                default: [
                                    0
                                ],
                                documentation: [
                                    " Nominators for a particular account that is in action right now."
                                ]
                            },
                            StorageFunctionMetadata {
                                name: "CurrentSessionReward",
                                modifier: Default,
                                ty: Plain(
                                    U128
                                ),
                                default: [
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0
                                ],
                                documentation: [
                                    " Maximum reward, per validator, that is provided per acceptable session."
                                ]
                            },
                            StorageFunctionMetadata {
                                name: "CurrentOfflineSlash",
                                modifier: Default,
                                ty: Plain(
                                    U128
                                ),
                                default: [
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0
                                ],
                                documentation: [
                                    " Slash, per validator that is taken for the first time they are found to be offline."
                                ]
                            },
                            StorageFunctionMetadata {
                                name: "NextSessionsPerEra",
                                modifier: Optional,
                                ty: Plain(
                                    U64
                                ),
                                default: [
                                    0
                                ],
                                documentation: [
                                    " The next value of sessions per era."
                                ]
                            },
                            StorageFunctionMetadata {
                                name: "LastEraLengthChange",
                                modifier: Default,
                                ty: Plain(
                                    U64
                                ),
                                default: [
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0
                                ],
                                documentation: [
                                    " The session index at which the era length last changed."
                                ]
                            },
                            StorageFunctionMetadata {
                                name: "StakeRange",
                                modifier: Default,
                                ty: Plain(
                                    Tuple(
                                        [
                                            U128,
                                            U128
                                        ]
                                    )
                                ),
                                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 highest and lowest staked validator slashable balances."
                                ]
                            },
                            StorageFunctionMetadata {
                                name: "Bondage",
                                modifier: Default,
                                ty: Map {
                                    key: Custom(
                                        "sr_primitives",
                                        "AccountId"
                                    ),
                                    value: U64
                                },
                                default: [
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0
                                ],
                                documentation: [
                                    " The block at which the `who`\'s funds become entirely liquid."
                                ]
                            },
                            StorageFunctionMetadata {
                                name: "SlashCount",
                                modifier: Default,
                                ty: Map {
                                    key: Custom(
                                        "sr_primitives",
                                        "AccountId"
                                    ),
                                    value: U32
                                },
                                default: [
                                    0,
                                    0,
                                    0,
                                    0
                                ],
                                documentation: [
                                    " The number of times a given validator has been reported offline. This gets decremented by one each era that passes."
                                ]
                            },
                            StorageFunctionMetadata {
                                name: "ForcingNewEra",
                                modifier: Optional,
                                ty: Plain(
                                    Unit
                                ),
                                default: [
                                    0
                                ],
                                documentation: [
                                    " We are forcing a new era."
                                ]
                            },
                            StorageFunctionMetadata {
                                name: "RecentlyOffline",
                                modifier: Default,
                                ty: Plain(
                                    Vector(
                                        Tuple(
                                            [
                                                Custom(
                                                    "sr_primitives",
                                                    "AccountId"
                                                ),
                                                U64,
                                                U32
                                            ]
                                        )
                                    )
                                ),
                                default: [
                                    0
                                ],
                                documentation: [
                                    " Most recent `RECENT_OFFLINE_COUNT` instances. (who it was, when it was reported, how many instances they were offline for)."
                                ]
                            }
                        ]
                    ),
                    calls: Some(
                        [
                            FunctionMetadata {
                                name: "stake",
                                arguments: [],
                                documentation: [
                                    " Declare the desire to stake for the transactor.",
                                    "",
                                    " Effects will be felt at the beginning of the next era."
                                ]
                            },
                            FunctionMetadata {
                                name: "unstake",
                                arguments: [
                                    FunctionArgumentMetadata {
                                        name: "intentions_index",
                                        ty: Compact(
                                            U32
                                        )
                                    }
                                ],
                                documentation: [
                                    " Retract the desire to stake for the transactor.",
                                    "",
                                    " Effects will be felt at the beginning of the next era."
                                ]
                            },
                            FunctionMetadata {
                                name: "nominate",
                                arguments: [
                                    FunctionArgumentMetadata {
                                        name: "target",
                                        ty: Custom(
                                            "srml_indices::address",
                                            "Address"
                                        )
                                    }
                                ],
                                documentation: []
                            },
                            FunctionMetadata {
                                name: "unnominate",
                                arguments: [
                                    FunctionArgumentMetadata {
                                        name: "target_index",
                                        ty: Compact(
                                            U32
                                        )
                                    }
                                ],
                                documentation: [
                                    " Will panic if called when source isn\'t currently nominating target.",
                                    " Updates Nominating, NominatorsFor and NominationBalance."
                                ]
                            },
                            FunctionMetadata {
                                name: "register_preferences",
                                arguments: [
                                    FunctionArgumentMetadata {
                                        name: "intentions_index",
                                        ty: Compact(
                                            U32
                                        )
                                    },
                                    FunctionArgumentMetadata {
                                        name: "prefs",
                                        ty: CustomWithGenerics(
                                            "srml_staking",
                                            "ValidatorPrefs",
                                            [
                                                U128
                                            ]
                                        )
                                    }
                                ],
                                documentation: [
                                    " Set the given account\'s preference for slashing behaviour should they be a validator.",
                                    "",
                                    " An error (no-op) if `Self::intentions()[intentions_index] != origin`."
                                ]
                            },
                            FunctionMetadata {
                                name: "set_sessions_per_era",
                                arguments: [
                                    FunctionArgumentMetadata {
                                        name: "new",
                                        ty: Compact(
                                            U64
                                        )
                                    }
                                ],
                                documentation: [
                                    " Set the number of sessions in an era."
                                ]
                            },
                            FunctionMetadata {
                                name: "set_bonding_duration",
                                arguments: [
                                    FunctionArgumentMetadata {
                                        name: "new",
                                        ty: Compact(
                                            U64
                                        )
                                    }
                                ],
                                documentation: [
                                    " The length of the bonding duration in eras."
                                ]
                            },
                            FunctionMetadata {
                                name: "set_validator_count",
                                arguments: [
                                    FunctionArgumentMetadata {
                                        name: "new",
                                        ty: Compact(
                                            U32
                                        )
                                    }
                                ],
                                documentation: [
                                    " The ideal number of validators."
                                ]
                            },
                            FunctionMetadata {
                                name: "force_new_era",
                                arguments: [
                                    FunctionArgumentMetadata {
                                        name: "apply_rewards",
                                        ty: Bool
                                    }
                                ],
                                documentation: [
                                    " Force there to be a new era. This also forces a new session immediately after.",
                                    " `apply_rewards` should be true for validators to get the session reward."
                                ]
                            },
                            FunctionMetadata {
                                name: "set_offline_slash_grace",
                                arguments: [
                                    FunctionArgumentMetadata {
                                        name: "new",
                                        ty: Compact(
                                            U32
                                        )
                                    }
                                ],
                                documentation: [
                                    " Set the offline slash grace period."
                                ]
                            },
                            FunctionMetadata {
                                name: "set_invulnerables",
                                arguments: [
                                    FunctionArgumentMetadata {
                                        name: "validators",
                                        ty: Vector(
                                            Custom(
                                                "sr_primitives",
                                                "AccountId"
                                            )
                                        )
                                    }
                                ],
                                documentation: [
                                    " Set the validators who cannot be slashed (if any)."
                                ]
                            }
                        ]
                    ),
                    event: Some(
                        [
                            EventMetadata {
                                name: "Reward",
                                arguments: [
                                    U128
                                ],
                                documentation: [
                                    " All validators have been rewarded by the given balance."
                                ]
                            },
                            EventMetadata {
                                name: "OfflineWarning",
                                arguments: [
                                    Custom(
                                        "sr_primitives",
                                        "AccountId"
                                    ),
                                    U32
                                ],
                                documentation: [
                                    " One validator (and their nominators) has been given a offline-warning (they\'re still",
                                    " within their grace). The accrued number of slashes is recorded, too."
                                ]
                            },
                            EventMetadata {
                                name: "OfflineSlash",
                                arguments: [
                                    Custom(
                                        "sr_primitives",
                                        "AccountId"
                                    ),
                                    U128
                                ],
                                documentation: [
                                    " One validator (and their nominators) has been slashed by the given amount."
                                ]
                            }
                        ]
                    )
                },
                ModuleMetadata {
                    name: "democracy",
                    prefix: "Democracy",
                    storage: Some(
                        [
                            StorageFunctionMetadata {
                                name: "PublicPropCount",
                                modifier: Default,
                                ty: Plain(
                                    U32
                                ),
                                default: [
                                    0,
                                    0,
                                    0,
                                    0
                                ],
                                documentation: [
                                    " The number of (public) proposals that have been made so far."
                                ]
                            },
                            StorageFunctionMetadata {
                                name: "PublicProps",
                                modifier: Default,
                                ty: Plain(
                                    Vector(
                                        Tuple(
                                            [
                                                U32,
                                                Custom(
                                                    "node_runtime",
                                                    "Call"
                                                ),
                                                Custom(
                                                    "sr_primitives",
                                                    "AccountId"
                                                )
                                            ]
                                        )
                                    )
                                ),
                                default: [
                                    0
                                ],
                                documentation: [
                                    " The public proposals. Unsorted."
                                ]
                            },
                            StorageFunctionMetadata {
                                name: "DepositOf",
                                modifier: Optional,
                                ty: Map {
                                    key: U32,
                                    value: Tuple(
                                        [
                                            U128,
                                            Vector(
                                                Custom(
                                                    "sr_primitives",
                                                    "AccountId"
                                                )
                                            )
                                        ]
                                    )
                                },
                                default: [
                                    0
                                ],
                                documentation: [
                                    " Those who have locked a deposit."
                                ]
                            },
                            StorageFunctionMetadata {
                                name: "LaunchPeriod",
                                modifier: Default,
                                ty: Plain(
                                    U64
                                ),
                                default: [
                                    232,
                                    3,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0
                                ],
                                documentation: [
                                    " How often (in blocks) new public referenda are launched."
                                ]
                            },
                            StorageFunctionMetadata {
                                name: "MinimumDeposit",
                                modifier: Default,
                                ty: Plain(
                                    U128
                                ),
                                default: [
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0
                                ],
                                documentation: [
                                    " The minimum amount to be used as a deposit for a public referendum proposal."
                                ]
                            },
                            StorageFunctionMetadata {
                                name: "PublicDelay",
                                modifier: Default,
                                ty: Plain(
                                    U64
                                ),
                                default: [
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0
                                ],
                                documentation: [
                                    " The delay before enactment for all public referenda."
                                ]
                            },
                            StorageFunctionMetadata {
                                name: "MaxLockPeriods",
                                modifier: Default,
                                ty: Plain(
                                    I8
                                ),
                                default: [
                                    0
                                ],
                                documentation: [
                                    " The maximum number of additional lock periods a voter may offer to strengthen their vote. Multiples of `PublicDelay`."
                                ]
                            },
                            StorageFunctionMetadata {
                                name: "VotingPeriod",
                                modifier: Default,
                                ty: Plain(
                                    U64
                                ),
                                default: [
                                    232,
                                    3,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0
                                ],
                                documentation: [
                                    " How often (in blocks) to check for new votes."
                                ]
                            },
                            StorageFunctionMetadata {
                                name: "ReferendumCount",
                                modifier: Default,
                                ty: Plain(
                                    U32
                                ),
                                default: [
                                    0,
                                    0,
                                    0,
                                    0
                                ],
                                documentation: [
                                    " The next free referendum index, aka the number of referendums started so far."
                                ]
                            },
                            StorageFunctionMetadata {
                                name: "NextTally",
                                modifier: Default,
                                ty: Plain(
                                    U32
                                ),
                                default: [
                                    0,
                                    0,
                                    0,
                                    0
                                ],
                                documentation: [
                                    " The next referendum index that should be tallied."
                                ]
                            },
                            StorageFunctionMetadata {
                                name: "ReferendumInfoOf",
                                modifier: Optional,
                                ty: Map {
                                    key: U32,
                                    value: CustomWithGenerics(
                                        "srml_democracy",
                                        "ReferendumInfo",
                                        [
                                            U64,
                                            Custom(
                                                "node_runtime",
                                                "Call"
                                            )
                                        ]
                                    )
                                },
                                default: [
                                    0
                                ],
                                documentation: [
                                    " Information concerning any given referendum."
                                ]
                            },
                            StorageFunctionMetadata {
                                name: "DispatchQueue",
                                modifier: Default,
                                ty: Map {
                                    key: U64,
                                    value: Vector(
                                        Option(
                                            Tuple(
                                                [
                                                    Custom(
                                                        "node_runtime",
                                                        "Call"
                                                    ),
                                                    U32
                                                ]
                                            )
                                        )
                                    )
                                },
                                default: [
                                    0
                                ],
                                documentation: [
                                    " Queue of successful referenda to be dispatched."
                                ]
                            },
                            StorageFunctionMetadata {
                                name: "Bondage",
                                modifier: Default,
                                ty: Map {
                                    key: Custom(
                                        "sr_primitives",
                                        "AccountId"
                                    ),
                                    value: U64
                                },
                                default: [
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0
                                ],
                                documentation: [
                                    " The block at which the `who`\'s funds become liquid."
                                ]
                            },
                            StorageFunctionMetadata {
                                name: "VotersFor",
                                modifier: Default,
                                ty: Map {
                                    key: U32,
                                    value: Vector(
                                        Custom(
                                            "sr_primitives",
                                            "AccountId"
                                        )
                                    )
                                },
                                default: [
                                    0
                                ],
                                documentation: [
                                    " Get the voters for the current proposal."
                                ]
                            },
                            StorageFunctionMetadata {
                                name: "VoteOf",
                                modifier: Default,
                                ty: Map {
                                    key: Tuple(
                                        [
                                            U32,
                                            Custom(
                                                "sr_primitives",
                                                "AccountId"
                                            )
                                        ]
                                    ),
                                    value: Custom(
                                        "srml_democracy",
                                        "Vote"
                                    )
                                },
                                default: [
                                    0
                                ],
                                documentation: [
                                    " Get the vote in a given referendum of a particular voter. The result is meaningful only if `voters_for` includes the",
                                    " voter when called with the referendum (you\'ll get the default `Vote` value otherwise). If you don\'t want to check",
                                    " `voters_for`, then you can also check for simple existence with `VoteOf::exists` first."
                                ]
                            }
                        ]
                    ),
                    calls: Some(
                        [
                            FunctionMetadata {
                                name: "propose",
                                arguments: [
                                    FunctionArgumentMetadata {
                                        name: "proposal",
                                        ty: Custom(
                                            "node_runtime",
                                            "Call"
                                        )
                                    },
                                    FunctionArgumentMetadata {
                                        name: "value",
                                        ty: Compact(
                                            U128
                                        )
                                    }
                                ],
                                documentation: [
                                    " Propose a sensitive action to be taken."
                                ]
                            },
                            FunctionMetadata {
                                name: "second",
                                arguments: [
                                    FunctionArgumentMetadata {
                                        name: "proposal",
                                        ty: Compact(
                                            U32
                                        )
                                    }
                                ],
                                documentation: [
                                    " Propose a sensitive action to be taken."
                                ]
                            },
                            FunctionMetadata {
                                name: "vote",
                                arguments: [
                                    FunctionArgumentMetadata {
                                        name: "ref_index",
                                        ty: Compact(
                                            U32
                                        )
                                    },
                                    FunctionArgumentMetadata {
                                        name: "vote",
                                        ty: Custom(
                                            "srml_democracy",
                                            "Vote"
                                        )
                                    }
                                ],
                                documentation: [
                                    " Vote in a referendum. If `vote.is_aye()`, the vote is to enact the proposal;",
                                    " otherwise it is a vote to keep the status quo."
                                ]
                            },
                            FunctionMetadata {
                                name: "start_referendum",
                                arguments: [
                                    FunctionArgumentMetadata {
                                        name: "proposal",
                                        ty: Custom(
                                            "node_runtime",
                                            "Call"
                                        )
                                    },
                                    FunctionArgumentMetadata {
                                        name: "threshold",
                                        ty: Custom(
                                            "srml_democracy::vote_threshold",
                                            "VoteThreshold"
                                        )
                                    },
                                    FunctionArgumentMetadata {
                                        name: "delay",
                                        ty: U64
                                    }
                                ],
                                documentation: [
                                    " Start a referendum."
                                ]
                            },
                            FunctionMetadata {
                                name: "cancel_referendum",
                                arguments: [
                                    FunctionArgumentMetadata {
                                        name: "ref_index",
                                        ty: Compact(
                                            U32
                                        )
                                    }
                                ],
                                documentation: [
                                    " Remove a referendum."
                                ]
                            },
                            FunctionMetadata {
                                name: "cancel_queued",
                                arguments: [
                                    FunctionArgumentMetadata {
                                        name: "when",
                                        ty: Compact(
                                            U64
                                        )
                                    },
                                    FunctionArgumentMetadata {
                                        name: "which",
                                        ty: Compact(
                                            U32
                                        )
                                    }
                                ],
                                documentation: [
                                    " Cancel a proposal queued for enactment."
                                ]
                            }
                        ]
                    ),
                    event: Some(
                        [
                            EventMetadata {
                                name: "Proposed",
                                arguments: [
                                    U32,
                                    U128
                                ],
                                documentation: []
                            },
                            EventMetadata {
                                name: "Tabled",
                                arguments: [
                                    U32,
                                    U128,
                                    Vector(
                                        Custom(
                                            "sr_primitives",
                                            "AccountId"
                                        )
                                    )
                                ],
                                documentation: []
                            },
                            EventMetadata {
                                name: "Started",
                                arguments: [
                                    U32,
                                    Custom(
                                        "srml_democracy::vote_threshold",
                                        "VoteThreshold"
                                    )
                                ],
                                documentation: []
                            },
                            EventMetadata {
                                name: "Passed",
                                arguments: [
                                    U32
                                ],
                                documentation: []
                            },
                            EventMetadata {
                                name: "NotPassed",
                                arguments: [
                                    U32
                                ],
                                documentation: []
                            },
                            EventMetadata {
                                name: "Cancelled",
                                arguments: [
                                    U32
                                ],
                                documentation: []
                            },
                            EventMetadata {
                                name: "Executed",
                                arguments: [
                                    U32,
                                    Bool
                                ],
                                documentation: []
                            }
                        ]
                    )
                },
                ModuleMetadata {
                    name: "council",
                    prefix: "Council",
                    storage: Some(
                        [
                            StorageFunctionMetadata {
                                name: "CandidacyBond",
                                modifier: Default,
                                ty: Plain(
                                    U128
                                ),
                                default: [
                                    9,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0
                                ],
                                documentation: [
                                    " How much should be locked up in order to submit one\'s candidacy."
                                ]
                            },
                            StorageFunctionMetadata {
                                name: "VotingBond",
                                modifier: Default,
                                ty: Plain(
                                    U128
                                ),
                                default: [
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0
                                ],
                                documentation: [
                                    " How much should be locked up in order to be able to submit votes."
                                ]
                            },
                            StorageFunctionMetadata {
                                name: "PresentSlashPerVoter",
                                modifier: Default,
                                ty: Plain(
                                    U128
                                ),
                                default: [
                                    1,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0
                                ],
                                documentation: [
                                    " The punishment, per voter, if you provide an invalid presentation."
                                ]
                            },
                            StorageFunctionMetadata {
                                name: "CarryCount",
                                modifier: Default,
                                ty: Plain(
                                    U32
                                ),
                                default: [
                                    2,
                                    0,
                                    0,
                                    0
                                ],
                                documentation: [
                                    " How many runners-up should have their approvals persist until the next vote."
                                ]
                            },
                            StorageFunctionMetadata {
                                name: "PresentationDuration",
                                modifier: Default,
                                ty: Plain(
                                    U64
                                ),
                                default: [
                                    232,
                                    3,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0
                                ],
                                documentation: [
                                    " How long to give each top candidate to present themselves after the vote ends."
                                ]
                            },
                            StorageFunctionMetadata {
                                name: "InactiveGracePeriod",
                                modifier: Default,
                                ty: Plain(
                                    U32
                                ),
                                default: [
                                    1,
                                    0,
                                    0,
                                    0
                                ],
                                documentation: [
                                    " How many vote indexes need to go by after a target voter\'s last vote before they can be reaped if their",
                                    " approvals are moot."
                                ]
                            },
                            StorageFunctionMetadata {
                                name: "VotingPeriod",
                                modifier: Default,
                                ty: Plain(
                                    U64
                                ),
                                default: [
                                    232,
                                    3,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0
                                ],
                                documentation: [
                                    " How often (in blocks) to check for new votes."
                                ]
                            },
                            StorageFunctionMetadata {
                                name: "TermDuration",
                                modifier: Default,
                                ty: Plain(
                                    U64
                                ),
                                default: [
                                    5,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0
                                ],
                                documentation: [
                                    " How long each position is active for."
                                ]
                            },
                            StorageFunctionMetadata {
                                name: "DesiredSeats",
                                modifier: Default,
                                ty: Plain(
                                    U32
                                ),
                                default: [
                                    0,
                                    0,
                                    0,
                                    0
                                ],
                                documentation: [
                                    " Number of accounts that should be sitting on the council."
                                ]
                            },
                            StorageFunctionMetadata {
                                name: "ActiveCouncil",
                                modifier: Default,
                                ty: Plain(
                                    Vector(
                                        Tuple(
                                            [
                                                Custom(
                                                    "sr_primitives",
                                                    "AccountId"
                                                ),
                                                U64
                                            ]
                                        )
                                    )
                                ),
                                default: [
                                    0
                                ],
                                documentation: [
                                    " The current council. When there\'s a vote going on, this should still be used for executive",
                                    " matters. The block number (second element in the tuple) is the block that their position is",
                                    " active until (calculated by the sum of the block number when the council member was elected",
                                    " and their term duration)."
                                ]
                            },
                            StorageFunctionMetadata {
                                name: "VoteCount",
                                modifier: Default,
                                ty: Plain(
                                    U32
                                ),
                                default: [
                                    0,
                                    0,
                                    0,
                                    0
                                ],
                                documentation: [
                                    " The total number of votes that have happened or are in progress."
                                ]
                            },
                            StorageFunctionMetadata {
                                name: "ApprovalsOf",
                                modifier: Default,
                                ty: Map {
                                    key: Custom(
                                        "sr_primitives",
                                        "AccountId"
                                    ),
                                    value: Vector(
                                        Bool
                                    )
                                },
                                default: [
                                    0
                                ],
                                documentation: [
                                    " A list of votes for each voter, respecting the last cleared vote index that this voter was",
                                    " last active at."
                                ]
                            },
                            StorageFunctionMetadata {
                                name: "RegisterInfoOf",
                                modifier: Optional,
                                ty: Map {
                                    key: Custom(
                                        "sr_primitives",
                                        "AccountId"
                                    ),
                                    value: Tuple(
                                        [
                                            U32,
                                            U32
                                        ]
                                    )
                                },
                                default: [
                                    0
                                ],
                                documentation: [
                                    " The vote index and list slot that the candidate `who` was registered or `None` if they are not",
                                    " currently registered."
                                ]
                            },
                            StorageFunctionMetadata {
                                name: "LastActiveOf",
                                modifier: Optional,
                                ty: Map {
                                    key: Custom(
                                        "sr_primitives",
                                        "AccountId"
                                    ),
                                    value: U32
                                },
                                default: [
                                    0
                                ],
                                documentation: [
                                    " The last cleared vote index that this voter was last active at."
                                ]
                            },
                            StorageFunctionMetadata {
                                name: "Voters",
                                modifier: Default,
                                ty: Plain(
                                    Vector(
                                        Custom(
                                            "sr_primitives",
                                            "AccountId"
                                        )
                                    )
                                ),
                                default: [
                                    0
                                ],
                                documentation: [
                                    " The present voter list."
                                ]
                            },
                            StorageFunctionMetadata {
                                name: "Candidates",
                                modifier: Default,
                                ty: Plain(
                                    Vector(
                                        Custom(
                                            "sr_primitives",
                                            "AccountId"
                                        )
                                    )
                                ),
                                default: [
                                    0
                                ],
                                documentation: [
                                    " The present candidate list."
                                ]
                            },
                            StorageFunctionMetadata {
                                name: "CandidateCount",
                                modifier: Default,
                                ty: Plain(
                                    U32
                                ),
                                default: [
                                    0,
                                    0,
                                    0,
                                    0
                                ],
                                documentation: []
                            },
                            StorageFunctionMetadata {
                                name: "NextFinalise",
                                modifier: Optional,
                                ty: Plain(
                                    Tuple(
                                        [
                                            U64,
                                            U32,
                                            Vector(
                                                Custom(
                                                    "sr_primitives",
                                                    "AccountId"
                                                )
                                            )
                                        ]
                                    )
                                ),
                                default: [
                                    0
                                ],
                                documentation: [
                                    " The accounts holding the seats that will become free on the next tally."
                                ]
                            },
                            StorageFunctionMetadata {
                                name: "SnapshotedStakes",
                                modifier: Default,
                                ty: Plain(
                                    Vector(
                                        U128
                                    )
                                ),
                                default: [
                                    0
                                ],
                                documentation: [
                                    " The stakes as they were at the point that the vote ended."
                                ]
                            },
                            StorageFunctionMetadata {
                                name: "Leaderboard",
                                modifier: Optional,
                                ty: Plain(
                                    Vector(
                                        Tuple(
                                            [
                                                U128,
                                                Custom(
                                                    "sr_primitives",
                                                    "AccountId"
                                                )
                                            ]
                                        )
                                    )
                                ),
                                default: [
                                    0
                                ],
                                documentation: [
                                    " Get the leaderboard if we;re in the presentation phase."
                                ]
                            }
                        ]
                    ),
                    calls: Some(
                        [
                            FunctionMetadata {
                                name: "set_approvals",
                                arguments: [
                                    FunctionArgumentMetadata {
                                        name: "votes",
                                        ty: Vector(
                                            Bool
                                        )
                                    },
                                    FunctionArgumentMetadata {
                                        name: "index",
                                        ty: Compact(
                                            U32
                                        )
                                    }
                                ],
                                documentation: [
                                    " Set candidate approvals. Approval slots stay valid as long as candidates in those slots",
                                    " are registered."
                                ]
                            },
                            FunctionMetadata {
                                name: "reap_inactive_voter",
                                arguments: [
                                    FunctionArgumentMetadata {
                                        name: "reporter_index",
                                        ty: Compact(
                                            U32
                                        )
                                    },
                                    FunctionArgumentMetadata {
                                        name: "who",
                                        ty: Custom(
                                            "srml_indices::address",
                                            "Address"
                                        )
                                    },
                                    FunctionArgumentMetadata {
                                        name: "who_index",
                                        ty: Compact(
                                            U32
                                        )
                                    },
                                    FunctionArgumentMetadata {
                                        name: "assumed_vote_index",
                                        ty: Compact(
                                            U32
                                        )
                                    }
                                ],
                                documentation: [
                                    " Remove a voter. For it not to be a bond-consuming no-op, all approved candidate indices",
                                    " must now be either unregistered or registered to a candidate that registered the slot after",
                                    " the voter gave their last approval set.",
                                    "",
                                    " May be called by anyone. Returns the voter deposit to `signed`."
                                ]
                            },
                            FunctionMetadata {
                                name: "retract_voter",
                                arguments: [
                                    FunctionArgumentMetadata {
                                        name: "index",
                                        ty: Compact(
                                            U32
                                        )
                                    }
                                ],
                                documentation: [
                                    " Remove a voter. All votes are cancelled and the voter deposit is returned."
                                ]
                            },
                            FunctionMetadata {
                                name: "submit_candidacy",
                                arguments: [
                                    FunctionArgumentMetadata {
                                        name: "slot",
                                        ty: Compact(
                                            U32
                                        )
                                    }
                                ],
                                documentation: [
                                    " Submit oneself for candidacy.",
                                    "",
                                    " Account must have enough transferrable funds in it to pay the bond."
                                ]
                            },
                            FunctionMetadata {
                                name: "present_winner",
                                arguments: [
                                    FunctionArgumentMetadata {
                                        name: "candidate",
                                        ty: Custom(
                                            "srml_indices::address",
                                            "Address"
                                        )
                                    },
                                    FunctionArgumentMetadata {
                                        name: "total",
                                        ty: Compact(
                                            U128
                                        )
                                    },
                                    FunctionArgumentMetadata {
                                        name: "index",
                                        ty: Compact(
                                            U32
                                        )
                                    }
                                ],
                                documentation: [
                                    " Claim that `signed` is one of the top Self::carry_count() + current_vote().1 candidates.",
                                    " Only works if the `block_number >= current_vote().0` and `< current_vote().0 + presentation_duration()``",
                                    " `signed` should have at least"
                                ]
                            },
                            FunctionMetadata {
                                name: "set_desired_seats",
                                arguments: [
                                    FunctionArgumentMetadata {
                                        name: "count",
                                        ty: Compact(
                                            U32
                                        )
                                    }
                                ],
                                documentation: [
                                    " Set the desired member count; if lower than the current count, then seats will not be up",
                                    " election when they expire. If more, then a new vote will be started if one is not already",
                                    " in progress."
                                ]
                            },
                            FunctionMetadata {
                                name: "remove_member",
                                arguments: [
                                    FunctionArgumentMetadata {
                                        name: "who",
                                        ty: Custom(
                                            "srml_indices::address",
                                            "Address"
                                        )
                                    }
                                ],
                                documentation: [
                                    " Remove a particular member. A tally will happen instantly (if not already in a presentation",
                                    " period) to fill the seat if removal means that the desired members are not met.",
                                    " This is effective immediately."
                                ]
                            },
                            FunctionMetadata {
                                name: "set_presentation_duration",
                                arguments: [
                                    FunctionArgumentMetadata {
                                        name: "count",
                                        ty: Compact(
                                            U64
                                        )
                                    }
                                ],
                                documentation: [
                                    " Set the presentation duration. If there is currently a vote being presented for, will",
                                    " invoke `finalise_vote`."
                                ]
                            },
                            FunctionMetadata {
                                name: "set_term_duration",
                                arguments: [
                                    FunctionArgumentMetadata {
                                        name: "count",
                                        ty: Compact(
                                            U64
                                        )
                                    }
                                ],
                                documentation: [
                                    " Set the presentation duration. If there is current a vote being presented for, will",
                                    " invoke `finalise_vote`."
                                ]
                            }
                        ]
                    ),
                    event: Some(
                        [
                            EventMetadata {
                                name: "VoterReaped",
                                arguments: [
                                    Custom(
                                        "sr_primitives",
                                        "AccountId"
                                    ),
                                    Custom(
                                        "sr_primitives",
                                        "AccountId"
                                    )
                                ],
                                documentation: [
                                    " reaped voter, reaper"
                                ]
                            },
                            EventMetadata {
                                name: "BadReaperSlashed",
                                arguments: [
                                    Custom(
                                        "sr_primitives",
                                        "AccountId"
                                    )
                                ],
                                documentation: [
                                    " slashed reaper"
                                ]
                            },
                            EventMetadata {
                                name: "TallyStarted",
                                arguments: [
                                    U32
                                ],
                                documentation: [
                                    " A tally (for approval votes of council seat(s)) has started."
                                ]
                            },
                            EventMetadata {
                                name: "TallyFinalised",
                                arguments: [
                                    Vector(
                                        Custom(
                                            "sr_primitives",
                                            "AccountId"
                                        )
                                    ),
                                    Vector(
                                        Custom(
                                            "sr_primitives",
                                            "AccountId"
                                        )
                                    )
                                ],
                                documentation: [
                                    " A tally (for approval votes of council seat(s)) has ended (with one or more new members)."
                                ]
                            }
                        ]
                    )
                },
                ModuleMetadata {
                    name: "council_voting",
                    prefix: "CouncilVoting",
                    storage: Some(
                        [
                            StorageFunctionMetadata {
                                name: "CooloffPeriod",
                                modifier: Default,
                                ty: Plain(
                                    U64
                                ),
                                default: [
                                    232,
                                    3,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0
                                ],
                                documentation: []
                            },
                            StorageFunctionMetadata {
                                name: "VotingPeriod",
                                modifier: Default,
                                ty: Plain(
                                    U64
                                ),
                                default: [
                                    3,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0
                                ],
                                documentation: []
                            },
                            StorageFunctionMetadata {
                                name: "EnactDelayPeriod",
                                modifier: Default,
                                ty: Plain(
                                    U64
                                ),
                                default: [
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0
                                ],
                                documentation: [
                                    " Number of blocks by which to delay enactment of successful, non-unanimous-council-instigated referendum proposals."
                                ]
                            },
                            StorageFunctionMetadata {
                                name: "Proposals",
                                modifier: Default,
                                ty: Plain(
                                    Vector(
                                        Tuple(
                                            [
                                                U64,
                                                H256
                                            ]
                                        )
                                    )
                                ),
                                default: [
                                    0
                                ],
                                documentation: []
                            },
                            StorageFunctionMetadata {
                                name: "ProposalOf",
                                modifier: Optional,
                                ty: Map {
                                    key: H256,
                                    value: Custom(
                                        "node_runtime",
                                        "Call"
                                    )
                                },
                                default: [
                                    0
                                ],
                                documentation: []
                            },
                            StorageFunctionMetadata {
                                name: "ProposalVoters",
                                modifier: Default,
                                ty: Map {
                                    key: H256,
                                    value: Vector(
                                        Custom(
                                            "sr_primitives",
                                            "AccountId"
                                        )
                                    )
                                },
                                default: [
                                    0
                                ],
                                documentation: []
                            },
                            StorageFunctionMetadata {
                                name: "CouncilVoteOf",
                                modifier: Optional,
                                ty: Map {
                                    key: Tuple(
                                        [
                                            H256,
                                            Custom(
                                                "sr_primitives",
                                                "AccountId"
                                            )
                                        ]
                                    ),
                                    value: Bool
                                },
                                default: [
                                    0
                                ],
                                documentation: []
                            },
                            StorageFunctionMetadata {
                                name: "VetoedProposal",
                                modifier: Optional,
                                ty: Map {
                                    key: H256,
                                    value: Tuple(
                                        [
                                            U64,
                                            Vector(
                                                Custom(
                                                    "sr_primitives",
                                                    "AccountId"
                                                )
                                            )
                                        ]
                                    )
                                },
                                default: [
                                    0
                                ],
                                documentation: []
                            }
                        ]
                    ),
                    calls: Some(
                        [
                            FunctionMetadata {
                                name: "propose",
                                arguments: [
                                    FunctionArgumentMetadata {
                                        name: "proposal",
                                        ty: Custom(
                                            "node_runtime",
                                            "Call"
                                        )
                                    }
                                ],
                                documentation: []
                            },
                            FunctionMetadata {
                                name: "vote",
                                arguments: [
                                    FunctionArgumentMetadata {
                                        name: "proposal",
                                        ty: H256
                                    },
                                    FunctionArgumentMetadata {
                                        name: "approve",
                                        ty: Bool
                                    }
                                ],
                                documentation: []
                            },
                            FunctionMetadata {
                                name: "veto",
                                arguments: [
                                    FunctionArgumentMetadata {
                                        name: "proposal_hash",
                                        ty: H256
                                    }
                                ],
                                documentation: []
                            },
                            FunctionMetadata {
                                name: "set_cooloff_period",
                                arguments: [
                                    FunctionArgumentMetadata {
                                        name: "blocks",
                                        ty: Compact(
                                            U64
                                        )
                                    }
                                ],
                                documentation: []
                            },
                            FunctionMetadata {
                                name: "set_voting_period",
                                arguments: [
                                    FunctionArgumentMetadata {
                                        name: "blocks",
                                        ty: Compact(
                                            U64
                                        )
                                    }
                                ],
                                documentation: []
                            }
                        ]
                    ),
                    event: Some(
                        [
                            EventMetadata {
                                name: "TallyCancelation",
                                arguments: [
                                    H256,
                                    U32,
                                    U32,
                                    U32
                                ],
                                documentation: [
                                    " A voting tally has happened for a referendum cancellation vote.",
                                    " Last three are yes, no, abstain counts."
                                ]
                            },
                            EventMetadata {
                                name: "TallyReferendum",
                                arguments: [
                                    H256,
                                    U32,
                                    U32,
                                    U32
                                ],
                                documentation: [
                                    " A voting tally has happened for a referendum vote.",
                                    " Last three are yes, no, abstain counts."
                                ]
                            }
                        ]
                    )
                },
                ModuleMetadata {
                    name: "council_motions",
                    prefix: "CouncilMotions",
                    storage: Some(
                        [
                            StorageFunctionMetadata {
                                name: "Proposals",
                                modifier: Default,
                                ty: Plain(
                                    Vector(
                                        H256
                                    )
                                ),
                                default: [
                                    0
                                ],
                                documentation: [
                                    " The (hashes of) the active proposals."
                                ]
                            },
                            StorageFunctionMetadata {
                                name: "ProposalOf",
                                modifier: Optional,
                                ty: Map {
                                    key: H256,
                                    value: Custom(
                                        "node_runtime",
                                        "Call"
                                    )
                                },
                                default: [
                                    0
                                ],
                                documentation: [
                                    " Actual proposal for a given hash, if it\'s current."
                                ]
                            },
                            StorageFunctionMetadata {
                                name: "Voting",
                                modifier: Optional,
                                ty: Map {
                                    key: H256,
                                    value: Tuple(
                                        [
                                            U32,
                                            U32,
                                            Vector(
                                                Custom(
                                                    "sr_primitives",
                                                    "AccountId"
                                                )
                                            ),
                                            Vector(
                                                Custom(
                                                    "sr_primitives",
                                                    "AccountId"
                                                )
                                            )
                                        ]
                                    )
                                },
                                default: [
                                    0
                                ],
                                documentation: [
                                    " Votes for a given proposal: (required_yes_votes, yes_voters, no_voters)."
                                ]
                            },
                            StorageFunctionMetadata {
                                name: "ProposalCount",
                                modifier: Default,
                                ty: Plain(
                                    U32
                                ),
                                default: [
                                    0,
                                    0,
                                    0,
                                    0
                                ],
                                documentation: [
                                    " Proposals so far."
                                ]
                            }
                        ]
                    ),
                    calls: Some(
                        [
                            FunctionMetadata {
                                name: "propose",
                                arguments: [
                                    FunctionArgumentMetadata {
                                        name: "threshold",
                                        ty: Compact(
                                            U32
                                        )
                                    },
                                    FunctionArgumentMetadata {
                                        name: "proposal",
                                        ty: Custom(
                                            "node_runtime",
                                            "Call"
                                        )
                                    }
                                ],
                                documentation: []
                            },
                            FunctionMetadata {
                                name: "vote",
                                arguments: [
                                    FunctionArgumentMetadata {
                                        name: "proposal",
                                        ty: H256
                                    },
                                    FunctionArgumentMetadata {
                                        name: "index",
                                        ty: Compact(
                                            U32
                                        )
                                    },
                                    FunctionArgumentMetadata {
                                        name: "approve",
                                        ty: Bool
                                    }
                                ],
                                documentation: []
                            }
                        ]
                    ),
                    event: Some(
                        [
                            EventMetadata {
                                name: "Proposed",
                                arguments: [
                                    Custom(
                                        "sr_primitives",
                                        "AccountId"
                                    ),
                                    U32,
                                    H256,
                                    U32
                                ],
                                documentation: [
                                    " A motion (given hash) has been proposed (by given account) with a threshold (given u32)."
                                ]
                            },
                            EventMetadata {
                                name: "Voted",
                                arguments: [
                                    Custom(
                                        "sr_primitives",
                                        "AccountId"
                                    ),
                                    H256,
                                    Bool,
                                    U32,
                                    U32
                                ],
                                documentation: [
                                    " A motion (given hash) has been voted on by given account, leaving",
                                    " a tally (yes votes and no votes given as u32s respectively)."
                                ]
                            },
                            EventMetadata {
                                name: "Approved",
                                arguments: [
                                    H256
                                ],
                                documentation: [
                                    " A motion was approved by the required threshold."
                                ]
                            },
                            EventMetadata {
                                name: "Disapproved",
                                arguments: [
                                    H256
                                ],
                                documentation: [
                                    " A motion was not approved by the required threshold."
                                ]
                            },
                            EventMetadata {
                                name: "Executed",
                                arguments: [
                                    H256,
                                    Bool
                                ],
                                documentation: [
                                    " A motion was executed; `bool` is true if returned without error."
                                ]
                            }
                        ]
                    )
                },
                ModuleMetadata {
                    name: "grandpa",
                    prefix: "GrandpaFinality",
                    storage: Some(
                        [
                            StorageFunctionMetadata {
                                name: "PendingChange",
                                modifier: Optional,
                                ty: Plain(
                                    CustomWithGenerics(
                                        "srml_grandpa",
                                        "StoredPendingChange",
                                        [
                                            U64,
                                            Custom(
                                                "substrate_primitives::authority_id",
                                                "Ed25519AuthorityId"
                                            )
                                        ]
                                    )
                                ),
                                default: [
                                    0
                                ],
                                documentation: []
                            }
                        ]
                    ),
                    calls: Some(
                        [
                            FunctionMetadata {
                                name: "report_misbehavior",
                                arguments: [
                                    FunctionArgumentMetadata {
                                        name: "_report",
                                        ty: Vector(
                                            U8
                                        )
                                    }
                                ],
                                documentation: [
                                    " Report some misbehaviour."
                                ]
                            }
                        ]
                    ),
                    event: Some(
                        [
                            EventMetadata {
                                name: "NewAuthorities",
                                arguments: [
                                    Vector(
                                        Tuple(
                                            [
                                                Custom(
                                                    "substrate_primitives::authority_id",
                                                    "Ed25519AuthorityId"
                                                ),
                                                U64
                                            ]
                                        )
                                    )
                                ],
                                documentation: [
                                    " New authority set has been applied."
                                ]
                            }
                        ]
                    )
                },
                ModuleMetadata {
                    name: "treasury",
                    prefix: "Treasury",
                    storage: Some(
                        [
                            StorageFunctionMetadata {
                                name: "ProposalBond",
                                modifier: Default,
                                ty: Plain(
                                    Custom(
                                        "sr_primitives",
                                        "Permill"
                                    )
                                ),
                                default: [
                                    0,
                                    0,
                                    0,
                                    0
                                ],
                                documentation: [
                                    " Proportion of funds that should be bonded in order to place a proposal. An accepted",
                                    " proposal gets these back. A rejected proposal doesn\'t."
                                ]
                            },
                            StorageFunctionMetadata {
                                name: "ProposalBondMinimum",
                                modifier: Default,
                                ty: Plain(
                                    U128
                                ),
                                default: [
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0
                                ],
                                documentation: [
                                    " Minimum amount of funds that should be placed in a deposit for making a proposal."
                                ]
                            },
                            StorageFunctionMetadata {
                                name: "SpendPeriod",
                                modifier: Default,
                                ty: Plain(
                                    U64
                                ),
                                default: [
                                    1,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0
                                ],
                                documentation: [
                                    " Period between successive spends."
                                ]
                            },
                            StorageFunctionMetadata {
                                name: "Burn",
                                modifier: Default,
                                ty: Plain(
                                    Custom(
                                        "sr_primitives",
                                        "Permill"
                                    )
                                ),
                                default: [
                                    0,
                                    0,
                                    0,
                                    0
                                ],
                                documentation: [
                                    " Percentage of spare funds (if any) that are burnt per spend period."
                                ]
                            },
                            StorageFunctionMetadata {
                                name: "Pot",
                                modifier: Default,
                                ty: Plain(
                                    U128
                                ),
                                default: [
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0
                                ],
                                documentation: [
                                    " Total funds available to this module for spending."
                                ]
                            },
                            StorageFunctionMetadata {
                                name: "ProposalCount",
                                modifier: Default,
                                ty: Plain(
                                    U32
                                ),
                                default: [
                                    0,
                                    0,
                                    0,
                                    0
                                ],
                                documentation: [
                                    " Number of proposals that have been made."
                                ]
                            },
                            StorageFunctionMetadata {
                                name: "Proposals",
                                modifier: Optional,
                                ty: Map {
                                    key: U32,
                                    value: CustomWithGenerics(
                                        "srml_treasury",
                                        "Proposal",
                                        [
                                            Custom(
                                                "sr_primitives",
                                                "AccountId"
                                            ),
                                            U128
                                        ]
                                    )
                                },
                                default: [
                                    0
                                ],
                                documentation: [
                                    " Proposals that have been made."
                                ]
                            },
                            StorageFunctionMetadata {
                                name: "Approvals",
                                modifier: Default,
                                ty: Plain(
                                    Vector(
                                        U32
                                    )
                                ),
                                default: [
                                    0
                                ],
                                documentation: [
                                    " Proposal indices that have been approved but not yet awarded."
                                ]
                            }
                        ]
                    ),
                    calls: Some(
                        [
                            FunctionMetadata {
                                name: "propose_spend",
                                arguments: [
                                    FunctionArgumentMetadata {
                                        name: "value",
                                        ty: Compact(
                                            U128
                                        )
                                    },
                                    FunctionArgumentMetadata {
                                        name: "beneficiary",
                                        ty: Custom(
                                            "srml_indices::address",
                                            "Address"
                                        )
                                    }
                                ],
                                documentation: [
                                    " Put forward a suggestion for spending. A deposit proportional to the value",
                                    " is reserved and slashed if the proposal is rejected. It is returned once the",
                                    " proposal is awarded."
                                ]
                            },
                            FunctionMetadata {
                                name: "set_pot",
                                arguments: [
                                    FunctionArgumentMetadata {
                                        name: "new_pot",
                                        ty: Compact(
                                            U128
                                        )
                                    }
                                ],
                                documentation: [
                                    " Set the balance of funds available to spend."
                                ]
                            },
                            FunctionMetadata {
                                name: "configure",
                                arguments: [
                                    FunctionArgumentMetadata {
                                        name: "proposal_bond",
                                        ty: Compact(
                                            Custom(
                                                "sr_primitives",
                                                "Permill"
                                            )
                                        )
                                    },
                                    FunctionArgumentMetadata {
                                        name: "proposal_bond_minimum",
                                        ty: Compact(
                                            U128
                                        )
                                    },
                                    FunctionArgumentMetadata {
                                        name: "spend_period",
                                        ty: Compact(
                                            U64
                                        )
                                    },
                                    FunctionArgumentMetadata {
                                        name: "burn",
                                        ty: Compact(
                                            Custom(
                                                "sr_primitives",
                                                "Permill"
                                            )
                                        )
                                    }
                                ],
                                documentation: [
                                    " (Re-)configure this module."
                                ]
                            },
                            FunctionMetadata {
                                name: "reject_proposal",
                                arguments: [
                                    FunctionArgumentMetadata {
                                        name: "proposal_id",
                                        ty: Compact(
                                            U32
                                        )
                                    }
                                ],
                                documentation: [
                                    " Reject a proposed spend. The original deposit will be slashed."
                                ]
                            },
                            FunctionMetadata {
                                name: "approve_proposal",
                                arguments: [
                                    FunctionArgumentMetadata {
                                        name: "proposal_id",
                                        ty: Compact(
                                            U32
                                        )
                                    }
                                ],
                                documentation: [
                                    " Approve a proposal. At a later time, the proposal will be allocated to the beneficiary",
                                    " and the original deposit will be returned."
                                ]
                            }
                        ]
                    ),
                    event: Some(
                        [
                            EventMetadata {
                                name: "Proposed",
                                arguments: [
                                    U32
                                ],
                                documentation: [
                                    " New proposal."
                                ]
                            },
                            EventMetadata {
                                name: "Spending",
                                arguments: [
                                    U128
                                ],
                                documentation: [
                                    " We have ended a spend period and will now allocate funds."
                                ]
                            },
                            EventMetadata {
                                name: "Awarded",
                                arguments: [
                                    U32,
                                    U128,
                                    Custom(
                                        "sr_primitives",
                                        "AccountId"
                                    )
                                ],
                                documentation: [
                                    " Some funds have been allocated."
                                ]
                            },
                            EventMetadata {
                                name: "Burnt",
                                arguments: [
                                    U128
                                ],
                                documentation: [
                                    " Some of our funds have been burnt."
                                ]
                            },
                            EventMetadata {
                                name: "Rollover",
                                arguments: [
                                    U128
                                ],
                                documentation: [
                                    " Spending has finished; this is the amount that rolls over until next spend."
                                ]
                            }
                        ]
                    )
                },
                ModuleMetadata {
                    name: "contract",
                    prefix: "Contract",
                    storage: Some(
                        [
                            StorageFunctionMetadata {
                                name: "ContractFee",
                                modifier: Default,
                                ty: Plain(
                                    U128
                                ),
                                default: [
                                    21,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0
                                ],
                                documentation: [
                                    " The fee required to create a contract. At least as big as staking\'s ReclaimRebate."
                                ]
                            },
                            StorageFunctionMetadata {
                                name: "CallBaseFee",
                                modifier: Default,
                                ty: Plain(
                                    U64
                                ),
                                default: [
                                    135,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0
                                ],
                                documentation: [
                                    " The fee charged for a call into a contract."
                                ]
                            },
                            StorageFunctionMetadata {
                                name: "CreateBaseFee",
                                modifier: Default,
                                ty: Plain(
                                    U64
                                ),
                                default: [
                                    175,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0
                                ],
                                documentation: [
                                    " The fee charged for a create of a contract."
                                ]
                            },
                            StorageFunctionMetadata {
                                name: "GasPrice",
                                modifier: Default,
                                ty: Plain(
                                    U128
                                ),
                                default: [
                                    1,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0
                                ],
                                documentation: [
                                    " The price of one unit of gas."
                                ]
                            },
                            StorageFunctionMetadata {
                                name: "MaxDepth",
                                modifier: Default,
                                ty: Plain(
                                    U32
                                ),
                                default: [
                                    100,
                                    0,
                                    0,
                                    0
                                ],
                                documentation: [
                                    " The maximum nesting level of a call/create stack."
                                ]
                            },
                            StorageFunctionMetadata {
                                name: "BlockGasLimit",
                                modifier: Default,
                                ty: Plain(
                                    U64
                                ),
                                default: [
                                    64,
                                    66,
                                    15,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0
                                ],
                                documentation: [
                                    " The maximum amount of gas that could be expended per block."
                                ]
                            },
                            StorageFunctionMetadata {
                                name: "GasSpent",
                                modifier: Default,
                                ty: Plain(
                                    U64
                                ),
                                default: [
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0
                                ],
                                documentation: [
                                    " Gas spent so far in this block."
                                ]
                            },
                            StorageFunctionMetadata {
                                name: "CurrentSchedule",
                                modifier: Default,
                                ty: Plain(
                                    CustomWithGenerics(
                                        "srml_contract",
                                        "Schedule",
                                        [
                                            U64
                                        ]
                                    )
                                ),
                                default: [
                                    0,
                                    0,
                                    0,
                                    0,
                                    1,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    1,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    1,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    1,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    1,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    1,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    1,
                                    0,
                                    16,
                                    0,
                                    0,
                                    0
                                ],
                                documentation: [
                                    " Current cost schedule for contracts."
                                ]
                            },
                            StorageFunctionMetadata {
                                name: "CodeHashOf",
                                modifier: Optional,
                                ty: Map {
                                    key: Custom(
                                        "sr_primitives",
                                        "AccountId"
                                    ),
                                    value: H256
                                },
                                default: [
                                    0
                                ],
                                documentation: [
                                    " The code associated with a given account."
                                ]
                            },
                            StorageFunctionMetadata {
                                name: "PristineCode",
                                modifier: Optional,
                                ty: Map {
                                    key: H256,
                                    value: Vector(
                                        U8
                                    )
                                },
                                default: [
                                    0
                                ],
                                documentation: [
                                    " A mapping from an original code hash to the original code, untouched by instrumentation."
                                ]
                            },
                            StorageFunctionMetadata {
                                name: "CodeStorage",
                                modifier: Optional,
                                ty: Map {
                                    key: H256,
                                    value: Custom(
                                        "srml_contract::wasm",
                                        "PrefabWasmModule"
                                    )
                                },
                                default: [
                                    0
                                ],
                                documentation: [
                                    " A mapping between an original code hash and instrumented wasm code, ready for the execution."
                                ]
                            }
                        ]
                    ),
                    calls: Some(
                        [
                            FunctionMetadata {
                                name: "update_schedule",
                                arguments: [
                                    FunctionArgumentMetadata {
                                        name: "schedule",
                                        ty: CustomWithGenerics(
                                            "srml_contract",
                                            "Schedule",
                                            [
                                                U64
                                            ]
                                        )
                                    }
                                ],
                                documentation: [
                                    " Updates the schedule for metering contracts.",
                                    "",
                                    " The schedule must have a greater version than the stored schedule."
                                ]
                            },
                            FunctionMetadata {
                                name: "put_code",
                                arguments: [
                                    FunctionArgumentMetadata {
                                        name: "gas_limit",
                                        ty: Compact(
                                            U64
                                        )
                                    },
                                    FunctionArgumentMetadata {
                                        name: "code",
                                        ty: Vector(
                                            U8
                                        )
                                    }
                                ],
                                documentation: [
                                    " Stores code in the storage. You can instantiate contracts only with stored code."
                                ]
                            },
                            FunctionMetadata {
                                name: "call",
                                arguments: [
                                    FunctionArgumentMetadata {
                                        name: "dest",
                                        ty: Custom(
                                            "srml_indices::address",
                                            "Address"
                                        )
                                    },
                                    FunctionArgumentMetadata {
                                        name: "value",
                                        ty: Compact(
                                            U128
                                        )
                                    },
                                    FunctionArgumentMetadata {
                                        name: "gas_limit",
                                        ty: Compact(
                                            U64
                                        )
                                    },
                                    FunctionArgumentMetadata {
                                        name: "data",
                                        ty: Vector(
                                            U8
                                        )
                                    }
                                ],
                                documentation: [
                                    " Make a call to a specified account, optionally transferring some balance."
                                ]
                            },
                            FunctionMetadata {
                                name: "create",
                                arguments: [
                                    FunctionArgumentMetadata {
                                        name: "endowment",
                                        ty: Compact(
                                            U128
                                        )
                                    },
                                    FunctionArgumentMetadata {
                                        name: "gas_limit",
                                        ty: Compact(
                                            U64
                                        )
                                    },
                                    FunctionArgumentMetadata {
                                        name: "code_hash",
                                        ty: H256
                                    },
                                    FunctionArgumentMetadata {
                                        name: "data",
                                        ty: Vector(
                                            U8
                                        )
                                    }
                                ],
                                documentation: [
                                    " Create a new contract, optionally transfering some balance to the created account.",
                                    "",
                                    " Creation is executed as follows:",
                                    "",
                                    " - the destination address is computed based on the sender and hash of the code.",
                                    " - account is created at the computed address.",
                                    " - the `ctor_code` is executed in the context of the newly created account. Buffer returned",
                                    "   after the execution is saved as the `code` of the account. That code will be invoked",
                                    "   upon any message received by this account."
                                ]
                            }
                        ]
                    ),
                    event: Some(
                        [
                            EventMetadata {
                                name: "Transfer",
                                arguments: [
                                    Custom(
                                        "sr_primitives",
                                        "AccountId"
                                    ),
                                    Custom(
                                        "sr_primitives",
                                        "AccountId"
                                    ),
                                    U128
                                ],
                                documentation: [
                                    " Transfer happened `from` -> `to` with given `value` as part of a `message-call` or `create`."
                                ]
                            },
                            EventMetadata {
                                name: "Instantiated",
                                arguments: [
                                    Custom(
                                        "sr_primitives",
                                        "AccountId"
                                    ),
                                    Custom(
                                        "sr_primitives",
                                        "AccountId"
                                    )
                                ],
                                documentation: [
                                    " Contract deployed by address at the specified address."
                                ]
                            },
                            EventMetadata {
                                name: "CodeStored",
                                arguments: [
                                    H256
                                ],
                                documentation: [
                                    " Code with the specified hash has been stored."
                                ]
                            },
                            EventMetadata {
                                name: "ScheduleUpdated",
                                arguments: [
                                    U32
                                ],
                                documentation: [
                                    " Triggered when the current schedule is updated."
                                ]
                            },
                            EventMetadata {
                                name: "Dispatched",
                                arguments: [
                                    Custom(
                                        "sr_primitives",
                                        "AccountId"
                                    ),
                                    Bool
                                ],
                                documentation: [
                                    " A call was dispatched from the given account. The bool signals whether it was",
                                    " successful execution or not."
                                ]
                            }
                        ]
                    )
                },
                ModuleMetadata {
                    name: "sudo",
                    prefix: "Sudo",
                    storage: Some(
                        [
                            StorageFunctionMetadata {
                                name: "Key",
                                modifier: Default,
                                ty: Plain(
                                    Custom(
                                        "sr_primitives",
                                        "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: []
                            }
                        ]
                    ),
                    calls: Some(
                        [
                            FunctionMetadata {
                                name: "sudo",
                                arguments: [
                                    FunctionArgumentMetadata {
                                        name: "proposal",
                                        ty: Custom(
                                            "node_runtime",
                                            "Call"
                                        )
                                    }
                                ],
                                documentation: []
                            },
                            FunctionMetadata {
                                name: "set_key",
                                arguments: [
                                    FunctionArgumentMetadata {
                                        name: "new",
                                        ty: Custom(
                                            "srml_indices::address",
                                            "Address"
                                        )
                                    }
                                ],
                                documentation: []
                            }
                        ]
                    ),
                    event: Some(
                        [
                            EventMetadata {
                                name: "Sudid",
                                arguments: [
                                    Bool
                                ],
                                documentation: [
                                    " A sudo just took place."
                                ]
                            },
                            EventMetadata {
                                name: "KeyChanged",
                                arguments: [
                                    Custom(
                                        "sr_primitives",
                                        "AccountId"
                                    )
                                ],
                                documentation: [
                                    " The sudoer just switched identity; the old key is supplied."
                                ]
                            }
                        ]
                    )
                },
                ModuleMetadata {
                    name: "fees",
                    prefix: "Fees",
                    storage: Some(
                        [
                            StorageFunctionMetadata {
                                name: "TransactionBaseFee",
                                modifier: Default,
                                ty: Plain(
                                    U128
                                ),
                                default: [
                                    0,
                                    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 base."
                                ]
                            },
                            StorageFunctionMetadata {
                                name: "TransactionByteFee",
                                modifier: Default,
                                ty: Plain(
                                    U128
                                ),
                                default: [
                                    0,
                                    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."
                                ]
                            },
                            StorageFunctionMetadata {
                                name: "CurrentTransactionFee",
                                modifier: Default,
                                ty: Map {
                                    key: U32,
                                    value: U128
                                },
                                default: [
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0
                                ],
                                documentation: [
                                    " The `extrinsic_index => accumulated_fees` map, containing records to",
                                    " track the overall charged fees for each transaction.",
                                    "",
                                    " All records should be removed at finalise stage."
                                ]
                            }
                        ]
                    ),
                    calls: None,
                    event: Some(
                        [
                            EventMetadata {
                                name: "Charged",
                                arguments: [
                                    U32,
                                    U128
                                ],
                                documentation: [
                                    " Fee charged (extrinsic_index, fee_amount)"
                                ]
                            }
                        ]
                    )
                }
            ],
            type_registry: MetadataRegistry {
                list: [
                    TypeMetadata {
                        name: CustomWithGenerics(
                            "sr_primitives::generic::block",
                            "Block",
                            [
                                CustomWithGenerics(
                                    "sr_primitives::generic::header",
                                    "Header",
                                    [
                                        U64,
                                        Custom(
                                            "sr_primitives::traits",
                                            "BlakeTwo256"
                                        ),
                                        Custom(
                                            "node_runtime",
                                            "Log"
                                        )
                                    ]
                                ),
                                CustomWithGenerics(
                                    "sr_primitives::generic::unchecked_mortal_compact_extrinsic",
                                    "UncheckedMortalCompactExtrinsic",
                                    [
                                        Custom(
                                            "srml_indices::address",
                                            "Address"
                                        ),
                                        U64,
                                        Custom(
                                            "node_runtime",
                                            "Call"
                                        ),
                                        Custom(
                                            "sr_primitives",
                                            "Ed25519Signature"
                                        )
                                    ]
                                )
                            ]
                        ),
                        kind: Struct(
                            [
                                FieldMetadata {
                                    name: Named(
                                        "header"
                                    ),
                                    ty: CustomWithGenerics(
                                        "sr_primitives::generic::header",
                                        "Header",
                                        [
                                            U64,
                                            Custom(
                                                "sr_primitives::traits",
                                                "BlakeTwo256"
                                            ),
                                            Custom(
                                                "node_runtime",
                                                "Log"
                                            )
                                        ]
                                    )
                                },
                                FieldMetadata {
                                    name: Named(
                                        "extrinsics"
                                    ),
                                    ty: Vector(
                                        CustomWithGenerics(
                                            "sr_primitives::generic::unchecked_mortal_compact_extrinsic",
                                            "UncheckedMortalCompactExtrinsic",
                                            [
                                                Custom(
                                                    "srml_indices::address",
                                                    "Address"
                                                ),
                                                U64,
                                                Custom(
                                                    "node_runtime",
                                                    "Call"
                                                ),
                                                Custom(
                                                    "sr_primitives",
                                                    "Ed25519Signature"
                                                )
                                            ]
                                        )
                                    )
                                }
                            ]
                        )
                    },
                    TypeMetadata {
                        name: CustomWithGenerics(
                            "sr_primitives::generic::header",
                            "Header",
                            [
                                U64,
                                Custom(
                                    "sr_primitives::traits",
                                    "BlakeTwo256"
                                ),
                                Custom(
                                    "node_runtime",
                                    "Log"
                                )
                            ]
                        ),
                        kind: Struct(
                            [
                                FieldMetadata {
                                    name: Named(
                                        "parent_hash"
                                    ),
                                    ty: H256
                                },
                                FieldMetadata {
                                    name: Named(
                                        "number"
                                    ),
                                    ty: U64
                                },
                                FieldMetadata {
                                    name: Named(
                                        "state_root"
                                    ),
                                    ty: H256
                                },
                                FieldMetadata {
                                    name: Named(
                                        "extrinsics_root"
                                    ),
                                    ty: H256
                                },
                                FieldMetadata {
                                    name: Named(
                                        "digest"
                                    ),
                                    ty: CustomWithGenerics(
                                        "sr_primitives::generic::digest",
                                        "Digest",
                                        [
                                            Custom(
                                                "node_runtime",
                                                "Log"
                                            )
                                        ]
                                    )
                                }
                            ]
                        )
                    },
                    TypeMetadata {
                        name: CustomWithGenerics(
                            "sr_primitives::generic::digest",
                            "Digest",
                            [
                                Custom(
                                    "node_runtime",
                                    "Log"
                                )
                            ]
                        ),
                        kind: Struct(
                            [
                                FieldMetadata {
                                    name: Named(
                                        "logs"
                                    ),
                                    ty: Vector(
                                        Custom(
                                            "node_runtime",
                                            "Log"
                                        )
                                    )
                                }
                            ]
                        )
                    },
                    TypeMetadata {
                        name: Custom(
                            "node_runtime",
                            "Log"
                        ),
                        kind: Struct(
                            [
                                FieldMetadata {
                                    name: Unnamed(
                                        0
                                    ),
                                    ty: Custom(
                                        "node_runtime",
                                        "InternalLog"
                                    )
                                }
                            ]
                        )
                    },
                    TypeMetadata {
                        name: Custom(
                            "node_runtime",
                            "InternalLog"
                        ),
                        kind: Enum(
                            [
                                EnumVariantMetadata {
                                    name: "system",
                                    index: 0,
                                    fields: [
                                        FieldMetadata {
                                            name: Unnamed(
                                                0
                                            ),
                                            ty: CustomWithGenerics(
                                                "srml_system",
                                                "RawLog",
                                                [
                                                    H256
                                                ]
                                            )
                                        }
                                    ]
                                },
                                EnumVariantMetadata {
                                    name: "consensus",
                                    index: 1,
                                    fields: [
                                        FieldMetadata {
                                            name: Unnamed(
                                                0
                                            ),
                                            ty: CustomWithGenerics(
                                                "srml_consensus",
                                                "RawLog",
                                                [
                                                    Custom(
                                                        "substrate_primitives::authority_id",
                                                        "Ed25519AuthorityId"
                                                    )
                                                ]
                                            )
                                        }
                                    ]
                                },
                                EnumVariantMetadata {
                                    name: "grandpa",
                                    index: 2,
                                    fields: [
                                        FieldMetadata {
                                            name: Unnamed(
                                                0
                                            ),
                                            ty: CustomWithGenerics(
                                                "srml_grandpa",
                                                "RawLog",
                                                [
                                                    U64,
                                                    Custom(
                                                        "substrate_primitives::authority_id",
                                                        "Ed25519AuthorityId"
                                                    )
                                                ]
                                            )
                                        }
                                    ]
                                }
                            ]
                        )
                    },
                    TypeMetadata {
                        name: CustomWithGenerics(
                            "srml_system",
                            "RawLog",
                            [
                                H256
                            ]
                        ),
                        kind: Enum(
                            [
                                EnumVariantMetadata {
                                    name: "ChangesTrieRoot",
                                    index: 0,
                                    fields: [
                                        FieldMetadata {
                                            name: Unnamed(
                                                0
                                            ),
                                            ty: H256
                                        }
                                    ]
                                }
                            ]
                        )
                    },
                    TypeMetadata {
                        name: CustomWithGenerics(
                            "srml_consensus",
                            "RawLog",
                            [
                                Custom(
                                    "substrate_primitives::authority_id",
                                    "Ed25519AuthorityId"
                                )
                            ]
                        ),
                        kind: Enum(
                            [
                                EnumVariantMetadata {
                                    name: "AuthoritiesChange",
                                    index: 0,
                                    fields: [
                                        FieldMetadata {
                                            name: Unnamed(
                                                0
                                            ),
                                            ty: Vector(
                                                Custom(
                                                    "substrate_primitives::authority_id",
                                                    "Ed25519AuthorityId"
                                                )
                                            )
                                        }
                                    ]
                                }
                            ]
                        )
                    },
                    TypeMetadata {
                        name: Custom(
                            "substrate_primitives::authority_id",
                            "Ed25519AuthorityId"
                        ),
                        kind: Struct(
                            [
                                FieldMetadata {
                                    name: Unnamed(
                                        0
                                    ),
                                    ty: Array(
                                        32,
                                        U8
                                    )
                                }
                            ]
                        )
                    },
                    TypeMetadata {
                        name: CustomWithGenerics(
                            "srml_grandpa",
                            "RawLog",
                            [
                                U64,
                                Custom(
                                    "substrate_primitives::authority_id",
                                    "Ed25519AuthorityId"
                                )
                            ]
                        ),
                        kind: Enum(
                            [
                                EnumVariantMetadata {
                                    name: "AuthoritiesChangeSignal",
                                    index: 0,
                                    fields: [
                                        FieldMetadata {
                                            name: Unnamed(
                                                0
                                            ),
                                            ty: U64
                                        },
                                        FieldMetadata {
                                            name: Unnamed(
                                                1
                                            ),
                                            ty: Vector(
                                                Tuple(
                                                    [
                                                        Custom(
                                                            "substrate_primitives::authority_id",
                                                            "Ed25519AuthorityId"
                                                        ),
                                                        U64
                                                    ]
                                                )
                                            )
                                        }
                                    ]
                                }
                            ]
                        )
                    },
                    TypeMetadata {
                        name: CustomWithGenerics(
                            "sr_primitives::generic::unchecked_mortal_compact_extrinsic",
                            "UncheckedMortalCompactExtrinsic",
                            [
                                Custom(
                                    "srml_indices::address",
                                    "Address"
                                ),
                                U64,
                                Custom(
                                    "node_runtime",
                                    "Call"
                                ),
                                Custom(
                                    "sr_primitives",
                                    "Ed25519Signature"
                                )
                            ]
                        ),
                        kind: Struct(
                            [
                                FieldMetadata {
                                    name: Named(
                                        "signature"
                                    ),
                                    ty: Option(
                                        Tuple(
                                            [
                                                Custom(
                                                    "srml_indices::address",
                                                    "Address"
                                                ),
                                                Custom(
                                                    "sr_primitives",
                                                    "Ed25519Signature"
                                                ),
                                                Compact(
                                                    U64
                                                ),
                                                Custom(
                                                    "sr_primitives::generic::era",
                                                    "Era"
                                                )
                                            ]
                                        )
                                    )
                                },
                                FieldMetadata {
                                    name: Named(
                                        "function"
                                    ),
                                    ty: Custom(
                                        "node_runtime",
                                        "Call"
                                    )
                                }
                            ]
                        )
                    },
                    TypeMetadata {
                        name: Custom(
                            "srml_indices::address",
                            "Address"
                        ),
                        kind: Primitive
                    },
                    TypeMetadata {
                        name: Custom(
                            "sr_primitives",
                            "Ed25519Signature"
                        ),
                        kind: Struct(
                            [
                                FieldMetadata {
                                    name: Unnamed(
                                        0
                                    ),
                                    ty: H512
                                }
                            ]
                        )
                    },
                    TypeMetadata {
                        name: Custom(
                            "sr_primitives::generic::era",
                            "Era"
                        ),
                        kind: Enum(
                            [
                                EnumVariantMetadata {
                                    name: "Immortal",
                                    index: 0,
                                    fields: []
                                },
                                EnumVariantMetadata {
                                    name: "Mortal",
                                    index: 1,
                                    fields: [
                                        FieldMetadata {
                                            name: Unnamed(
                                                0
                                            ),
                                            ty: U64
                                        },
                                        FieldMetadata {
                                            name: Unnamed(
                                                1
                                            ),
                                            ty: U64
                                        }
                                    ]
                                }
                            ]
                        )
                    },
                    TypeMetadata {
                        name: Custom(
                            "node_runtime",
                            "Call"
                        ),
                        kind: Enum(
                            [
                                EnumVariantMetadata {
                                    name: "Timestamp",
                                    index: 0,
                                    fields: [
                                        FieldMetadata {
                                            name: Unnamed(
                                                0
                                            ),
                                            ty: Custom(
                                                "srml_timestamp",
                                                "Module"
                                            )
                                        }
                                    ]
                                },
                                EnumVariantMetadata {
                                    name: "Consensus",
                                    index: 1,
                                    fields: [
                                        FieldMetadata {
                                            name: Unnamed(
                                                0
                                            ),
                                            ty: Custom(
                                                "srml_consensus",
                                                "Module"
                                            )
                                        }
                                    ]
                                },
                                EnumVariantMetadata {
                                    name: "Indices",
                                    index: 2,
                                    fields: [
                                        FieldMetadata {
                                            name: Unnamed(
                                                0
                                            ),
                                            ty: Custom(
                                                "srml_indices",
                                                "Module"
                                            )
                                        }
                                    ]
                                },
                                EnumVariantMetadata {
                                    name: "Balances",
                                    index: 3,
                                    fields: [
                                        FieldMetadata {
                                            name: Unnamed(
                                                0
                                            ),
                                            ty: Custom(
                                                "srml_balances",
                                                "Module"
                                            )
                                        }
                                    ]
                                },
                                EnumVariantMetadata {
                                    name: "Session",
                                    index: 4,
                                    fields: [
                                        FieldMetadata {
                                            name: Unnamed(
                                                0
                                            ),
                                            ty: Custom(
                                                "srml_session",
                                                "Module"
                                            )
                                        }
                                    ]
                                },
                                EnumVariantMetadata {
                                    name: "Staking",
                                    index: 5,
                                    fields: [
                                        FieldMetadata {
                                            name: Unnamed(
                                                0
                                            ),
                                            ty: Custom(
                                                "srml_staking",
                                                "Module"
                                            )
                                        }
                                    ]
                                },
                                EnumVariantMetadata {
                                    name: "Democracy",
                                    index: 6,
                                    fields: [
                                        FieldMetadata {
                                            name: Unnamed(
                                                0
                                            ),
                                            ty: Custom(
                                                "srml_democracy",
                                                "Module"
                                            )
                                        }
                                    ]
                                },
                                EnumVariantMetadata {
                                    name: "Council",
                                    index: 7,
                                    fields: [
                                        FieldMetadata {
                                            name: Unnamed(
                                                0
                                            ),
                                            ty: Custom(
                                                "srml_council::seats",
                                                "Module"
                                            )
                                        }
                                    ]
                                },
                                EnumVariantMetadata {
                                    name: "CouncilVoting",
                                    index: 8,
                                    fields: [
                                        FieldMetadata {
                                            name: Unnamed(
                                                0
                                            ),
                                            ty: Custom(
                                                "srml_council::voting",
                                                "Module"
                                            )
                                        }
                                    ]
                                },
                                EnumVariantMetadata {
                                    name: "CouncilMotions",
                                    index: 9,
                                    fields: [
                                        FieldMetadata {
                                            name: Unnamed(
                                                0
                                            ),
                                            ty: Custom(
                                                "srml_council::motions",
                                                "Module"
                                            )
                                        }
                                    ]
                                },
                                EnumVariantMetadata {
                                    name: "Grandpa",
                                    index: 10,
                                    fields: [
                                        FieldMetadata {
                                            name: Unnamed(
                                                0
                                            ),
                                            ty: Custom(
                                                "srml_grandpa",
                                                "Module"
                                            )
                                        }
                                    ]
                                },
                                EnumVariantMetadata {
                                    name: "Treasury",
                                    index: 11,
                                    fields: [
                                        FieldMetadata {
                                            name: Unnamed(
                                                0
                                            ),
                                            ty: Custom(
                                                "srml_treasury",
                                                "Module"
                                            )
                                        }
                                    ]
                                },
                                EnumVariantMetadata {
                                    name: "Contract",
                                    index: 12,
                                    fields: [
                                        FieldMetadata {
                                            name: Unnamed(
                                                0
                                            ),
                                            ty: Custom(
                                                "srml_contract",
                                                "Module"
                                            )
                                        }
                                    ]
                                },
                                EnumVariantMetadata {
                                    name: "Sudo",
                                    index: 13,
                                    fields: [
                                        FieldMetadata {
                                            name: Unnamed(
                                                0
                                            ),
                                            ty: Custom(
                                                "srml_sudo",
                                                "Module"
                                            )
                                        }
                                    ]
                                }
                            ]
                        )
                    },
                    TypeMetadata {
                        name: Custom(
                            "srml_timestamp",
                            "Module"
                        ),
                        kind: Struct(
                            []
                        )
                    },
                    TypeMetadata {
                        name: Custom(
                            "srml_consensus",
                            "Module"
                        ),
                        kind: Struct(
                            []
                        )
                    },
                    TypeMetadata {
                        name: Custom(
                            "srml_indices",
                            "Module"
                        ),
                        kind: Struct(
                            []
                        )
                    },
                    TypeMetadata {
                        name: Custom(
                            "srml_balances",
                            "Module"
                        ),
                        kind: Struct(
                            []
                        )
                    },
                    TypeMetadata {
                        name: Custom(
                            "srml_session",
                            "Module"
                        ),
                        kind: Struct(
                            []
                        )
                    },
                    TypeMetadata {
                        name: Custom(
                            "srml_staking",
                            "Module"
                        ),
                        kind: Struct(
                            []
                        )
                    },
                    TypeMetadata {
                        name: Custom(
                            "srml_democracy",
                            "Module"
                        ),
                        kind: Struct(
                            []
                        )
                    },
                    TypeMetadata {
                        name: Custom(
                            "srml_council::seats",
                            "Module"
                        ),
                        kind: Struct(
                            []
                        )
                    },
                    TypeMetadata {
                        name: Custom(
                            "srml_council::voting",
                            "Module"
                        ),
                        kind: Struct(
                            []
                        )
                    },
                    TypeMetadata {
                        name: Custom(
                            "srml_council::motions",
                            "Module"
                        ),
                        kind: Struct(
                            []
                        )
                    },
                    TypeMetadata {
                        name: Custom(
                            "srml_grandpa",
                            "Module"
                        ),
                        kind: Struct(
                            []
                        )
                    },
                    TypeMetadata {
                        name: Custom(
                            "srml_treasury",
                            "Module"
                        ),
                        kind: Struct(
                            []
                        )
                    },
                    TypeMetadata {
                        name: Custom(
                            "srml_contract",
                            "Module"
                        ),
                        kind: Struct(
                            []
                        )
                    },
                    TypeMetadata {
                        name: Custom(
                            "srml_sudo",
                            "Module"
                        ),
                        kind: Struct(
                            []
                        )
                    },
                    TypeMetadata {
                        name: Custom(
                            "sr_primitives",
                            "AccountId"
                        ),
                        kind: Struct(
                            [
                                FieldMetadata {
                                    name: Unnamed(
                                        0
                                    ),
                                    ty: H256
                                }
                            ]
                        )
                    },
                    TypeMetadata {
                        name: CustomWithGenerics(
                            "srml_system",
                            "EventRecord",
                            [
                                Custom(
                                    "node_runtime",
                                    "Event"
                                )
                            ]
                        ),
                        kind: Struct(
                            [
                                FieldMetadata {
                                    name: Named(
                                        "phase"
                                    ),
                                    ty: Custom(
                                        "srml_system",
                                        "Phase"
                                    )
                                },
                                FieldMetadata {
                                    name: Named(
                                        "event"
                                    ),
                                    ty: Custom(
                                        "node_runtime",
                                        "Event"
                                    )
                                }
                            ]
                        )
                    },
                    TypeMetadata {
                        name: Custom(
                            "srml_system",
                            "Phase"
                        ),
                        kind: Enum(
                            [
                                EnumVariantMetadata {
                                    name: "ApplyExtrinsic",
                                    index: 0,
                                    fields: [
                                        FieldMetadata {
                                            name: Unnamed(
                                                0
                                            ),
                                            ty: U32
                                        }
                                    ]
                                },
                                EnumVariantMetadata {
                                    name: "Finalization",
                                    index: 1,
                                    fields: []
                                }
                            ]
                        )
                    },
                    TypeMetadata {
                        name: Custom(
                            "node_runtime",
                            "Event"
                        ),
                        kind: Enum(
                            [
                                EnumVariantMetadata {
                                    name: "system",
                                    index: 0,
                                    fields: [
                                        FieldMetadata {
                                            name: Unnamed(
                                                0
                                            ),
                                            ty: Custom(
                                                "srml_system",
                                                "Event"
                                            )
                                        }
                                    ]
                                },
                                EnumVariantMetadata {
                                    name: "indices",
                                    index: 1,
                                    fields: [
                                        FieldMetadata {
                                            name: Unnamed(
                                                0
                                            ),
                                            ty: CustomWithGenerics(
                                                "srml_indices",
                                                "RawEvent",
                                                [
                                                    Custom(
                                                        "sr_primitives",
                                                        "AccountId"
                                                    ),
                                                    U32
                                                ]
                                            )
                                        }
                                    ]
                                },
                                EnumVariantMetadata {
                                    name: "balances",
                                    index: 2,
                                    fields: [
                                        FieldMetadata {
                                            name: Unnamed(
                                                0
                                            ),
                                            ty: CustomWithGenerics(
                                                "srml_balances",
                                                "RawEvent",
                                                [
                                                    Custom(
                                                        "sr_primitives",
                                                        "AccountId"
                                                    ),
                                                    U128
                                                ]
                                            )
                                        }
                                    ]
                                },
                                EnumVariantMetadata {
                                    name: "session",
                                    index: 3,
                                    fields: [
                                        FieldMetadata {
                                            name: Unnamed(
                                                0
                                            ),
                                            ty: CustomWithGenerics(
                                                "srml_session",
                                                "RawEvent",
                                                [
                                                    U64
                                                ]
                                            )
                                        }
                                    ]
                                },
                                EnumVariantMetadata {
                                    name: "staking",
                                    index: 4,
                                    fields: [
                                        FieldMetadata {
                                            name: Unnamed(
                                                0
                                            ),
                                            ty: CustomWithGenerics(
                                                "srml_staking",
                                                "RawEvent",
                                                [
                                                    U128,
                                                    Custom(
                                                        "sr_primitives",
                                                        "AccountId"
                                                    )
                                                ]
                                            )
                                        }
                                    ]
                                },
                                EnumVariantMetadata {
                                    name: "democracy",
                                    index: 5,
                                    fields: [
                                        FieldMetadata {
                                            name: Unnamed(
                                                0
                                            ),
                                            ty: CustomWithGenerics(
                                                "srml_democracy",
                                                "RawEvent",
                                                [
                                                    U128,
                                                    Custom(
                                                        "sr_primitives",
                                                        "AccountId"
                                                    )
                                                ]
                                            )
                                        }
                                    ]
                                },
                                EnumVariantMetadata {
                                    name: "council",
                                    index: 6,
                                    fields: [
                                        FieldMetadata {
                                            name: Unnamed(
                                                0
                                            ),
                                            ty: CustomWithGenerics(
                                                "srml_council::seats",
                                                "RawEvent",
                                                [
                                                    Custom(
                                                        "sr_primitives",
                                                        "AccountId"
                                                    )
                                                ]
                                            )
                                        }
                                    ]
                                },
                                EnumVariantMetadata {
                                    name: "council_voting",
                                    index: 7,
                                    fields: [
                                        FieldMetadata {
                                            name: Unnamed(
                                                0
                                            ),
                                            ty: CustomWithGenerics(
                                                "srml_council::voting",
                                                "RawEvent",
                                                [
                                                    H256
                                                ]
                                            )
                                        }
                                    ]
                                },
                                EnumVariantMetadata {
                                    name: "council_motions",
                                    index: 8,
                                    fields: [
                                        FieldMetadata {
                                            name: Unnamed(
                                                0
                                            ),
                                            ty: CustomWithGenerics(
                                                "srml_council::motions",
                                                "RawEvent",
                                                [
                                                    H256,
                                                    Custom(
                                                        "sr_primitives",
                                                        "AccountId"
                                                    )
                                                ]
                                            )
                                        }
                                    ]
                                },
                                EnumVariantMetadata {
                                    name: "grandpa",
                                    index: 9,
                                    fields: [
                                        FieldMetadata {
                                            name: Unnamed(
                                                0
                                            ),
                                            ty: CustomWithGenerics(
                                                "srml_grandpa",
                                                "RawEvent",
                                                [
                                                    Custom(
                                                        "substrate_primitives::authority_id",
                                                        "Ed25519AuthorityId"
                                                    )
                                                ]
                                            )
                                        }
                                    ]
                                },
                                EnumVariantMetadata {
                                    name: "treasury",
                                    index: 10,
                                    fields: [
                                        FieldMetadata {
                                            name: Unnamed(
                                                0
                                            ),
                                            ty: CustomWithGenerics(
                                                "srml_treasury",
                                                "RawEvent",
                                                [
                                                    U128,
                                                    Custom(
                                                        "sr_primitives",
                                                        "AccountId"
                                                    )
                                                ]
                                            )
                                        }
                                    ]
                                },
                                EnumVariantMetadata {
                                    name: "contract",
                                    index: 11,
                                    fields: [
                                        FieldMetadata {
                                            name: Unnamed(
                                                0
                                            ),
                                            ty: CustomWithGenerics(
                                                "srml_contract",
                                                "RawEvent",
                                                [
                                                    U128,
                                                    Custom(
                                                        "sr_primitives",
                                                        "AccountId"
                                                    ),
                                                    H256
                                                ]
                                            )
                                        }
                                    ]
                                },
                                EnumVariantMetadata {
                                    name: "sudo",
                                    index: 12,
                                    fields: [
                                        FieldMetadata {
                                            name: Unnamed(
                                                0
                                            ),
                                            ty: CustomWithGenerics(
                                                "srml_sudo",
                                                "RawEvent",
                                                [
                                                    Custom(
                                                        "sr_primitives",
                                                        "AccountId"
                                                    )
                                                ]
                                            )
                                        }
                                    ]
                                },
                                EnumVariantMetadata {
                                    name: "fees",
                                    index: 13,
                                    fields: [
                                        FieldMetadata {
                                            name: Unnamed(
                                                0
                                            ),
                                            ty: CustomWithGenerics(
                                                "srml_fees",
                                                "RawEvent",
                                                [
                                                    U128
                                                ]
                                            )
                                        }
                                    ]
                                }
                            ]
                        )
                    },
                    TypeMetadata {
                        name: Custom(
                            "srml_system",
                            "Event"
                        ),
                        kind: Enum(
                            [
                                EnumVariantMetadata {
                                    name: "ExtrinsicSuccess",
                                    index: 0,
                                    fields: []
                                },
                                EnumVariantMetadata {
                                    name: "ExtrinsicFailed",
                                    index: 1,
                                    fields: []
                                }
                            ]
                        )
                    },
                    TypeMetadata {
                        name: CustomWithGenerics(
                            "srml_indices",
                            "RawEvent",
                            [
                                Custom(
                                    "sr_primitives",
                                    "AccountId"
                                ),
                                U32
                            ]
                        ),
                        kind: Enum(
                            [
                                EnumVariantMetadata {
                                    name: "NewAccountIndex",
                                    index: 0,
                                    fields: [
                                        FieldMetadata {
                                            name: Unnamed(
                                                0
                                            ),
                                            ty: Custom(
                                                "sr_primitives",
                                                "AccountId"
                                            )
                                        },
                                        FieldMetadata {
                                            name: Unnamed(
                                                1
                                            ),
                                            ty: U32
                                        }
                                    ]
                                }
                            ]
                        )
                    },
                    TypeMetadata {
                        name: CustomWithGenerics(
                            "srml_balances",
                            "RawEvent",
                            [
                                Custom(
                                    "sr_primitives",
                                    "AccountId"
                                ),
                                U128
                            ]
                        ),
                        kind: Enum(
                            [
                                EnumVariantMetadata {
                                    name: "NewAccount",
                                    index: 0,
                                    fields: [
                                        FieldMetadata {
                                            name: Unnamed(
                                                0
                                            ),
                                            ty: Custom(
                                                "sr_primitives",
                                                "AccountId"
                                            )
                                        },
                                        FieldMetadata {
                                            name: Unnamed(
                                                1
                                            ),
                                            ty: U128
                                        }
                                    ]
                                },
                                EnumVariantMetadata {
                                    name: "ReapedAccount",
                                    index: 1,
                                    fields: [
                                        FieldMetadata {
                                            name: Unnamed(
                                                0
                                            ),
                                            ty: Custom(
                                                "sr_primitives",
                                                "AccountId"
                                            )
                                        }
                                    ]
                                },
                                EnumVariantMetadata {
                                    name: "Transfer",
                                    index: 2,
                                    fields: [
                                        FieldMetadata {
                                            name: Unnamed(
                                                0
                                            ),
                                            ty: Custom(
                                                "sr_primitives",
                                                "AccountId"
                                            )
                                        },
                                        FieldMetadata {
                                            name: Unnamed(
                                                1
                                            ),
                                            ty: Custom(
                                                "sr_primitives",
                                                "AccountId"
                                            )
                                        },
                                        FieldMetadata {
                                            name: Unnamed(
                                                2
                                            ),
                                            ty: U128
                                        },
                                        FieldMetadata {
                                            name: Unnamed(
                                                3
                                            ),
                                            ty: U128
                                        }
                                    ]
                                }
                            ]
                        )
                    },
                    TypeMetadata {
                        name: CustomWithGenerics(
                            "srml_session",
                            "RawEvent",
                            [
                                U64
                            ]
                        ),
                        kind: Enum(
                            [
                                EnumVariantMetadata {
                                    name: "NewSession",
                                    index: 0,
                                    fields: [
                                        FieldMetadata {
                                            name: Unnamed(
                                                0
                                            ),
                                            ty: U64
                                        }
                                    ]
                                }
                            ]
                        )
                    },
                    TypeMetadata {
                        name: CustomWithGenerics(
                            "srml_staking",
                            "RawEvent",
                            [
                                U128,
                                Custom(
                                    "sr_primitives",
                                    "AccountId"
                                )
                            ]
                        ),
                        kind: Enum(
                            [
                                EnumVariantMetadata {
                                    name: "Reward",
                                    index: 0,
                                    fields: [
                                        FieldMetadata {
                                            name: Unnamed(
                                                0
                                            ),
                                            ty: U128
                                        }
                                    ]
                                },
                                EnumVariantMetadata {
                                    name: "OfflineWarning",
                                    index: 1,
                                    fields: [
                                        FieldMetadata {
                                            name: Unnamed(
                                                0
                                            ),
                                            ty: Custom(
                                                "sr_primitives",
                                                "AccountId"
                                            )
                                        },
                                        FieldMetadata {
                                            name: Unnamed(
                                                1
                                            ),
                                            ty: U32
                                        }
                                    ]
                                },
                                EnumVariantMetadata {
                                    name: "OfflineSlash",
                                    index: 2,
                                    fields: [
                                        FieldMetadata {
                                            name: Unnamed(
                                                0
                                            ),
                                            ty: Custom(
                                                "sr_primitives",
                                                "AccountId"
                                            )
                                        },
                                        FieldMetadata {
                                            name: Unnamed(
                                                1
                                            ),
                                            ty: U128
                                        }
                                    ]
                                }
                            ]
                        )
                    },
                    TypeMetadata {
                        name: CustomWithGenerics(
                            "srml_democracy",
                            "RawEvent",
                            [
                                U128,
                                Custom(
                                    "sr_primitives",
                                    "AccountId"
                                )
                            ]
                        ),
                        kind: Enum(
                            [
                                EnumVariantMetadata {
                                    name: "Proposed",
                                    index: 0,
                                    fields: [
                                        FieldMetadata {
                                            name: Unnamed(
                                                0
                                            ),
                                            ty: U32
                                        },
                                        FieldMetadata {
                                            name: Unnamed(
                                                1
                                            ),
                                            ty: U128
                                        }
                                    ]
                                },
                                EnumVariantMetadata {
                                    name: "Tabled",
                                    index: 1,
                                    fields: [
                                        FieldMetadata {
                                            name: Unnamed(
                                                0
                                            ),
                                            ty: U32
                                        },
                                        FieldMetadata {
                                            name: Unnamed(
                                                1
                                            ),
                                            ty: U128
                                        },
                                        FieldMetadata {
                                            name: Unnamed(
                                                2
                                            ),
                                            ty: Vector(
                                                Custom(
                                                    "sr_primitives",
                                                    "AccountId"
                                                )
                                            )
                                        }
                                    ]
                                },
                                EnumVariantMetadata {
                                    name: "Started",
                                    index: 2,
                                    fields: [
                                        FieldMetadata {
                                            name: Unnamed(
                                                0
                                            ),
                                            ty: U32
                                        },
                                        FieldMetadata {
                                            name: Unnamed(
                                                1
                                            ),
                                            ty: Custom(
                                                "srml_democracy::vote_threshold",
                                                "VoteThreshold"
                                            )
                                        }
                                    ]
                                },
                                EnumVariantMetadata {
                                    name: "Passed",
                                    index: 3,
                                    fields: [
                                        FieldMetadata {
                                            name: Unnamed(
                                                0
                                            ),
                                            ty: U32
                                        }
                                    ]
                                },
                                EnumVariantMetadata {
                                    name: "NotPassed",
                                    index: 4,
                                    fields: [
                                        FieldMetadata {
                                            name: Unnamed(
                                                0
                                            ),
                                            ty: U32
                                        }
                                    ]
                                },
                                EnumVariantMetadata {
                                    name: "Cancelled",
                                    index: 5,
                                    fields: [
                                        FieldMetadata {
                                            name: Unnamed(
                                                0
                                            ),
                                            ty: U32
                                        }
                                    ]
                                },
                                EnumVariantMetadata {
                                    name: "Executed",
                                    index: 6,
                                    fields: [
                                        FieldMetadata {
                                            name: Unnamed(
                                                0
                                            ),
                                            ty: U32
                                        },
                                        FieldMetadata {
                                            name: Unnamed(
                                                1
                                            ),
                                            ty: Bool
                                        }
                                    ]
                                }
                            ]
                        )
                    },
                    TypeMetadata {
                        name: Custom(
                            "srml_democracy::vote_threshold",
                            "VoteThreshold"
                        ),
                        kind: Enum(
                            [
                                EnumVariantMetadata {
                                    name: "SuperMajorityApprove",
                                    index: 0,
                                    fields: []
                                },
                                EnumVariantMetadata {
                                    name: "SuperMajorityAgainst",
                                    index: 1,
                                    fields: []
                                },
                                EnumVariantMetadata {
                                    name: "SimpleMajority",
                                    index: 2,
                                    fields: []
                                }
                            ]
                        )
                    },
                    TypeMetadata {
                        name: CustomWithGenerics(
                            "srml_council::seats",
                            "RawEvent",
                            [
                                Custom(
                                    "sr_primitives",
                                    "AccountId"
                                )
                            ]
                        ),
                        kind: Enum(
                            [
                                EnumVariantMetadata {
                                    name: "VoterReaped",
                                    index: 0,
                                    fields: [
                                        FieldMetadata {
                                            name: Unnamed(
                                                0
                                            ),
                                            ty: Custom(
                                                "sr_primitives",
                                                "AccountId"
                                            )
                                        },
                                        FieldMetadata {
                                            name: Unnamed(
                                                1
                                            ),
                                            ty: Custom(
                                                "sr_primitives",
                                                "AccountId"
                                            )
                                        }
                                    ]
                                },
                                EnumVariantMetadata {
                                    name: "BadReaperSlashed",
                                    index: 1,
                                    fields: [
                                        FieldMetadata {
                                            name: Unnamed(
                                                0
                                            ),
                                            ty: Custom(
                                                "sr_primitives",
                                                "AccountId"
                                            )
                                        }
                                    ]
                                },
                                EnumVariantMetadata {
                                    name: "TallyStarted",
                                    index: 2,
                                    fields: [
                                        FieldMetadata {
                                            name: Unnamed(
                                                0
                                            ),
                                            ty: U32
                                        }
                                    ]
                                },
                                EnumVariantMetadata {
                                    name: "TallyFinalised",
                                    index: 3,
                                    fields: [
                                        FieldMetadata {
                                            name: Unnamed(
                                                0
                                            ),
                                            ty: Vector(
                                                Custom(
                                                    "sr_primitives",
                                                    "AccountId"
                                                )
                                            )
                                        },
                                        FieldMetadata {
                                            name: Unnamed(
                                                1
                                            ),
                                            ty: Vector(
                                                Custom(
                                                    "sr_primitives",
                                                    "AccountId"
                                                )
                                            )
                                        }
                                    ]
                                }
                            ]
                        )
                    },
                    TypeMetadata {
                        name: CustomWithGenerics(
                            "srml_council::voting",
                            "RawEvent",
                            [
                                H256
                            ]
                        ),
                        kind: Enum(
                            [
                                EnumVariantMetadata {
                                    name: "TallyCancelation",
                                    index: 0,
                                    fields: [
                                        FieldMetadata {
                                            name: Unnamed(
                                                0
                                            ),
                                            ty: H256
                                        },
                                        FieldMetadata {
                                            name: Unnamed(
                                                1
                                            ),
                                            ty: U32
                                        },
                                        FieldMetadata {
                                            name: Unnamed(
                                                2
                                            ),
                                            ty: U32
                                        },
                                        FieldMetadata {
                                            name: Unnamed(
                                                3
                                            ),
                                            ty: U32
                                        }
                                    ]
                                },
                                EnumVariantMetadata {
                                    name: "TallyReferendum",
                                    index: 1,
                                    fields: [
                                        FieldMetadata {
                                            name: Unnamed(
                                                0
                                            ),
                                            ty: H256
                                        },
                                        FieldMetadata {
                                            name: Unnamed(
                                                1
                                            ),
                                            ty: U32
                                        },
                                        FieldMetadata {
                                            name: Unnamed(
                                                2
                                            ),
                                            ty: U32
                                        },
                                        FieldMetadata {
                                            name: Unnamed(
                                                3
                                            ),
                                            ty: U32
                                        }
                                    ]
                                }
                            ]
                        )
                    },
                    TypeMetadata {
                        name: CustomWithGenerics(
                            "srml_council::motions",
                            "RawEvent",
                            [
                                H256,
                                Custom(
                                    "sr_primitives",
                                    "AccountId"
                                )
                            ]
                        ),
                        kind: Enum(
                            [
                                EnumVariantMetadata {
                                    name: "Proposed",
                                    index: 0,
                                    fields: [
                                        FieldMetadata {
                                            name: Unnamed(
                                                0
                                            ),
                                            ty: Custom(
                                                "sr_primitives",
                                                "AccountId"
                                            )
                                        },
                                        FieldMetadata {
                                            name: Unnamed(
                                                1
                                            ),
                                            ty: U32
                                        },
                                        FieldMetadata {
                                            name: Unnamed(
                                                2
                                            ),
                                            ty: H256
                                        },
                                        FieldMetadata {
                                            name: Unnamed(
                                                3
                                            ),
                                            ty: U32
                                        }
                                    ]
                                },
                                EnumVariantMetadata {
                                    name: "Voted",
                                    index: 1,
                                    fields: [
                                        FieldMetadata {
                                            name: Unnamed(
                                                0
                                            ),
                                            ty: Custom(
                                                "sr_primitives",
                                                "AccountId"
                                            )
                                        },
                                        FieldMetadata {
                                            name: Unnamed(
                                                1
                                            ),
                                            ty: H256
                                        },
                                        FieldMetadata {
                                            name: Unnamed(
                                                2
                                            ),
                                            ty: Bool
                                        },
                                        FieldMetadata {
                                            name: Unnamed(
                                                3
                                            ),
                                            ty: U32
                                        },
                                        FieldMetadata {
                                            name: Unnamed(
                                                4
                                            ),
                                            ty: U32
                                        }
                                    ]
                                },
                                EnumVariantMetadata {
                                    name: "Approved",
                                    index: 2,
                                    fields: [
                                        FieldMetadata {
                                            name: Unnamed(
                                                0
                                            ),
                                            ty: H256
                                        }
                                    ]
                                },
                                EnumVariantMetadata {
                                    name: "Disapproved",
                                    index: 3,
                                    fields: [
                                        FieldMetadata {
                                            name: Unnamed(
                                                0
                                            ),
                                            ty: H256
                                        }
                                    ]
                                },
                                EnumVariantMetadata {
                                    name: "Executed",
                                    index: 4,
                                    fields: [
                                        FieldMetadata {
                                            name: Unnamed(
                                                0
                                            ),
                                            ty: H256
                                        },
                                        FieldMetadata {
                                            name: Unnamed(
                                                1
                                            ),
                                            ty: Bool
                                        }
                                    ]
                                }
                            ]
                        )
                    },
                    TypeMetadata {
                        name: CustomWithGenerics(
                            "srml_grandpa",
                            "RawEvent",
                            [
                                Custom(
                                    "substrate_primitives::authority_id",
                                    "Ed25519AuthorityId"
                                )
                            ]
                        ),
                        kind: Enum(
                            [
                                EnumVariantMetadata {
                                    name: "NewAuthorities",
                                    index: 0,
                                    fields: [
                                        FieldMetadata {
                                            name: Unnamed(
                                                0
                                            ),
                                            ty: Vector(
                                                Tuple(
                                                    [
                                                        Custom(
                                                            "substrate_primitives::authority_id",
                                                            "Ed25519AuthorityId"
                                                        ),
                                                        U64
                                                    ]
                                                )
                                            )
                                        }
                                    ]
                                }
                            ]
                        )
                    },
                    TypeMetadata {
                        name: CustomWithGenerics(
                            "srml_treasury",
                            "RawEvent",
                            [
                                U128,
                                Custom(
                                    "sr_primitives",
                                    "AccountId"
                                )
                            ]
                        ),
                        kind: Enum(
                            [
                                EnumVariantMetadata {
                                    name: "Proposed",
                                    index: 0,
                                    fields: [
                                        FieldMetadata {
                                            name: Unnamed(
                                                0
                                            ),
                                            ty: U32
                                        }
                                    ]
                                },
                                EnumVariantMetadata {
                                    name: "Spending",
                                    index: 1,
                                    fields: [
                                        FieldMetadata {
                                            name: Unnamed(
                                                0
                                            ),
                                            ty: U128
                                        }
                                    ]
                                },
                                EnumVariantMetadata {
                                    name: "Awarded",
                                    index: 2,
                                    fields: [
                                        FieldMetadata {
                                            name: Unnamed(
                                                0
                                            ),
                                            ty: U32
                                        },
                                        FieldMetadata {
                                            name: Unnamed(
                                                1
                                            ),
                                            ty: U128
                                        },
                                        FieldMetadata {
                                            name: Unnamed(
                                                2
                                            ),
                                            ty: Custom(
                                                "sr_primitives",
                                                "AccountId"
                                            )
                                        }
                                    ]
                                },
                                EnumVariantMetadata {
                                    name: "Burnt",
                                    index: 3,
                                    fields: [
                                        FieldMetadata {
                                            name: Unnamed(
                                                0
                                            ),
                                            ty: U128
                                        }
                                    ]
                                },
                                EnumVariantMetadata {
                                    name: "Rollover",
                                    index: 4,
                                    fields: [
                                        FieldMetadata {
                                            name: Unnamed(
                                                0
                                            ),
                                            ty: U128
                                        }
                                    ]
                                }
                            ]
                        )
                    },
                    TypeMetadata {
                        name: CustomWithGenerics(
                            "srml_contract",
                            "RawEvent",
                            [
                                U128,
                                Custom(
                                    "sr_primitives",
                                    "AccountId"
                                ),
                                H256
                            ]
                        ),
                        kind: Enum(
                            [
                                EnumVariantMetadata {
                                    name: "Transfer",
                                    index: 0,
                                    fields: [
                                        FieldMetadata {
                                            name: Unnamed(
                                                0
                                            ),
                                            ty: Custom(
                                                "sr_primitives",
                                                "AccountId"
                                            )
                                        },
                                        FieldMetadata {
                                            name: Unnamed(
                                                1
                                            ),
                                            ty: Custom(
                                                "sr_primitives",
                                                "AccountId"
                                            )
                                        },
                                        FieldMetadata {
                                            name: Unnamed(
                                                2
                                            ),
                                            ty: U128
                                        }
                                    ]
                                },
                                EnumVariantMetadata {
                                    name: "Instantiated",
                                    index: 1,
                                    fields: [
                                        FieldMetadata {
                                            name: Unnamed(
                                                0
                                            ),
                                            ty: Custom(
                                                "sr_primitives",
                                                "AccountId"
                                            )
                                        },
                                        FieldMetadata {
                                            name: Unnamed(
                                                1
                                            ),
                                            ty: Custom(
                                                "sr_primitives",
                                                "AccountId"
                                            )
                                        }
                                    ]
                                },
                                EnumVariantMetadata {
                                    name: "CodeStored",
                                    index: 2,
                                    fields: [
                                        FieldMetadata {
                                            name: Unnamed(
                                                0
                                            ),
                                            ty: H256
                                        }
                                    ]
                                },
                                EnumVariantMetadata {
                                    name: "ScheduleUpdated",
                                    index: 3,
                                    fields: [
                                        FieldMetadata {
                                            name: Unnamed(
                                                0
                                            ),
                                            ty: U32
                                        }
                                    ]
                                },
                                EnumVariantMetadata {
                                    name: "Dispatched",
                                    index: 4,
                                    fields: [
                                        FieldMetadata {
                                            name: Unnamed(
                                                0
                                            ),
                                            ty: Custom(
                                                "sr_primitives",
                                                "AccountId"
                                            )
                                        },
                                        FieldMetadata {
                                            name: Unnamed(
                                                1
                                            ),
                                            ty: Bool
                                        }
                                    ]
                                }
                            ]
                        )
                    },
                    TypeMetadata {
                        name: CustomWithGenerics(
                            "srml_sudo",
                            "RawEvent",
                            [
                                Custom(
                                    "sr_primitives",
                                    "AccountId"
                                )
                            ]
                        ),
                        kind: Enum(
                            [
                                EnumVariantMetadata {
                                    name: "Sudid",
                                    index: 0,
                                    fields: [
                                        FieldMetadata {
                                            name: Unnamed(
                                                0
                                            ),
                                            ty: Bool
                                        }
                                    ]
                                },
                                EnumVariantMetadata {
                                    name: "KeyChanged",
                                    index: 1,
                                    fields: [
                                        FieldMetadata {
                                            name: Unnamed(
                                                0
                                            ),
                                            ty: Custom(
                                                "sr_primitives",
                                                "AccountId"
                                            )
                                        }
                                    ]
                                }
                            ]
                        )
                    },
                    TypeMetadata {
                        name: CustomWithGenerics(
                            "srml_fees",
                            "RawEvent",
                            [
                                U128
                            ]
                        ),
                        kind: Enum(
                            [
                                EnumVariantMetadata {
                                    name: "Charged",
                                    index: 0,
                                    fields: [
                                        FieldMetadata {
                                            name: Unnamed(
                                                0
                                            ),
                                            ty: U32
                                        },
                                        FieldMetadata {
                                            name: Unnamed(
                                                1
                                            ),
                                            ty: U128
                                        }
                                    ]
                                }
                            ]
                        )
                    },
                    TypeMetadata {
                        name: CustomWithGenerics(
                            "srml_balances",
                            "VestingSchedule",
                            [
                                U128
                            ]
                        ),
                        kind: Struct(
                            [
                                FieldMetadata {
                                    name: Named(
                                        "offset"
                                    ),
                                    ty: U128
                                },
                                FieldMetadata {
                                    name: Named(
                                        "per_block"
                                    ),
                                    ty: U128
                                }
                            ]
                        )
                    },
                    TypeMetadata {
                        name: Custom(
                            "sr_primitives",
                            "Perbill"
                        ),
                        kind: Struct(
                            [
                                FieldMetadata {
                                    name: Unnamed(
                                        0
                                    ),
                                    ty: U32
                                }
                            ]
                        )
                    },
                    TypeMetadata {
                        name: CustomWithGenerics(
                            "srml_staking",
                            "ValidatorPrefs",
                            [
                                U128
                            ]
                        ),
                        kind: Struct(
                            [
                                FieldMetadata {
                                    name: Named(
                                        "unstake_threshold"
                                    ),
                                    ty: Compact(
                                        U32
                                    )
                                },
                                FieldMetadata {
                                    name: Named(
                                        "validator_payment"
                                    ),
                                    ty: Compact(
                                        U128
                                    )
                                }
                            ]
                        )
                    },
                    TypeMetadata {
                        name: CustomWithGenerics(
                            "srml_democracy",
                            "ReferendumInfo",
                            [
                                U64,
                                Custom(
                                    "node_runtime",
                                    "Call"
                                )
                            ]
                        ),
                        kind: Struct(
                            [
                                FieldMetadata {
                                    name: Named(
                                        "end"
                                    ),
                                    ty: U64
                                },
                                FieldMetadata {
                                    name: Named(
                                        "proposal"
                                    ),
                                    ty: Custom(
                                        "node_runtime",
                                        "Call"
                                    )
                                },
                                FieldMetadata {
                                    name: Named(
                                        "threshold"
                                    ),
                                    ty: Custom(
                                        "srml_democracy::vote_threshold",
                                        "VoteThreshold"
                                    )
                                },
                                FieldMetadata {
                                    name: Named(
                                        "delay"
                                    ),
                                    ty: U64
                                }
                            ]
                        )
                    },
                    TypeMetadata {
                        name: Custom(
                            "srml_democracy",
                            "Vote"
                        ),
                        kind: Struct(
                            [
                                FieldMetadata {
                                    name: Unnamed(
                                        0
                                    ),
                                    ty: I8
                                }
                            ]
                        )
                    },
                    TypeMetadata {
                        name: CustomWithGenerics(
                            "srml_grandpa",
                            "StoredPendingChange",
                            [
                                U64,
                                Custom(
                                    "substrate_primitives::authority_id",
                                    "Ed25519AuthorityId"
                                )
                            ]
                        ),
                        kind: Struct(
                            [
                                FieldMetadata {
                                    name: Named(
                                        "scheduled_at"
                                    ),
                                    ty: U64
                                },
                                FieldMetadata {
                                    name: Named(
                                        "delay"
                                    ),
                                    ty: U64
                                },
                                FieldMetadata {
                                    name: Named(
                                        "next_authorities"
                                    ),
                                    ty: Vector(
                                        Tuple(
                                            [
                                                Custom(
                                                    "substrate_primitives::authority_id",
                                                    "Ed25519AuthorityId"
                                                ),
                                                U64
                                            ]
                                        )
                                    )
                                }
                            ]
                        )
                    },
                    TypeMetadata {
                        name: Custom(
                            "sr_primitives",
                            "Permill"
                        ),
                        kind: Struct(
                            [
                                FieldMetadata {
                                    name: Unnamed(
                                        0
                                    ),
                                    ty: U32
                                }
                            ]
                        )
                    },
                    TypeMetadata {
                        name: CustomWithGenerics(
                            "srml_treasury",
                            "Proposal",
                            [
                                Custom(
                                    "sr_primitives",
                                    "AccountId"
                                ),
                                U128
                            ]
                        ),
                        kind: Struct(
                            [
                                FieldMetadata {
                                    name: Named(
                                        "proposer"
                                    ),
                                    ty: Custom(
                                        "sr_primitives",
                                        "AccountId"
                                    )
                                },
                                FieldMetadata {
                                    name: Named(
                                        "value"
                                    ),
                                    ty: U128
                                },
                                FieldMetadata {
                                    name: Named(
                                        "beneficiary"
                                    ),
                                    ty: Custom(
                                        "sr_primitives",
                                        "AccountId"
                                    )
                                },
                                FieldMetadata {
                                    name: Named(
                                        "bond"
                                    ),
                                    ty: U128
                                }
                            ]
                        )
                    },
                    TypeMetadata {
                        name: CustomWithGenerics(
                            "srml_contract",
                            "Schedule",
                            [
                                U64
                            ]
                        ),
                        kind: Struct(
                            [
                                FieldMetadata {
                                    name: Named(
                                        "version"
                                    ),
                                    ty: U32
                                },
                                FieldMetadata {
                                    name: Named(
                                        "put_code_per_byte_cost"
                                    ),
                                    ty: U64
                                },
                                FieldMetadata {
                                    name: Named(
                                        "grow_mem_cost"
                                    ),
                                    ty: U64
                                },
                                FieldMetadata {
                                    name: Named(
                                        "regular_op_cost"
                                    ),
                                    ty: U64
                                },
                                FieldMetadata {
                                    name: Named(
                                        "return_data_per_byte_cost"
                                    ),
                                    ty: U64
                                },
                                FieldMetadata {
                                    name: Named(
                                        "sandbox_data_read_cost"
                                    ),
                                    ty: U64
                                },
                                FieldMetadata {
                                    name: Named(
                                        "sandbox_data_write_cost"
                                    ),
                                    ty: U64
                                },
                                FieldMetadata {
                                    name: Named(
                                        "max_stack_height"
                                    ),
                                    ty: U32
                                },
                                FieldMetadata {
                                    name: Named(
                                        "max_memory_pages"
                                    ),
                                    ty: U32
                                }
                            ]
                        )
                    },
                    TypeMetadata {
                        name: Custom(
                            "srml_contract::wasm",
                            "PrefabWasmModule"
                        ),
                        kind: Struct(
                            [
                                FieldMetadata {
                                    name: Named(
                                        "schedule_version"
                                    ),
                                    ty: Compact(
                                        U32
                                    )
                                },
                                FieldMetadata {
                                    name: Named(
                                        "initial"
                                    ),
                                    ty: Compact(
                                        U32
                                    )
                                },
                                FieldMetadata {
                                    name: Named(
                                        "maximum"
                                    ),
                                    ty: Compact(
                                        U32
                                    )
                                },
                                FieldMetadata {
                                    name: Named(
                                        "_reserved"
                                    ),
                                    ty: Option(
                                        Unit
                                    )
                                },
                                FieldMetadata {
                                    name: Named(
                                        "code"
                                    ),
                                    ty: Vector(
                                        U8
                                    )
                                }
                            ]
                        )
                    }
                ]
            },
            block: CustomWithGenerics(
                "sr_primitives::generic::block",
                "Block",
                [
                    CustomWithGenerics(
                        "sr_primitives::generic::header",
                        "Header",
                        [
                            U64,
                            Custom(
                                "sr_primitives::traits",
                                "BlakeTwo256"
                            ),
                            Custom(
                                "node_runtime",
                                "Log"
                            )
                        ]
                    ),
                    CustomWithGenerics(
                        "sr_primitives::generic::unchecked_mortal_compact_extrinsic",
                        "UncheckedMortalCompactExtrinsic",
                        [
                            Custom(
                                "srml_indices::address",
                                "Address"
                            ),
                            U64,
                            Custom(
                                "node_runtime",
                                "Call"
                            ),
                            Custom(
                                "sr_primitives",
                                "Ed25519Signature"
                            )
                        ]
                    )
                ]
            )
        }
    )
)