ipse.json

{
  "types": {
    "GIB": "u64",
    "Balance": "u128",
    "BalanceOf": "Balance",
    "Block": "GenericBlock",
    "Call": "GenericCall",
    "H160": "H160",
    "H256": "H256",
    "H512": "H512",
    "Hash": "H256",
    "CallHash": "Hash",
    "CallHashOf": "CallHash",
    "Fixed64": "u64",
    "Fixed128": "u128",
    "AccountId": "GenericAccountId",
    "AccountIdOf": "AccountId",
    "AccountVoteSplit": {
      "type": "struct",
      "type_mapping": [
        [
          "aye",
          "Balance"
        ],
        [
          "nay",
          "Balance"
        ]
      ]
    },
    "AccountVoteStandard": {
      "type": "struct",
      "type_mapping": [
        [
          "vote",
          "Vote"
        ],
        [
          "balance",
          "Balance"
        ]
      ]
    },
    "AccountVote": {
      "type": "enum",
      "type_mapping": [
        [
          "Standard",
          "AccountVoteStandard"
        ],
        [
          "Split",
          "AccountVoteSplit"
        ]
      ]
    },
    "Delegations": {
      "type": "struct",
      "type_mapping": [
        [
          "votes",
          "Balance"
        ],
        [
          "capital",
          "Balance"
        ]
      ]
    },
    "PriorLock": {
      "type": "struct",
      "type_mapping": [
         ["blockNumber", "BlockNumber"],
         ["balance", "Balance"]
      ]
    },
    "ReferendumInfoFinished": {
      "type": "struct",
      "type_mapping": [
        [
          "approved",
          "bool"
        ],
        [
          "end",
          "BlockNumber"
        ]
      ]
    },

	"MiningInfo":{
	"type":"struct",
	"type_mapping":[
	["miner",  "Option<AccountId>"],
	["best_dl", "u64"],
	["block", "u64"]
	]
	},

	"Difficulty": {
	"type":"struct",
	"type_mapping":[
	["base_target", "u64"],
	["net_difficulty", "u64"],
	["block", "u64"]
	]
    },
	"MiningMiners": {
	"type":"struct",
	"type_mapping":[
	["BTreeSet", "AccountId"]
	]
    },
	"MachineInfo": {
	"type":"struct",
	"type_mapping":[
	["plot_size", "u64"],
	["numeric_id", "u128"],
	["update_time", "BlockNumber"],
	["is_stop", "bool"],
	["reward_dest", "AccountId"]
	]
    },
	"MiningHistory": {
	"type":"struct",
	"type_mapping":[
	["total_num", "u64"],
	["history", "Vec<(BlockNumber, Balance)>"]
	]
    },
	"StakingInfo": {
	"type":"struct",
	"type_mapping":[
	["miner","AccountId"],
	["miner_proportion","Percent"],
    ["total_staking","Balance"],
    ["others","Vec<(AccountId, Balance, Balance)>"]
	]
	},
    "Tally": {
      "type": "struct",
      "type_mapping": [
        [
          "ayes",
          "Balance"
        ],
        [
          "nays",
          "Balance"
        ],
        [
          "turnout",
          "Balance"
        ]
      ]
    },
    "ReferendumStatus": {
      "type": "struct",
      "type_mapping": [
        [
          "end",
          "BlockNumber"
        ],
        [
          "proposalHash",
          "Hash"
        ],
        [
          "threshold",
          "VoteThreshold"
        ],
        [
          "delay",
          "BlockNumber"
        ],
        [
          "tally",
          "Tally"
        ]
      ]
    },
    "ReferendumInfo": {
      "type": "enum",
      "type_mapping": [
        [
          "Ongoing",
          "ReferendumStatus"
        ],
        [
          "Finished",
          "ReferendumInfoFinished"
        ]
      ]
    },
    "VotingDirectVote": {
      "type": "struct",
      "type_mapping": [
         ["referendumIndex", "ReferendumIndex"],
         ["accountVote", "AccountVote"]
      ]
    },
    "VotingDirect": {
      "type": "struct",
      "type_mapping": [
        [
          "votes",
          "Vec<VotingDirectVote>"
        ],
        [
          "delegations",
          "Delegations"
        ],
        [
          "prior",
          "PriorLock"
        ]
      ]
    },
    "VotingDelegating": {
      "type": "struct",
      "type_mapping": [
        [
          "balance",
          "Balance"
        ],
        [
          "target",
          "AccountId"
        ],
        [
          "conviction",
          "Conviction"
        ],
        [
          "delegations",
          "Delegations"
        ],
        [
          "prior",
          "PriorLock"
        ]
      ]
    },
    "Voting": {
      "type": "enum",
      "type_mapping": [
        [
          "Direct",
          "VotingDirect"
        ],
        [
          "Delegating",
          "VotingDelegating"
        ]
      ]
    },
    "(AccountId, Balance)": {
      "type": "struct",
      "type_mapping": [
        [
          "account",
          "AccountId"
        ],
        [
          "balance",
          "Balance"
        ]
      ]
    },
    "(BalanceOf<T, I>, BidKind<AccountId, BalanceOf<T, I>>)": {
      "type": "struct",
      "type_mapping": [
        [
          "balance",
          "Balance"
        ],
        [
          "bidkind",
          "BidKind"
        ]
      ]
    },
    "RawOrigin": {
      "type": "enum",
      "type_mapping": [
        [
          "Root",
          "Null"
        ],
        [
          "Signed",
          "AccountId"
        ],
        [
          "None",
          "Null"
        ]
      ]
    },
    "RefCount": "u32",
    "RefCountTo259": "u8",
    "SyncState": {
      "type": "struct",
      "type_mapping": [
        [
          "startingBlock",
          "BlockNumber"
        ],
        [
          "currentBlock",
          "BlockNumber"
        ],
        [
          "highestBlock",
          "Option<BlockNumber>"
        ]
      ]
    },
    "SystemOrigin": "RawOrigin",
    "Moment": "u64",
    "AccountData": {
      "type": "struct",
      "type_mapping": [
        [
          "free",
          "Balance"
        ],
        [
          "reserved",
          "Balance"
        ],
        [
          "miscFrozen",
          "Balance"
        ],
        [
          "feeFrozen",
          "Balance"
        ]
      ]
    },
    "AccountInfo<Index, AccountData>": {
      "type": "struct",
      "type_mapping": [
        [
          "nonce",
          "Index"
        ],
        [
          "refcount",
          "RefCount"
        ],
        [
          "data",
          "AccountData"
        ]
      ]
    },
    "ActiveEraInfo": {
      "type": "struct",
      "type_mapping": [
        [
          "index",
          "EraIndex"
        ],
        [
          "start",
          "Option<Moment>"
        ]
      ]
    },
    "BlockNumber": "u32",
    "ValidityVote": {
      "type": "struct",
      "type_mapping": [
        [
          "accountId",
          "AccountId"
        ],
        [
          "validityAttestation",
          "ValidityAttestation"
        ]
      ]
    },
    "AttestedCandidate": {
      "type": "struct",
      "type_mapping": [
        [
          "candidate",
          "AbridgedCandidateReceipt"
        ],
        [
          "validityVotes",
          "Vec<ValidityAttestation>"
        ],
        [
          "validatorIndices",
          "BitVec"
        ]
      ]
    },
    "LockIdentifier": "[u8; 8]",
    "TransactionPriority": "u64",
    "BalanceLock": {
      "type": "struct",
      "type_mapping": [
        [
          "id",
          "LockIdentifier"
        ],
        [
          "amount",
          "Balance"
        ],
        [
          "reasons",
          "Reasons"
        ]
      ]
    },
    "FullIdentification": {
      "type": "struct",
      "type_mapping": [
         ["total", "Compact<Balance>"],
         ["own", "Compact<Balance>"],
         ["others", "Vec<IndividualExposure>"]
      ]
    },
    "IdentificationTuple": {
      "type": "struct",
      "type_mapping": [
         ["validatorId", "ValidatorId"],
         ["exposure", "FullIdentification"]
      ]
    },
    "SetId": "u64",
    "Reasons": {
      "type": "enum",
      "value_list": [
        "Fee",
        "Misc",
        "All"
      ]
    },
    "RoundNumber": "U64",
    "SessionIndex": "u32",
    "AuctionIndex": "u32",
    "AuthIndex": "u32",
    "AuthorityIndex": "u64",
    "Signature": "H512",
    "CollatorSignature": "Signature",
    "AuthorityWeight": "u64",
    "EncodedFinalityProofs": "Bytes",
    "NextAuthority": {
      "type": "struct",
      "type_mapping": [
         ["AuthorityId", "AuthorityId"],
         ["weight", "AuthorityWeight"]
      ]
    },
    "AuthorityList": "Vec<NextAuthority>",
    "BalanceUpload": {
      "type": "struct",
      "type_mapping": [
        [
          "accountId",
          "AccountId"
        ],
        [
          "balance",
          "u64"
        ]
      ]
    },
    "CollatorId": "[u8; 32]",
    "ContractInfo": {
      "type": "enum",
      "type_mapping": [
        [
          "Alive",
          "AliveContractInfo"
        ],
        [
          "Tombstone",
          "TombstoneContractInfo"
        ]
      ]
    },
    "TrieId": "Bytes",
    "RawAliveContractInfo": {
      "type": "struct",
      "type_mapping": [
        [
          "trie_id",
          "TrieId"
        ],
        [
          "storage_size",
          "u32"
        ],
        [
          "code_hash",
          "CodeHash"
        ],
        [
          "rent_allowance",
          "Balance"
        ],
        [
          "deduct_block",
          "BlockNumber"
        ],
        [
          "last_write",
          "Option<BlockNumber>"
        ]
      ]
    },
    "Pays": {
      "type": "enum",
      "value_list": [
        "Yes",
        "No"
      ]
    },
    "DispatchClass": {
      "type": "enum",
      "value_list": [
        "Normal",
        "Operational",
        "Mandatory"
      ]
    },
    "DispatchInfo": {
      "type": "struct",
      "type_mapping": [
        [
          "weight",
          "Weight"
        ],
        [
          "class",
          "DispatchClass"
        ],
        [
          "paysFee",
          "Pays"
        ]
      ]
    },
    "EgressQueueRoot": {
      "type": "struct",
      "type_mapping": [
        [
          "paraId",
          "ParaId"
        ],
        [
          "hash",
          "Hash"
        ]
      ]
    },
    "EventIndex": "u32",
    "Extrinsic": "ExtrinsicsDecoder",
    "ExtrinsicSignature": "MultiSignature",
    "ExtrinsicPayloadValue": {
      "type": "struct",
      "type_mapping": [
        [
          "call",
          "CallBytes"
        ],
        [
          "era",
          "Era"
        ],
        [
          "nonce",
          "Compact<Index>"
        ],
        [
          "tip",
          "Compact<Balance>"
        ],
        [
          "specVersion",
          "u32"
        ],
        [
          "transactionVersion",
          "u32"
        ],
        [
          "genesisHash",
          "Hash"
        ],
        [
          "blockHash",
          "Hash"
        ]
      ]
    },
    "Gas": "u64",
    "IdentityFields": {
      "type": "set",
      "value_type": "u64",
      "value_list": {
        "Display": 1,
        "Legal": 2,
        "Web": 4,
        "Riot": 8,
        "Email": 16,
        "PgpFingerprint": 32,
        "Image": 64,
        "Twitter": 128
      }
    },
    "IdentityInfoAdditional": {
      "type": "struct",
      "type_mapping": [
         ["field", "Data"],
         ["value", "Data"]
      ]
    },
    "IdentityInfo": {
      "type": "struct",
      "type_mapping": [
        [
          "additional",
          "Vec<IdentityInfoAdditional>"
        ],
        [
          "display",
          "Data"
        ],
        [
          "legal",
          "Data"
        ],
        [
          "web",
          "Data"
        ],
        [
          "riot",
          "Data"
        ],
        [
          "email",
          "Data"
        ],
        [
          "pgpFingerprint",
          "Option<H160>"
        ],
        [
          "image",
          "Data"
        ],
        [
          "twitter",
          "Data"
        ]
      ]
    },
    "IdentityJudgement": {
      "type": "enum",
      "type_mapping": [
        [
          "Unknown",
          "Null"
        ],
        [
          "FeePaid",
          "Balance"
        ],
        [
          "Reasonable",
          "Null"
        ],
        [
          "KnownGood",
          "Null"
        ],
        [
          "OutOfDate",
          "Null"
        ],
        [
          "LowQuality",
          "Null"
        ],
        [
          "Erroneous",
          "Null"
        ]
      ]
    },
    "Judgement": "IdentityJudgement",
    "Judgement<BalanceOf>": "IdentityJudgement",
    "LeasePeriod": "BlockNumber",
    "LeasePeriodOf": "LeasePeriod",
    "(LeasePeriodOf, IncomingParachain<AccountId, Hash>)": {
      "type": "struct",
      "type_mapping": [
        [
          "leasePeriod",
          "LeasePeriodOf"
        ],
        [
          "incomingParachain",
          "IncomingParachain"
        ]
      ]
    },
    "(ParaId, Option<(CollatorId, Retriable)>)": {
      "type": "struct",
      "type_mapping": [
        [
          "ParaId",
          "ParaId"
        ],
        [
          "CollatorId-Retriable",
          "Option<(CollatorId, Retriable)>"
        ]
      ]
    },
    "MaybeVrf": "Option<VrfData>",
    "MemberCount": "u32",
    "CollectiveOrigin": {
      "type": "enum",
      "type_mapping": [
        [
          "Members",
          "(MemberCount, MemberCount)"
        ],
        [
          "Member",
          "AccountId"
        ]
      ]
    },
    "MomentOf": "Moment",
    "MoreAttestations": {
      "type": "struct",
      "type_mapping": []
    },
    "Multiplier": "Fixed128",
    "Timepoint": {
      "type": "struct",
      "type_mapping": [
        [
          "height",
          "BlockNumber"
        ],
        [
          "index",
          "u32"
        ]
      ]
    },
    "Multisig": {
      "type": "struct",
      "type_mapping": [
        [
          "when",
          "Timepoint"
        ],
        [
          "deposit",
          "Balance"
        ],
        [
          "depositor",
          "AccountId"
        ],
        [
          "approvals",
          "Vec<AccountId>"
        ]
      ]
    },
    "Offender": "IdentificationTuple",
    "PhantomData": "Null",
    "sp_std::marker::PhantomData<(AccountId, Event)>": "PhantomData",
    "Reporter": "AccountId",
    "OffenceDetails": {
      "type": "struct",
      "type_mapping": [
        [
          "offender",
          "Offender"
        ],
        [
          "reporters",
          "Vec<Reporter>"
        ]
      ]
    },
    "BountyStatusActive": {
      "type": "struct",
      "type_mapping": [
        [
          "curator",
          "AccountId"
        ],
        [
          "updateDue",
          "BlockNumber"
        ]
      ]
    },
    "BountyStatusCuratorProposed": {
      "type": "struct",
      "type_mapping": [
        [
          "curator",
          "AccountId"
        ]
      ]
    },
    "BountyStatusPendingPayout": {
      "type": "struct",
      "type_mapping": [
        [
          "curator",
          "AccountId"
        ],
        [
          "beneficiary",
          "AccountId"
        ],
        [
          "unlockAt",
          "BlockNumber"
        ]
      ]
    },
    "BountyIndex": "u32",
    "BountyStatus": {
      "type": "enum",
      "type_mapping": [
        [
          "Proposed",
          "Null"
        ],
        [
          "Approved",
          "Null"
        ],
        [
          "Funded",
          "Null"
        ],
        [
          "CuratorProposed",
          "BountyStatusCuratorProposed"
        ],
        [
          "Active",
          "BountyStatusActive"
        ],
        [
          "PendingPayout",
          "BountyStatusPendingPayout"
        ]
      ]
    },
    "Bounty": {
      "type": "struct",
      "type_mapping": [
        [
          "proposer",
          "AccountId"
        ],
        [
          "value",
          "Balance"
        ],
        [
          "fee",
          "Balance"
        ],
        [
          "curatorDeposit",
          "Balance"
        ],
        [
          "bond",
          "Balance"
        ],
        [
          "status",
          "BountyStatus"
        ]
      ]
    },
    "OpenTipFinder": "(AccountId, Balance)",
    "OpenTipTip": "(AccountId, Balance)",
    "OpenTip": {
      "type": "struct",
      "type_mapping": [
        [
          "reason",
          "Hash"
        ],
        [
          "who",
          "AccountId"
        ],
        [
          "finder",
          "AccountId"
        ],
        [
          "deposit",
          "Balance"
        ],
        [
          "closes",
          "Option<BlockNumber>"
        ],
        [
          "tips",
          "Vec<OpenTipTip>"
        ],
        [
          "findersFee",
          "bool"
        ]
      ]
    },
    "ParaId": "u32",
    "ParaIdOf": "ParaId",
    "ParaScheduling": {
      "type": "enum",
      "value_list": [
        "Always",
        "Dynamic"
      ]
    },
    "ParaInfo": {
      "type": "struct",
      "type_mapping": [
        [
          "scheduling",
          "Scheduling"
        ]
      ]
    },
    "Percent": "u8",
    "SlotNumber": "u64",
    "VrfData": "[u8; 32]",
    "VrfProof": "[u8; 64]",
    "RawAuraPreDigest": {
      "type": "struct",
      "type_mapping": [
        [
          "slotNumber",
          "u64"
        ]
      ]
    },
    "RawBabePreDigest": {
      "type": "enum",
      "type_mapping": [
        [
          "Phantom",
          "Null"
        ],
        [
          "Primary",
          "RawBabePreDigestPrimary"
        ],
        [
          "SecondaryPlain",
          "RawBabePreDigestSecondaryPlain"
        ],
        [
          "SecondaryVRF",
          "RawBabePreDigestSecondaryVRF"
        ]
      ]
    },
    "RawBabePreDigestPrimary": {
      "type": "struct",
      "type_mapping": [
        [
          "authorityIndex",
          "u32"
        ],
        [
          "slotNumber",
          "SlotNumber"
        ],
        [
          "vrfOutput",
          "VrfOutput"
        ],
        [
          "vrfProof",
          "VrfProof"
        ]
      ]
    },
    "RawBabePreDigestSecondaryPlain": {
      "type": "struct",
      "type_mapping": [
        [
          "authorityIndex",
          "u32"
        ],
        [
          "slotNumber",
          "SlotNumber"
        ]
      ]
    },
    "RawBabePreDigestSecondaryVRF": {
      "type": "struct",
      "type_mapping": [
        [
          "authorityIndex",
          "u32"
        ],
        [
          "slotNumber",
          "SlotNumber"
        ],
        [
          "vrfOutput",
          "VrfOutput"
        ],
        [
          "vrfProof",
          "VrfProof"
        ]
      ]
    },
    "ReferendumInfo<BlockNumber, Proposal>": {
      "type": "struct",
      "type_mapping": [
        [
          "end",
          "BlockNumber"
        ],
        [
          "proposal",
          "Proposal"
        ],
        [
          "threshold",
          "VoteThreshold"
        ],
        [
          "delay",
          "BlockNumber"
        ]
      ]
    },
    "(ReferendumInfo<BlockNumber, Proposal>)": "ReferendumInfo<BlockNumber, Proposal>",
    "ReferendumInfo<BlockNumber, Hash>": {
      "type": "struct",
      "type_mapping": [
        [
          "end",
          "BlockNumber"
        ],
        [
          "proposalHash",
          "Hash"
        ],
        [
          "threshold",
          "VoteThreshold"
        ],
        [
          "delay",
          "BlockNumber"
        ]
      ]
    },
    "(ReferendumInfo<BlockNumber, Hash>)": "ReferendumInfo<BlockNumber, Hash>",
    "RegistrarIndex": "u32",
    "RegistrarInfo": {
      "type": "struct",
      "type_mapping": [
        [
          "account",
          "AccountId"
        ],
        [
          "fee",
          "Balance"
        ],
        [
          "fields",
          "IdentityFields"
        ]
      ]
    },
    "RegistrationJudgement": {
      "type": "struct",
      "type_mapping": [
         ["registrarIndex", "RegistrarIndex"],
         ["judgement", "Judgement"]
      ]
    },
    "Registration": {
      "type": "struct",
      "type_mapping": [
        [
          "judgements",
          "Vec<RegistrationJudgement>"
        ],
        [
          "deposit",
          "Balance"
        ],
        [
          "info",
          "IdentityInfo"
        ]
      ]
    },
    "ReportIdOf": "Hash",
    "ScheduleTo258": {
      "type": "struct",
      "type_mapping": [
        [
          "version",
          "u32"
        ],
        [
          "putCodePerByteCost",
          "Gas"
        ],
        [
          "growMemCost",
          "Gas"
        ],
        [
          "regularOpCost",
          "Gas"
        ],
        [
          "returnDataPerByteCost",
          "Gas"
        ],
        [
          "eventDataPerByteCost",
          "Gas"
        ],
        [
          "eventPerTopicCost",
          "Gas"
        ],
        [
          "eventBaseCost",
          "Gas"
        ],
        [
          "sandboxDataReadCost",
          "Gas"
        ],
        [
          "sandboxDataWriteCost",
          "Gas"
        ],
        [
          "transferCost",
          "Gas"
        ],
        [
          "maxEventTopics",
          "u32"
        ],
        [
          "maxStackHeight",
          "u32"
        ],
        [
          "maxMemoryPages",
          "u32"
        ],
        [
          "enablePrintln",
          "bool"
        ],
        [
          "maxSubjectLen",
          "u32"
        ]
      ]
    },
    "Schedule": {
      "type": "struct",
      "type_mapping": [
        [
          "version",
          "u32"
        ],
        [
          "enablePrintln",
          "bool"
        ],
        [
          "limits",
          "Limits"
        ],
        [
          "instructionWeights",
          "InstructionWeights"
        ],
        [
          "hostFnWeights",
          "HostFnWeights"
        ]
      ]
    },
    "SubId": "u32",
    "UncleEntryItem<BlockNumber, Hash, AccountId>": {
      "type": "enum",
      "value_list": [
        "InclusionHeight",
        "Uncle"
      ]
    },
    "ValidatorPrefs": {
      "type": "struct",
      "type_mapping": [
        [
          "commission",
          "Compact<Perbill>"
        ]
      ]
    },
    "VestingSchedule<Balance, BlockNumber>": {
      "type": "struct",
      "type_mapping": [
        [
          "offset",
          "Balance"
        ],
        [
          "perBlock",
          "Balance"
        ],
        [
          "startingBlock",
          "BlockNumber"
        ]
      ]
    },
    "Weight": "u64",
    "WeightMultiplier": "Fixed64",
    "WinningDataEntry": "Option<Bidder>",
    "WinningData": "[WinningDataEntry; 10]",
    "WithdrawReasons": {
      "type": "set",
      "value_type": "u64",
      "value_list": {
        "TransactionPayment": 1,
        "Transfer": 2,
        "Reserve": 4,
        "Fee": 8,
        "Tip": 16
      }
    },
    "Index": "u32",
    "Kind": "[u8; 16]",
    "Nominations": {
      "type": "struct",
      "type_mapping": [
        [
          "targets",
          "Vec<AccountId>"
        ],
        [
          "submittedIn",
          "EraIndex"
        ],
        [
          "suppressed",
          "bool"
        ]
      ]
    },
    "OpaqueTimeSlot": "Bytes",
    "Box<<T as Trait<I>>::Proposal>": "BoxProposal",
    "AuthoritySignature": "Signature",
    "<AuthorityId as RuntimeAppPublic>::Signature": "AuthoritySignature",
    "&[u8]": "Bytes",
    "Text": "Bytes",
    "Forcing": {
      "type": "enum",
      "value_list": [
        "NotForcing",
        "ForceNew",
        "ForceNone",
        "ForceAlways"
      ]
    },
    "Heartbeat": {
      "type": "struct",
      "type_mapping": [
        [
          "blockNumber",
          "BlockNumber"
        ],
        [
          "networkState",
          "OpaqueNetworkState"
        ],
        [
          "sessionIndex",
          "SessionIndex"
        ],
        [
          "authorityIndex",
          "AuthIndex"
        ],
        [
          "validatorsLen",
          "u32"
        ]
      ]
    },
    "RewardDestination": {
      "type": "enum",
      "type_mapping": [
        [
          "Staked",
          "Null"
        ],
        [
          "Stash",
          "Null"
        ],
        [
          "Controller",
          "Null"
        ],
        [
          "Account",
          "AccountId"
        ]
      ]
    },
    "RewardDestinationTo257": {
      "type": "enum",
      "value_list": [
        "Staked",
        "Stash",
        "Controller"
      ]
    },
    "ChangesTrieConfiguration": {
      "type": "struct",
      "type_mapping": [
        [
          "digestInterval",
          "u32"
        ],
        [
          "digestLevels",
          "u32"
        ]
      ]
    },
    "ConsensusEngineId": "GenericConsensusEngineId",
    "DigestItem": {
      "type": "enum",
      "type_mapping": [
        [
          "Other",
          "Bytes"
        ],
        [
          "AuthoritiesChange",
          "Vec<AuthorityId>"
        ],
        [
          "ChangesTrieRoot",
          "Hash"
        ],
        [
          "SealV0",
          "SealV0"
        ],
        [
          "Consensus",
          "Consensus"
        ],
        [
          "Seal",
          "Seal"
        ],
        [
          "PreRuntime",
          "PreRuntime"
        ]
      ]
    },
    "Digest": {
      "type": "struct",
      "type_mapping": [
        [
          "logs",
          "Vec<DigestItem>"
        ]
      ]
    },
    "DigestOf": "Digest",
    "SpanIndex": "u32",
    "slashing::SpanIndex": "SpanIndex",
    "SlashingSpans": {
      "type": "struct",
      "type_mapping": [
        [
          "spanIndex",
          "SpanIndex"
        ],
        [
          "lastStart",
          "EraIndex"
        ],
        [
          "lastNonzeroSlash",
          "EraIndex"
        ],
        [
          "prior",
          "Vec<EraIndex>"
        ]
      ]
    },
    "slashing::SlashingSpans": "SlashingSpans",
    "SpanRecord": {
      "type": "struct",
      "type_mapping": [
        [
          "slashed",
          "Balance"
        ],
        [
          "paidOut",
          "Balance"
        ]
      ]
    },
    "slashing::SpanRecord<BalanceOf>": "SpanRecord",
    "UnappliedSlashOther": {
      "type": "struct",
      "type_mapping": [
         ["account", "AccountId"],
         ["amount", "Balance"]
      ]
    },
    "UnappliedSlash<AccountId, BalanceOf>": {
      "type": "struct",
      "type_mapping": [
        [
          "validator",
          "AccountId"
        ],
        [
          "own",
          "AccountId"
        ],
        [
          "others",
          "Vec<UnappliedSlashOther>"
        ],
        [
          "reporters",
          "Vec<AccountId>"
        ],
        [
          "payout",
          "Balance"
        ]
      ]
    },
    "Keys": "SessionKeysSubstrate",
    "Header": {
      "type": "struct",
      "type_mapping": [
        [
          "parentHash",
          "Hash"
        ],
        [
          "number",
          "Compact<BlockNumber>"
        ],
        [
          "stateRoot",
          "Hash"
        ],
        [
          "extrinsicsRoot",
          "Hash"
        ],
        [
          "digest",
          "Digest"
        ]
      ]
    },
    "DispatchErrorModule": {
      "type": "struct",
      "type_mapping": [
        [
          "index",
          "u8"
        ],
        [
          "error",
          "u8"
        ]
      ]
    },
    "DispatchError": {
      "type": "enum",
      "type_mapping": [
        [
          "Other",
          "Null"
        ],
        [
          "CannotLookup",
          "Null"
        ],
        [
          "BadOrigin",
          "Null"
        ],
        [
          "Module",
          "DispatchErrorModule"
        ]
      ]
    },
    "DispatchResult": {
      "type": "enum",
      "type_mapping": [
        [
          "Ok",
          "Null"
        ],
        [
          "Error",
          "DispatchError"
        ]
      ]
    },
    "ActiveRecovery": {
      "type": "struct",
      "type_mapping": [
        [
          "created",
          "BlockNumber"
        ],
        [
          "deposit",
          "Balance"
        ],
        [
          "friends",
          "Vec<AccountId>"
        ]
      ]
    },
    "RecoveryConfig": {
      "type": "struct",
      "type_mapping": [
        [
          "delayPeriod",
          "BlockNumber"
        ],
        [
          "deposit",
          "Balance"
        ],
        [
          "friends",
          "Vec<AccountId>"
        ],
        [
          "threshold",
          "u16"
        ]
      ]
    },
    "BidKindVouch": {
      "type": "struct",
      "type_mapping": [
        [
          "account",
          "AccountId"
        ],
        [
          "amount",
          "Balance"
        ]
      ]
    },
    "BidKind": {
      "type": "enum",
      "type_mapping": [
        [
          "Deposit",
          "Balance"
        ],
        [
          "Vouch",
          "(AccountId, Balance)"
        ]
      ]
    },
    "BidKind<AccountId,Balance>": "Bidkind",
    "BidKind<AccountId, BalanceOf<T, I>>": "Bidkind",
    "Bid": {
      "type": "struct",
      "type_mapping": [
        [
          "who",
          "AccountId"
        ],
        [
          "kind",
          "BidKind"
        ],
        [
          "value",
          "Balance"
        ]
      ]
    },
    "StrikeCount": "u32",
    "VouchingStatus": {
      "type": "enum",
      "value_list": [
        "Vouching",
        "Banned"
      ]
    },
    "ExtrinsicMetadata": {
      "type": "struct",
      "type_mapping": [
        [
          "version",
          "u8"
        ],
        [
          "signedExtensions",
          "Vec<Bytes>"
        ]
      ]
    },
    "RewardPoint": "u32",
    "BTreeMap<AccountId, RewardPoint>": "Vec<(AccountId, RewardPoint)>",
    "EraRewardPoints": {
      "type": "struct",
      "type_mapping": [
        [
          "total",
          "RewardPoint"
        ],
        [
          "individual",
          "BTreeMap<AccountId, RewardPoint>"
        ]
      ]
    },
    "IncomingParachainDeploy": {
      "type": "struct",
      "type_mapping": [
        [
          "code",
          "ValidationCode"
        ],
        [
          "initialHeadData",
          "HeadData"
        ]
      ]
    },
    "NewBidder": {
      "type": "struct",
      "type_mapping": [
        [
          "who",
          "AccountId"
        ],
        [
          "sub",
          "SubId"
        ]
      ]
    },
    "OutboundHrmpMessage": {
      "type": "struct",
      "type_mapping": [
        [
          "recipient",
          "u32"
        ],
        [
          "data",
          "Bytes"
        ]
      ]
    },
    "IncomingParachainFixed": {
      "type": "struct",
      "type_mapping": [
        [
          "codeHash",
          "Hash"
        ],
        [
          "codeSize",
          "u32"
        ],
        [
          "initialHeadData",
          "HeadData"
        ]
      ]
    },
    "IncomingParachain": {
      "type": "enum",
      "type_mapping": [
        [
          "Unset",
          "NewBidder"
        ],
        [
          "Fixed",
          "IncomingParachainFixed"
        ],
        [
          "Deploy",
          "IncomingParachainDeploy"
        ]
      ]
    },
    "LastRuntimeUpgradeInfo": {
      "type": "struct",
      "type_mapping": [
        [
          "specVersion",
          "Compact<u32>"
        ],
        [
          "specName",
          "Text"
        ]
      ]
    },
    "ProxyState": {
      "type": "enum",
      "type_mapping": [
        [
          "Open",
          "AccountId"
        ],
        [
          "Active",
          "AccountId"
        ]
      ]
    },
    "ReleasesBalances": {
      "type": "enum",
      "value_list": [
        "V1_0_0",
        "V2_0_0"
      ]
    },
    "Releases": {
      "type": "enum",
      "value_list": [
        "V1",
        "V2",
        "V3",
        "V4",
        "V5",
        "V6",
        "V7",
        "V8",
        "V9",
        "V10"
      ]
    },
    "SlotRange": {
      "type": "enum",
      "value_list": [
        "ZeroZero",
        "ZeroOne",
        "ZeroTwo",
        "ZeroThree",
        "OneOne",
        "OneTwo",
        "OneThree",
        "TwoTwo",
        "TwoThree",
        "ThreeThree"
      ]
    },
    "ValidityAttestation": {
      "type": "enum",
      "type_mapping": [
        [
          "Never",
          "Null"
        ],
        [
          "Implicit",
          "ValidatorSignature"
        ],
        [
          "Explicit",
          "ValidatorSignature"
        ]
      ]
    },
    "VestingInfo": {
      "type": "struct",
      "type_mapping": [
        [
          "locked",
          "Balance"
        ],
        [
          "perBlock",
          "Balance"
        ],
        [
          "startingBlock",
          "BlockNumber"
        ]
      ]
    },
    "NominatorIndex": "u32",
    "ValidatorIndex": "u16",
    "PerU16": "u16",
    "ValidatorIndexCompact": "Compact<ValidatorIndex>",
    "NominatorIndexCompact": "Compact<NominatorIndex>",
    "OffchainAccuracy": "PerU16",
    "OffchainAccuracyCompact": "Compact<OffchainAccuracy>",
    "CompactScoreCompact": {
      "type": "struct",
        "type_mapping": [
          ["validatorIndex", "ValidatorIndexCompact"],
          ["offchainAccuracy", "OffchainAccuracyCompact"]
        ]
    },
    "CompactScore": {
      "type": "struct",
        "type_mapping": [
          ["validatorIndex", "ValidatorIndex"],
          ["offchainAccuracy", "OffchainAccuracy"]
        ]
    },
    "CompactAssignmentsFrom258": {
      "type": "struct",
      "type_mapping": [
        [
          "votes1",
          "Vec<(NominatorIndexCompact, ValidatorIndexCompact)>"
        ],
        [
          "votes2",
          "Vec<(NominatorIndexCompact, CompactScoreCompact, ValidatorIndexCompact)>"
        ],
        [
          "votes3",
          "Vec<(NominatorIndexCompact, [CompactScoreCompact; 2], ValidatorIndexCompact)>"
        ],
        [
          "votes4",
          "Vec<(NominatorIndexCompact, [CompactScoreCompact; 3], ValidatorIndexCompact)>"
        ],
        [
          "votes5",
          "Vec<(NominatorIndexCompact, [CompactScoreCompact; 4], ValidatorIndexCompact)>"
        ],
        [
          "votes6",
          "Vec<(NominatorIndexCompact, [CompactScoreCompact; 5], ValidatorIndexCompact)>"
        ],
        [
          "votes7",
          "Vec<(NominatorIndexCompact, [CompactScoreCompact; 6], ValidatorIndexCompact)>"
        ],
        [
          "votes8",
          "Vec<(NominatorIndexCompact, [CompactScoreCompact; 7], ValidatorIndexCompact)>"
        ],
        [
          "votes9",
          "Vec<(NominatorIndexCompact, [CompactScoreCompact; 8], ValidatorIndexCompact)>"
        ],
        [
          "votes10",
          "Vec<(NominatorIndexCompact, [CompactScoreCompact; 9], ValidatorIndexCompact)>"
        ],
        [
          "votes11",
          "Vec<(NominatorIndexCompact, [CompactScoreCompact; 10], ValidatorIndexCompact)>"
        ],
        [
          "votes12",
          "Vec<(NominatorIndexCompact, [CompactScoreCompact; 11], ValidatorIndexCompact)>"
        ],
        [
          "votes13",
          "Vec<(NominatorIndexCompact, [CompactScoreCompact; 12], ValidatorIndexCompact)>"
        ],
        [
          "votes14",
          "Vec<(NominatorIndexCompact, [CompactScoreCompact; 13], ValidatorIndexCompact)>"
        ],
        [
          "votes15",
          "Vec<(NominatorIndexCompact, [CompactScoreCompact; 14], ValidatorIndexCompact)>"
        ],
        [
          "votes16",
          "Vec<(NominatorIndexCompact, [CompactScoreCompact; 15], ValidatorIndexCompact)>"
        ]
      ]
    },
    "CompactAssignmentsTo257": {
      "type": "struct",
      "type_mapping": [
        [
          "votes1",
          "Vec<(NominatorIndex, [CompactScore; 0], ValidatorIndex)>"
        ],
        [
          "votes2",
          "Vec<(NominatorIndex, [CompactScore; 1], ValidatorIndex)>"
        ],
        [
          "votes3",
          "Vec<(NominatorIndex, [CompactScore; 2], ValidatorIndex)>"
        ],
        [
          "votes4",
          "Vec<(NominatorIndex, [CompactScore; 3], ValidatorIndex)>"
        ],
        [
          "votes5",
          "Vec<(NominatorIndex, [CompactScore; 4], ValidatorIndex)>"
        ],
        [
          "votes6",
          "Vec<(NominatorIndex, [CompactScore; 5], ValidatorIndex)>"
        ],
        [
          "votes7",
          "Vec<(NominatorIndex, [CompactScore; 6], ValidatorIndex)>"
        ],
        [
          "votes8",
          "Vec<(NominatorIndex, [CompactScore; 7], ValidatorIndex)>"
        ],
        [
          "votes9",
          "Vec<(NominatorIndex, [CompactScore; 8], ValidatorIndex)>"
        ],
        [
          "votes10",
          "Vec<(NominatorIndex, [CompactScore; 9], ValidatorIndex)>"
        ],
        [
          "votes11",
          "Vec<(NominatorIndex, [CompactScore; 10], ValidatorIndex)>"
        ],
        [
          "votes12",
          "Vec<(NominatorIndex, [CompactScore; 11], ValidatorIndex)>"
        ],
        [
          "votes13",
          "Vec<(NominatorIndex, [CompactScore; 12], ValidatorIndex)>"
        ],
        [
          "votes14",
          "Vec<(NominatorIndex, [CompactScore; 13], ValidatorIndex)>"
        ],
        [
          "votes15",
          "Vec<(NominatorIndex, [CompactScore; 14], ValidatorIndex)>"
        ],
        [
          "votes16",
          "Vec<(NominatorIndex, [CompactScore; 15], ValidatorIndex)>"
        ]
      ]
    },
    "CompactAssignments": "CompactAssignmentsFrom258",
    "DeferredOffenceOf": {
      "type": "struct",
        "type_mapping": [
          ["offences", "Vec<OffenceDetails>"],
          ["perc", "Vec<Perbill>"],
          ["session", "SessionIndex"]
        ]
    },
    "Statement": {
      "type": "enum",
      "type_mapping": [
        [
          "Never",
          "Null"
        ],
        [
          "Candidate",
          "Hash"
        ],
        [
          "Valid",
          "Hash"
        ],
        [
          "Invalid",
          "Hash"
        ]
      ]
    },
    "ValidatorSignature": "Signature",
    "DoubleVoteReportStatement": {
      "type": "struct",
      "type_mapping": [
        [
          "statement",
          "Statement"
        ],
        [
          "signature",
          "ValidatorSignature"
        ]
      ]
    },
    "DoubleVoteReportProof": {
      "type": "struct",
      "type_mapping": [
        [
          "session",
          "SessionIndex"
        ],
        [
          "trieNodes",
          "Vec<Bytes>"
        ]
      ]
    },
    "SigningContext": {
      "type": "struct",
      "type_mapping": [
        [
          "sessionIndex",
          "SessionIndex"
        ],
        [
          "parentHash",
          "Hash"
        ]
      ]
    },
    "DoubleVoteReport": {
      "type": "struct",
      "type_mapping": [
        [
          "identity",
          "ValidatorId"
        ],
        [
          "first",
          "(Statement, ValidatorSignature)"
        ],
        [
          "second",
          "(Statement, ValidatorSignature)"
        ],
        [
          "proof",
          "MembershipProof"
        ],
        [
          "signingContext",
          "SigningContext"
        ]
      ]
    },
    "ElectionCompute": {
      "type": "enum",
      "value_list": [
        "OnChain",
        "Signed",
        "Authority"
      ]
    },
    "ElectionResult": {
      "type": "struct",
      "type_mapping": [
        [
          "compute",
          "ElectionCompute"
        ],
        [
          "slotStake",
          "Balance"
        ],
        [
          "electedStashes",
          "Vec<AccountId>"
        ],
        [
          "exposures",
          "Vec<(AccountId, Exposure)>"
        ]
      ]
    },
    "ElectionStatus": {
      "type": "enum",
      "type_mapping": [
        [
          "Close",
          "Null"
        ],
        [
          "Open",
          "BlockNumber"
        ]
      ]
    },
    "Phase": {
      "type": "enum",
      "type_mapping": [
        [
          "ApplyExtrinsic",
          "u32"
        ],
        [
          "Finalization",
          "Null"
        ],
        [
          "Initialization",
          "Null"
        ]
      ]
    },
    "PhragmenScore": "[u128; 3]",
    "PreimageStatusAvailable": {
      "type": "struct",
      "type_mapping": [
        [
          "data",
          "Bytes"
        ],
        [
          "provider",
          "AccountId"
        ],
        [
          "deposit",
          "Balance"
        ],
        [
          "since",
          "BlockNumber"
        ],
        [
          "expiry",
          "Option<BlockNumber>"
        ]
      ]
    },
    "PreimageStatus": {
      "type": "enum",
      "type_mapping": [
        [
          "Missing",
          "BlockNumber"
        ],
        [
          "Available",
          "PreimageStatusAvailable"
        ]
      ]
    },
    "Randomness": "Hash",
    "MaybeRandomness": "Option<Randomness>",
    "schnorrkel::Randomness": "Hash",
    "schnorrkel::RawVRFOutput": "[u8; 32]",
    "TaskAddress": {
      "type": "struct",
      "type_mapping": [
        ["blockNumber", "BlockNumber"],
        ["index", "u32"]
      ]
    },
    "ValidationFunctionParams": {
      "type": "struct",
      "type_mapping": [
        [
          "maxCodeSize",
          "u32"
        ],
        [
          "relayChainHeight",
          "RelayChainBlockNumber"
        ],
        [
          "codeUpgradeAllowed",
          "Option<RelayChainBlockNumber>"
        ]
      ]
    },
    "ValidationCode": "Bytes",
    "ParaPastCodeMeta": {
      "type": "struct",
      "type_mapping": [
        [
          "upgradeTimes",
          "Vec<BlockNumber>"
        ],
        [
          "lastPruned",
          "Option<BlockNumber>"
        ]
      ]
    },
    "ModuleId": "LockIdentifier",
    "MultiAddress": "GenericMultiAddress",
    "RuntimeDbWeight": {
      "type": "struct",
      "type_mapping": [
        [
          "read",
          "Weight"
        ],
        [
          "write",
          "Weight"
        ]
      ]
    },
    "Renouncing": {
      "type": "enum",
      "type_mapping": [
        [
          "Member",
          "Null"
        ],
        [
          "RunnerUp",
          "Null"
        ],
        [
          "Candidate",
          "Compact<u32>"
        ]
      ]
    },
    "ExtrinsicsWeight": {
      "type": "struct",
      "type_mapping": [
        [
          "normal",
          "Weight"
        ],
        [
          "operational",
          "Weight"
        ]
      ]
    },
    "weights::ExtrinsicsWeight": "ExtrinsicsWeight",
    "ValidatorCount": "u32",
    "MembershipProof": {
      "type": "struct",
      "type_mapping": [
        [
          "session",
          "SessionIndex"
        ],
        [
          "trieNodes",
          "Vec<Vec<u8>>"
        ],
        [
          "validatorCount",
          "ValidatorCount"
        ]
      ]
    },
    "JustificationNotification": "Bytes",
    "KeyOwnerProof": "MembershipProof",
    "DefunctVoter": {
      "type": "struct",
      "type_mapping": [
        [
          "who",
          "AccountId"
        ],
        [
          "voteCount",
          "Compact<u32>"
        ],
        [
          "candidateCount",
          "Compact<u32>"
        ]
      ]
    },
    "ElectionScore": "[u128; 3]",
    "ElectionSize": {
      "type": "struct",
      "type_mapping": [
        [
          "validators",
          "Compact<ValidatorIndex>"
        ],
        [
          "nominators",
          "Compact<NominatorIndex>"
        ]
      ]
    },
    "SiField": {
      "type": "struct",
      "type_mapping": [
        [
          "name",
          "Option<Text>"
        ],
        [
          "type",
          "SiLookupTypeId"
        ]
      ]
    },
    "SiLookupTypeId": "u32",
    "SiPath": "Vec<Text>",
    "SiType": {
      "type": "struct",
      "type_mapping": [
        [
          "path",
          "SiPath"
        ],
        [
          "params",
          "Vec<SiLookupTypeId>"
        ],
        [
          "def",
          "SiTypeDef"
        ]
      ]
    },
    "SiTypeDef": {
      "type": "enum",
      "type_mapping": [
        [
          "Composite",
          "SiTypeDefComposite"
        ],
        [
          "Variant",
          "SiTypeDefVariant"
        ],
        [
          "Sequence",
          "SiTypeDefSequence"
        ],
        [
          "Array",
          "SiTypeDefArray"
        ],
        [
          "Tuple",
          "SiTypeDefTuple"
        ],
        [
          "Primitive",
          "SiTypeDefPrimitive"
        ]
      ]
    },
    "SiTypeDefArray": {
      "type": "struct",
      "type_mapping": [
        [
          "len",
          "u16"
        ],
        [
          "type",
          "SiLookupTypeId"
        ]
      ]
    },
    "SiTypeDefComposite": {
      "type": "struct",
      "type_mapping": [
        [
          "fields",
          "Vec<SiField>"
        ]
      ]
    },
    "SiTypeDefVariant": {
      "type": "struct",
      "type_mapping": [
        [
          "variants",
          "Vec<SiVariant>"
        ]
      ]
    },
    "SiTypeDefPrimitive": {
      "type": "enum",
      "value_list": [
        "Bool",
        "Char",
        "Str",
        "U8",
        "U16",
        "U32",
        "U64",
        "U128",
        "U256",
        "I8",
        "I16",
        "I32",
        "I64",
        "I128",
        "I256"
      ]
    },
    "SiTypeDefSequence": {
      "type": "struct",
      "type_mapping": [
        [
          "type",
          "SiLookupTypeId"
        ]
      ]
    },
    "SiTypeDefTuple": "Vec<SiLookupTypeId>",
    "SiVariant": {
      "type": "struct",
      "type_mapping": [
        [
          "name",
          "Text"
        ],
        [
          "fields",
          "Vec<SiField>"
        ],
        [
          "discriminant",
          "Option<u64>"
        ]
      ]
    },
    "AllowedSlots": {
      "type": "enum",
      "value_list": [
        "PrimarySlots",
        "PrimaryAndSecondaryPlainSlots",
        "PrimaryAndSecondaryVRFSlots"
      ]
    },
    "NextConfigDescriptorV1": {
      "type": "struct",
      "type_mapping": [
        [
          "c",
          "(u64, u64)"
        ],
        [
          "allowedSlots",
          "AllowedSlots"
        ]
      ]
    },
    "NextConfigDescriptor": {
      "type": "enum",
      "type_mapping": [
        [
          "V0",
          "Null"
        ],
        [
          "V1",
          "NextConfigDescriptorV1"
        ]
      ]
    },
    "StatementKind": {
      "type": "enum",
      "value_list": [
        "Regular",
        "Saft"
      ]
    },
    "schedule::Priority": "u8",
    "GrandpaEquivocation": {
      "type": "enum",
      "type_mapping": [
        [
          "Prevote",
          "GrandpaEquivocationValue"
        ],
        [
          "Precommit",
          "GrandpaEquivocationValue"
        ]
      ]
    },
    "GrandpaPrevote": {
      "type": "struct",
      "type_mapping": [
        [
          "targetHash",
          "Hash"
        ],
        [
          "targetNumber",
          "BlockNumber"
        ]
      ]
    },
    "Equivocation": "GrandpaEquivocation",
    "EquivocationProof<Hash, BlockNumber>": {
      "type": "struct",
      "type_mapping": [
        [
          "setId",
          "SetId"
        ],
        [
          "equivocation",
          "Equivocation"
        ]
      ]
    },
    "ProxyType": {
      "type": "enum",
      "value_list": [
        "Any",
        "NonTransfer",
        "Governance",
        "Staking"
      ]
    },
    "BalanceStatus": {
      "type": "enum",
      "value_list": [
        "Free",
        "Reserved"
      ]
    },
    "Status": "BalanceStatus",
    "EcdsaSignature": "[u8; 65]",
    "Ed25519Signature": "H512",
    "Sr25519Signature": "H512",
    "AnySignature": "H512",
    "MultiSignature": {
      "type": "enum",
      "type_mapping": [
        [
          "Ed25519",
          "Ed25519Signature"
        ],
        [
          "Sr25519",
          "Sr25519Signature"
        ],
        [
          "Ecdsa",
          "EcdsaSignature"
        ]
      ]
    },
    "schedule::period<blocknumber>": "(BlockNumber, u32)",
    "OpaqueCall": "OpaqueCall",
    "OriginCaller": {
      "type": "enum",
      "type_mapping": [
        [
          "System",
          "SystemOrigin"
        ]
      ]
    },
    "PalletsOrigin": "OriginCaller",
    "PalletVersion": {
      "type": "struct",
      "type_mapping": [
        [
          "major",
          "u16"
        ],
        [
          "minor",
          "u8"
        ],
        [
          "patch",
          "u8"
        ]
      ]
    },
    "AuthorityId": "AccountId",
    "RawVRFOutput": "[u8; 32]",
    "BlockAttestations": {
      "type": "struct",
      "type_mapping": [
        [
          "receipt",
          "CandidateReceipt"
        ],
        [
          "valid",
          "Vec<AccountId>"
        ],
        [
          "invalid",
          "Vec<AccountId>"
        ]
      ]
    },
    "IncludedBlocks": {
      "type": "struct",
      "type_mapping": [
        [
          "actualNumber",
          "BlockNumber"
        ],
        [
          "session",
          "SessionIndex"
        ],
        [
          "randomSeed",
          "H256"
        ],
        [
          "activeParachains",
          "Vec<ParaId>"
        ],
        [
          "paraBlocks",
          "Vec<Hash>"
        ]
      ]
    },
    "HeartbeatTo244": {
      "type": "struct",
      "type_mapping": [
        [
          "blockNumber",
          "BlockNumber"
        ],
        [
          "networkState",
          "OpaqueNetworkState"
        ],
        [
          "sessionIndex",
          "SessionIndex"
        ],
        [
          "authorityIndex",
          "AuthIndex"
        ]
      ]
    },
    "OpaqueMultiaddr": "Bytes",
    "OpaquePeerId": "Bytes",
    "OpaqueNetworkState": {
      "type": "struct",
      "type_mapping": [
        [
          "peerId",
          "OpaquePeerId"
        ],
        [
          "externalAddresses",
          "Vec<OpaqueMultiaddr>"
        ]
      ]
    },
    "ProposalIndex": "u32",
    "VotesTo230": {
      "type": "struct",
      "type_mapping": [
        [
          "index",
          "ProposalIndex"
        ],
        [
          "threshold",
          "MemberCount"
        ],
        [
          "ayes",
          "Vec<AccountId>"
        ],
        [
          "nays",
          "Vec<AccountId>"
        ]
      ]
    },
    "Votes": {
      "type": "struct",
      "type_mapping": [
        [
          "index",
          "ProposalIndex"
        ],
        [
          "threshold",
          "MemberCount"
        ],
        [
          "ayes",
          "Vec<AccountId>"
        ],
        [
          "nays",
          "Vec<AccountId>"
        ],
        [
          "end",
          "BlockNumber"
        ]
      ]
    },
    "RuntimeDispatchInfo": {
      "type": "struct",
      "type_mapping": [
        [
          "weight",
          "Weight"
        ],
        [
          "class",
          "DispatchClass"
        ],
        [
          "partialFee",
          "Balance"
        ]
      ]
    },
    "AliveContractInfo": {
      "type": "struct",
      "type_mapping": [
        [
          "trieId",
          "TrieId"
        ],
        [
          "storageSize",
          "u32"
        ],
        [
          "emptyPairCount",
          "u32"
        ],
        [
          "totalPairCount",
          "u32"
        ],
        [
          "codeHash",
          "CodeHash"
        ],
        [
          "rentAllowance",
          "Balance"
        ],
        [
          "deductBlock",
          "BlockNumber"
        ],
        [
          "lastWrite",
          "Option<BlockNumber>"
        ]
      ]
    },
    "CodeHash": "Hash",
    "ContractCallRequest": {
      "type": "struct",
      "type_mapping": [
        [
          "origin",
          "AccountId"
        ],
        [
          "dest",
          "AccountId"
        ],
        [
          "value",
          "Balance"
        ],
        [
          "gasLimit",
          "u64"
        ],
        [
          "inputData",
          "Bytes"
        ]
      ]
    },
    "ContractExecResultSuccessTo260": {
      "type": "struct",
      "type_mapping": [
        [
          "flags",
          "u32"
        ],
        [
          "data",
          "Bytes"
        ],
        [
          "gasConsumed",
          "u64"
        ]
      ]
    },
    "ContractExecResultTo260": {
      "type": "enum",
      "type_mapping": [
        [
          "Success",
          "ContractExecResultSuccessTo260"
        ],
        [
          "Error",
          "Null"
        ]
      ]
    },
    "ContractExecResultErrModule": {
      "type": "struct",
      "type_mapping": [
        [
          "index",
          "u8"
        ],
        [
          "error",
          "u8"
        ],
        [
          "message",
          "Option<Text>"
        ]
      ]
    },
    "ContractExecResultErr": {
      "type": "enum",
      "type_mapping": [
        [
          "Other",
          "Text"
        ],
        [
          "CannotLookup",
          "Null"
        ],
        [
          "BadOrigin",
          "Null"
        ],
        [
          "Module",
          "ContractExecResultErrModule"
        ]
      ]
    },
    "ContractExecResultOk": {
      "type": "struct",
      "type_mapping": [
        [
          "flags",
          "u32"
        ],
        [
          "data",
          "Bytes"
        ]
      ]
    },
    "ContractExecResultResult": {
      "type": "enum",
      "type_mapping": [
        [
          "Ok",
          "ContractExecResultOk"
        ],
        [
          "Err",
          "ContractExecResultErr"
        ]
      ]
    },
    "ContractExecResult": {
      "type": "struct",
      "type_mapping": [
        [
          "gasConsumed",
          "u64"
        ],
        [
          "debugMessage",
          "Text"
        ],
        [
          "result",
          "ContractExecResultResult"
        ]
      ]
    },
    "ContractStorageKey": "[u8; 32]",
    "HostFnWeights": {
      "type": "struct",
      "type_mapping": [
        [
          "caller",
          "Weight"
        ],
        [
          "address",
          "Weight"
        ],
        [
          "gasLeft",
          "Weight"
        ],
        [
          "balance",
          "Weight"
        ],
        [
          "valueTransferred",
          "Weight"
        ],
        [
          "minimumBalance",
          "Weight"
        ],
        [
          "tombstoneDeposit",
          "Weight"
        ],
        [
          "rentAllowance",
          "Weight"
        ],
        [
          "blockNumber",
          "Weight"
        ],
        [
          "now",
          "Weight"
        ],
        [
          "weightToFee",
          "Weight"
        ],
        [
          "gas",
          "Weight"
        ],
        [
          "input",
          "Weight"
        ],
        [
          "inputPerByte",
          "Weight"
        ],
        [
          "return",
          "Weight"
        ],
        [
          "returnPerByte",
          "Weight"
        ],
        [
          "terminate",
          "Weight"
        ],
        [
          "restoreTo",
          "Weight"
        ],
        [
          "restoreToPerDelta",
          "Weight"
        ],
        [
          "random",
          "Weight"
        ],
        [
          "depositEvent",
          "Weight"
        ],
        [
          "depositEventPerTopic",
          "Weight"
        ],
        [
          "depositEventPerByte",
          "Weight"
        ],
        [
          "setRentAllowance",
          "Weight"
        ],
        [
          "setStorage",
          "Weight"
        ],
        [
          "setStoragePerByte",
          "Weight"
        ],
        [
          "clearStorage",
          "Weight"
        ],
        [
          "getStorage",
          "Weight"
        ],
        [
          "getStoragePerByte",
          "Weight"
        ],
        [
          "transfer",
          "Weight"
        ],
        [
          "call",
          "Weight"
        ],
        [
          "callTransferSurcharge",
          "Weight"
        ],
        [
          "callPerInputByte",
          "Weight"
        ],
        [
          "callPerOutputByte",
          "Weight"
        ],
        [
          "instantiate",
          "Weight"
        ],
        [
          "instantiatePerInputByte",
          "Weight"
        ],
        [
          "instantiatePerOutputByte",
          "Weight"
        ],
        [
          "hashSha2256",
          "Weight"
        ],
        [
          "hashSha2256PerByte",
          "Weight"
        ],
        [
          "hashKeccak256",
          "Weight"
        ],
        [
          "hashKeccak256PerByte",
          "Weight"
        ],
        [
          "hashBlake2256",
          "Weight"
        ],
        [
          "hashBlake2256PerByte",
          "Weight"
        ],
        [
          "hashBlake2128",
          "Weight"
        ],
        [
          "hashBlake2128PerByte",
          "Weight"
        ]
      ]
    },
    "InstructionWeights": {
      "type": "struct",
      "type_mapping": [
        [
          "i64const",
          "u32"
        ],
        [
          "i64load",
          "u32"
        ],
        [
          "i64store",
          "u32"
        ],
        [
          "select",
          "u32"
        ],
        [
          "rIf",
          "u32"
        ],
        [
          "br",
          "u32"
        ],
        [
          "brIf",
          "u32"
        ],
        [
          "brIable",
          "u32"
        ],
        [
          "brIablePerEntry",
          "u32"
        ],
        [
          "call",
          "u32"
        ],
        [
          "callIndirect",
          "u32"
        ],
        [
          "callIndirectPerParam",
          "u32"
        ],
        [
          "localGet",
          "u32"
        ],
        [
          "localSet",
          "u32"
        ],
        [
          "local_tee",
          "u32"
        ],
        [
          "globalGet",
          "u32"
        ],
        [
          "globalSet",
          "u32"
        ],
        [
          "memoryCurrent",
          "u32"
        ],
        [
          "memoryGrow",
          "u32"
        ],
        [
          "i64clz",
          "u32"
        ],
        [
          "i64ctz",
          "u32"
        ],
        [
          "i64popcnt",
          "u32"
        ],
        [
          "i64eqz",
          "u32"
        ],
        [
          "i64extendsi32",
          "u32"
        ],
        [
          "i64extendui32",
          "u32"
        ],
        [
          "i32wrapi64",
          "u32"
        ],
        [
          "i64eq",
          "u32"
        ],
        [
          "i64ne",
          "u32"
        ],
        [
          "i64lts",
          "u32"
        ],
        [
          "i64ltu",
          "u32"
        ],
        [
          "i64gts",
          "u32"
        ],
        [
          "i64gtu",
          "u32"
        ],
        [
          "i64les",
          "u32"
        ],
        [
          "i64leu",
          "u32"
        ],
        [
          "i64ges",
          "u32"
        ],
        [
          "i64geu",
          "u32"
        ],
        [
          "i64add",
          "u32"
        ],
        [
          "i64sub",
          "u32"
        ],
        [
          "i64mul",
          "u32"
        ],
        [
          "i64divs",
          "u32"
        ],
        [
          "i64divu",
          "u32"
        ],
        [
          "i64rems",
          "u32"
        ],
        [
          "i64remu",
          "u32"
        ],
        [
          "i64and",
          "u32"
        ],
        [
          "i64or",
          "u32"
        ],
        [
          "i64xor",
          "u32"
        ],
        [
          "i64shl",
          "u32"
        ],
        [
          "i64shrs",
          "u32"
        ],
        [
          "i64shru",
          "u32"
        ],
        [
          "i64rotl",
          "u32"
        ],
        [
          "i64rotr",
          "u32"
        ]
      ]
    },
    "Limits": {
      "type": "struct",
      "type_mapping": [
        [
          "eventTopics",
          "u32"
        ],
        [
          "stackHeight",
          "u32"
        ],
        [
          "globals",
          "u32"
        ],
        [
          "parameters",
          "u32"
        ],
        [
          "memoryPages",
          "u32"
        ],
        [
          "tableSize",
          "u32"
        ],
        [
          "brTableSize",
          "u32"
        ],
        [
          "subjectLen",
          "u32"
        ],
        [
          "codeSize",
          "u32"
        ]
      ]
    },
    "PrefabWasmModule": {
      "type": "struct",
      "type_mapping": [
        [
          "scheduleVersion",
          "Compact<u32>"
        ],
        [
          "initial",
          "Compact<u32>"
        ],
        [
          "maximum",
          "Compact<u32>"
        ],
        [
          "_reserved",
          "PrefabWasmModuleReserved"
        ],
        [
          "code",
          "Bytes"
        ]
      ]
    },
    "PrefabWasmModuleReserved": "Option<Null>",
    "ScheduleTo212": {
      "type": "struct",
      "type_mapping": [
        [
          "version",
          "u32"
        ],
        [
          "putCodePerByteCost",
          "Gas"
        ],
        [
          "growMemCost",
          "Gas"
        ],
        [
          "regularOpCost",
          "Gas"
        ],
        [
          "returnDataPerByteCost",
          "Gas"
        ],
        [
          "eventDataPerByteCost",
          "Gas"
        ],
        [
          "eventPerTopicCost",
          "Gas"
        ],
        [
          "eventBaseCost",
          "Gas"
        ],
        [
          "sandboxDataReadCost",
          "Gas"
        ],
        [
          "sandboxDataWriteCost",
          "Gas"
        ],
        [
          "maxEventTopics",
          "u32"
        ],
        [
          "maxStackHeight",
          "u32"
        ],
        [
          "maxMemoryPages",
          "u32"
        ],
        [
          "enablePrintln",
          "bool"
        ],
        [
          "maxSubjectLen",
          "u32"
        ]
      ]
    },
    "SeedOf": "Hash",
    "TombstoneContractInfo": "Hash",
    "ExtrinsicOrHash": {
      "type": "enum",
      "type_mapping": [
        [
          "Hash",
          "Hash"
        ],
        [
          "Extrinsic",
          "Bytes"
        ]
      ]
    },
    "ExtrinsicStatus": {
      "type": "enum",
      "type_mapping": [
        [
          "Future",
          "Null"
        ],
        [
          "Ready",
          "Null"
        ],
        [
          "Broadcast",
          "Vec<Text>"
        ],
        [
          "InBlock",
          "Hash"
        ],
        [
          "Retracted",
          "Hash"
        ],
        [
          "FinalityTimeout",
          "Hash"
        ],
        [
          "Finalized",
          "Hash"
        ],
        [
          "Usurped",
          "Hash"
        ],
        [
          "Dropped",
          "Null"
        ],
        [
          "Invalid",
          "Null"
        ]
      ]
    },
    "StorageKey": "Bytes",
    "PrefixedStorageKey": "StorageKey",
    "ContractProject": {
      "type": "struct",
      "type_mapping": [
        [
          "metadataVersion",
          "Text"
        ],
        [
          "source",
          "ContractProjectSource"
        ],
        [
          "contract",
          "ContractProjectContract"
        ],
        [
          "types",
          "Vec<SiType>"
        ],
        [
          "spec",
          "ContractContractSpec"
        ]
      ]
    },
    "ContractProjectContract": {
      "type": "struct",
      "type_mapping": [
        [
          "name",
          "Text"
        ],
        [
          "version",
          "Text"
        ],
        [
          "authors",
          "Vec<Text>"
        ],
        [
          "description",
          "Option<Text>"
        ],
        [
          "documentation",
          "Option<Text>"
        ],
        [
          "repository",
          "Option<Text>"
        ],
        [
          "homepage",
          "Option<Text>"
        ],
        [
          "license",
          "Option<Text>"
        ]
      ]
    },
    "ContractProjectSource": {
      "type": "struct",
      "type_mapping": [
        [
          "hash",
          "[u8; 32]"
        ],
        [
          "language",
          "Text"
        ],
        [
          "compiler",
          "Text"
        ],
        [
          "wasm",
          "Raw"
        ]
      ]
    },
    "AccountIndex": "GenericAccountIndex",
    "Address": "GenericAddress",
    "AssetId": "u32",
    "Justification": "Bytes",
    "StorageData": "Bytes",
    "KeyValue": {
      "type": "struct",
      "type_mapping": [
        [
          "key",
          "StorageKey"
        ],
        [
          "value",
          "StorageData"
        ]
      ]
    },
    "KeyTypeId": "u32",
    "LookupSource": "Address",
    "LookupTarget": "AccountId",
    "Perbill": "u32",
    "Permill": "u32",
    "Perquintill": "u64",
    "Phantom": "Null",
    "SignedBlock": {
      "type": "struct",
      "type_mapping": [
        [
          "block",
          "Block"
        ],
        [
          "justification",
          "Justification"
        ]
      ]
    },
    "ValidatorId": "AccountId",
    "PreRuntime": "(ConsensusEngineId, Bytes)",
    "SealV0": "(u64, Signature)",
    "Seal": "(ConsensusEngineId, Bytes)",
    "Consensus": "(ConsensusEngineId, Bytes)",
    "Period": "(BlockNumber, u32)",
    "Priority": "u8",
    "SchedulePeriod": "Period",
    "SchedulePriority": "Priority",
    "Scheduled": {
      "type": "struct",
      "type_mapping": [
        [
          "maybeId",
          "Option<Bytes>"
        ],
        [
          "priority",
          "SchedulePriority"
        ],
        [
          "call",
          "Call"
        ],
        [
          "maybePeriodic",
          "Option<SchedulePeriod>"
        ],
        [
          "origin",
          "PalletsOrigin"
        ]
      ]
    },
    "ScheduledTo254": {
      "type": "struct",
      "type_mapping": [
        [
          "maybeId",
          "Option<Bytes>"
        ],
        [
          "priority",
          "SchedulePriority"
        ],
        [
          "call",
          "Call"
        ],
        [
          "maybePeriodic",
          "Option<SchedulePeriod>"
        ]
      ]
    },
    "SocietyJudgement": {
      "type": "enum",
      "value_list": [
        "Rebid",
        "Reject",
        "Approve"
      ]
    },
    "SocietyVote": {
      "type": "enum",
      "value_list": [
        "Skeptic",
        "Reject",
        "Approve"
      ]
    },
    "BlockHash": "Hash",
    "UncleEntryItem": {
      "type": "enum",
      "type_mapping": [
        [
          "InclusionHeight",
          "BlockNumber"
        ],
        [
          "Uncle",
          "(Hash, Option<AccountId>)"
        ]
      ]
    },
    "ApiId": "[u8; 8]",
    "KeyValueOption": "(StorageKey, Option<StorageData>)",
    "ReadProof": {
      "type": "struct",
      "type_mapping": [
        [
          "at",
          "Hash"
        ],
        [
          "proof",
          "Vec<Bytes>"
        ]
      ]
    },
    "RuntimeVersionApi": "(ApiId, u32)",
    "RuntimeVersion": {
      "type": "struct",
      "type_mapping": [
        [
          "specName",
          "Text"
        ],
        [
          "implName",
          "Text"
        ],
        [
          "authoringVersion",
          "u32"
        ],
        [
          "specVersion",
          "u32"
        ],
        [
          "implVersion",
          "u32"
        ],
        [
          "apis",
          "Vec<RuntimeVersionApi>"
        ],
        [
          "transactionVersion",
          "u32"
        ]
      ]
    },
    "StorageChangeSet": {
      "type": "struct",
      "type_mapping": [
        [
          "block",
          "Hash"
        ],
        [
          "changes",
          "Vec<KeyValueOption>"
        ]
      ]
    },
    "GrandpaEquivocationProof": {
      "type": "struct",
      "type_mapping": [
        [
          "setId",
          "SetId"
        ],
        [
          "equivocation",
          "GrandpaEquivocation"
        ]
      ]
    },
    "GrandpaEquivocationValue": {
      "type": "struct",
      "type_mapping": [
        [
          "roundNumber",
          "u64"
        ],
        [
          "identity",
          "AuthorityId"
        ],
        [
          "first",
          "(GrandpaPrevote, AuthoritySignature)"
        ],
        [
          "second",
          "(GrandpaPrevote, AuthoritySignature)"
        ]
      ]
    },
    "PendingPause": {
      "type": "struct",
      "type_mapping": [
        [
          "scheduledAt",
          "BlockNumber"
        ],
        [
          "delay",
          "BlockNumber"
        ]
      ]
    },
    "PendingResume": {
      "type": "struct",
      "type_mapping": [
        [
          "scheduledAt",
          "BlockNumber"
        ],
        [
          "delay",
          "BlockNumber"
        ]
      ]
    },
    "Precommits": {
      "type": "struct",
      "type_mapping": [
        [
          "currentWeight",
          "u32"
        ],
        [
          "missing",
          "BTreeSet<AuthorityId>"
        ]
      ]
    },
    "Prevotes": {
      "type": "struct",
      "type_mapping": [
        [
          "currentWeight",
          "u32"
        ],
        [
          "missing",
          "BTreeSet<AuthorityId>"
        ]
      ]
    },
    "ReportedRoundStates": {
      "type": "struct",
      "type_mapping": [
        [
          "setId",
          "u32"
        ],
        [
          "best",
          "RoundState"
        ],
        [
          "background",
          "Vec<RoundState>"
        ]
      ]
    },
    "RoundState": {
      "type": "struct",
      "type_mapping": [
        [
          "round",
          "u32"
        ],
        [
          "totalWeight",
          "u32"
        ],
        [
          "thresholdWeight",
          "u32"
        ],
        [
          "prevotes",
          "Prevotes"
        ],
        [
          "precommits",
          "Precommits"
        ]
      ]
    },
    "StoredPendingChange": {
      "type": "struct",
      "type_mapping": [
        [
          "scheduledAt",
          "BlockNumber"
        ],
        [
          "delay",
          "BlockNumber"
        ],
        [
          "nextAuthorities",
          "AuthorityList"
        ]
      ]
    },
    "StoredState": {
      "type": "enum",
      "type_mapping": [
        [
          "Live",
          "Null"
        ],
        [
          "PendingPause",
          "PendingPause"
        ],
        [
          "Paused",
          "Null"
        ],
        [
          "PendingResume",
          "PendingResume"
        ]
      ]
    },
    "AccountInfo": {
      "type": "struct",
      "type_mapping": [
        [
          "nonce",
          "Index"
        ],
        [
          "refcount",
          "RefCount"
        ],
        [
          "data",
          "AccountData"
        ]
      ]
    },
    "ChainProperties": {
      "type": "struct",
      "type_mapping": [
        [
          "ss58Format",
          "Option<u8>"
        ],
        [
          "tokenDecimals",
          "Option<u32>"
        ],
        [
          "tokenSymbol",
          "Option<Text>"
        ]
      ]
    },
    "ChainType": {
      "type": "enum",
      "type_mapping": [
        [
          "Development",
          "Null"
        ],
        [
          "Local",
          "Null"
        ],
        [
          "Live",
          "Null"
        ],
        [
          "Custom",
          "Text"
        ]
      ]
    },
    "DispatchErrorTo198": {
      "type": "struct",
      "type_mapping": [
        [
          "module",
          "Option<u8>"
        ],
        [
          "error",
          "u8"
        ]
      ]
    },
    "DispatchInfoTo190": {
      "type": "struct",
      "type_mapping": [
        [
          "weight",
          "Weight"
        ],
        [
          "class",
          "DispatchClass"
        ]
      ]
    },
    "DispatchInfoTo244": {
      "type": "struct",
      "type_mapping": [
        [
          "weight",
          "Weight"
        ],
        [
          "class",
          "DispatchClass"
        ],
        [
          "paysFee",
          "bool"
        ]
      ]
    },
    "DispatchResultOf": "DispatchResult",
    "Event": "GenericEvent",
    "EventId": "[u8; 2]",
    "EventRecord": "EventRecord",
    "EventRecordTo76": {
      "type": "struct",
      "type_mapping": [
        [
          "phase",
          "Phase"
        ],
        [
          "event",
          "Event"
        ]
      ]
    },
    "Health": {
      "type": "struct",
      "type_mapping": [
        [
          "peers",
          "u64"
        ],
        [
          "isSyncing",
          "bool"
        ],
        [
          "shouldHavePeers",
          "bool"
        ]
      ]
    },
    "InvalidTransaction": {
      "type": "enum",
      "type_mapping": [
        [
          "Call",
          "Null"
        ],
        [
          "Payment",
          "Null"
        ],
        [
          "Future",
          "Null"
        ],
        [
          "Stale",
          "Null"
        ],
        [
          "BadProof",
          "Null"
        ],
        [
          "AncientBirthBlock",
          "Null"
        ],
        [
          "ExhaustsResources",
          "Null"
        ],
        [
          "Custom",
          "u8"
        ],
        [
          "BadMandatory",
          "Null"
        ],
        [
          "MandatoryDispatch",
          "Null"
        ]
      ]
    },
    "Key": "Bytes",
    "NetworkState": {
      "type": "struct",
      "type_mapping": [
        [
          "peerId",
          "Text"
        ],
        [
          "listenedAddresses",
          "Vec<Text>"
        ],
        [
          "externalAddresses",
          "Vec<Text>"
        ],
        [
          "connectedPeers",
          "HashMap<Text, Peer>"
        ],
        [
          "notConnectedPeers",
          "HashMap<Text, NotConnectedPeer>"
        ],
        [
          "averageDownloadPerSec",
          "u64"
        ],
        [
          "averageUploadPerSec",
          "u64"
        ],
        [
          "peerset",
          "NetworkStatePeerset"
        ]
      ]
    },
    "NetworkStatePeerset": {
      "type": "struct",
      "type_mapping": [
        [
          "messageQueue",
          "u64"
        ],
        [
          "nodes",
          "HashMap<Text, NetworkStatePeersetInfo>"
        ]
      ]
    },
    "NetworkStatePeersetInfo": {
      "type": "struct",
      "type_mapping": [
        [
          "connected",
          "bool"
        ],
        [
          "reputation",
          "i32"
        ]
      ]
    },
    "NodeRole": {
      "type": "enum",
      "type_mapping": [
        [
          "Full",
          "Null"
        ],
        [
          "LightClient",
          "Null"
        ],
        [
          "Authority",
          "Null"
        ],
        [
          "UnknownRole",
          "u8"
        ]
      ]
    },
    "NotConnectedPeer": {
      "type": "struct",
      "type_mapping": [
        [
          "knownAddresses",
          "Vec<Text>"
        ],
        [
          "latestPingTime",
          "Option<PeerPing>"
        ],
        [
          "versionString",
          "Option<Text>"
        ]
      ]
    },
    "Peer": {
      "type": "struct",
      "type_mapping": [
        [
          "enabled",
          "bool"
        ],
        [
          "endpoint",
          "PeerEndpoint"
        ],
        [
          "knownAddresses",
          "Vec<Text>"
        ],
        [
          "latestPingTime",
          "PeerPing"
        ],
        [
          "open",
          "bool"
        ],
        [
          "versionString",
          "Text"
        ]
      ]
    },
    "PeerEndpoint": {
      "type": "struct",
      "type_mapping": [
        [
          "listening",
          "PeerEndpointAddr"
        ]
      ]
    },
    "PeerEndpointAddr": {
      "type": "struct",
      "type_mapping": [
        [
          "_alias",
          {
            "localAddr": "local_addr",
            "sendBackAddr": "send_back_addr"
          }
        ],
        [
          "localAddr",
          "Text"
        ],
        [
          "sendBackAddr",
          "Text"
        ]
      ]
    },
    "PeerPing": {
      "type": "struct",
      "type_mapping": [
        [
          "nanos",
          "u64"
        ],
        [
          "secs",
          "u64"
        ]
      ]
    },
    "PeerInfo": {
      "type": "struct",
      "type_mapping": [
        [
          "peerId",
          "Text"
        ],
        [
          "roles",
          "Text"
        ],
        [
          "protocolVersion",
          "u32"
        ],
        [
          "bestHash",
          "Hash"
        ],
        [
          "bestNumber",
          "BlockNumber"
        ]
      ]
    },
    "TransactionValidityError": {
      "type": "enum",
      "type_mapping": [
        [
          "Invalid",
          "InvalidTransaction"
        ],
        [
          "Unknown",
          "UnknownTransaction"
        ]
      ]
    },
    "UnknownTransaction": {
      "type": "enum",
      "type_mapping": [
        [
          "CannotLookup",
          "Null"
        ],
        [
          "NoUnsignedValidator",
          "Null"
        ],
        [
          "Custom",
          "u8"
        ]
      ]
    },
    "WeightToFeeCoefficient": {
      "type": "struct",
      "type_mapping": [
        [
          "coeffInteger",
          "Balance"
        ],
        [
          "coeffFrac",
          "Perbill"
        ],
        [
          "negative",
          "bool"
        ],
        [
          "degree",
          "u8"
        ]
      ]
    },
    "EraIndex": "u32",
    "EraRewards": {
      "type": "struct",
      "type_mapping": [
        [
          "total",
          "u32"
        ],
        [
          "rewards",
          "Vec<u32>"
        ]
      ]
    },
    "Exposure": {
      "type": "struct",
      "type_mapping": [
        [
          "total",
          "Compact<Balance>"
        ],
        [
          "own",
          "Compact<Balance>"
        ],
        [
          "others",
          "Vec<IndividualExposure>"
        ]
      ]
    },
    "IndividualExposure": {
      "type": "struct",
      "type_mapping": [
        [
          "who",
          "AccountId"
        ],
        [
          "value",
          "Compact<Balance>"
        ]
      ]
    },
    "KeyType": "AccountId",
    "Points": "u32",
    "SlashJournalEntry": {
      "type": "struct",
      "type_mapping": [
        [
          "who",
          "AccountId"
        ],
        [
          "amount",
          "Balance"
        ],
        [
          "ownSlash",
          "Balance"
        ]
      ]
    },
    "SlashingSpansTo204": {
      "type": "struct",
      "type_mapping": [
        [
          "spanIndex",
          "SpanIndex"
        ],
        [
          "lastStart",
          "EraIndex"
        ],
        [
          "prior",
          "Vec<EraIndex>"
        ]
      ]
    },
    "StakingLedgerTo223": {
      "type": "struct",
      "type_mapping": [
        [
          "stash",
          "AccountId"
        ],
        [
          "total",
          "Compact<Balance>"
        ],
        [
          "active",
          "Compact<Balance>"
        ],
        [
          "unlocking",
          "Vec<UnlockChunk>"
        ]
      ]
    },
    "StakingLedgerTo240": {
      "type": "struct",
      "type_mapping": [
        [
          "stash",
          "AccountId"
        ],
        [
          "total",
          "Compact<Balance>"
        ],
        [
          "active",
          "Compact<Balance>"
        ],
        [
          "unlocking",
          "Vec<UnlockChunk>"
        ],
        [
          "lastReward",
          "Option<EraIndex>"
        ]
      ]
    },
    "StakingLedger": {
      "type": "struct",
      "type_mapping": [
        [
          "stash",
          "AccountId"
        ],
        [
          "total",
          "Compact<Balance>"
        ],
        [
          "active",
          "Compact<Balance>"
        ],
        [
          "unlocking",
          "Vec<UnlockChunk>"
        ],
        [
          "claimedRewards",
          "Vec<EraIndex>"
        ]
      ]
    },
    "UnappliedSlash": {
      "type": "struct",
      "type_mapping": [
        [
          "validator",
          "AccountId"
        ],
        [
          "own",
          "Balance"
        ],
        [
          "others",
          "Vec<UnappliedSlashOther>"
        ],
        [
          "reporters",
          "Vec<AccountId>"
        ],
        [
          "payout",
          "Balance"
        ]
      ]
    },
    "UnlockChunk": {
      "type": "struct",
      "type_mapping": [
        [
          "value",
          "Compact<Balance>"
        ],
        [
          "era",
          "Compact<BlockNumber>"
        ]
      ]
    },
    "ValidatorPrefsTo196": {
      "type": "struct",
      "type_mapping": [
        [
          "validatorPayment",
          "Compact<Balance>"
        ]
      ]
    },
    "ValidatorPrefsTo145": {
      "type": "struct",
      "type_mapping": [
        [
          "unstakeThreshold",
          "Compact<u32>"
        ],
        [
          "validatorPayment",
          "Compact<Balance>"
        ]
      ]
    },
    "BalanceLockTo212": {
      "type": "struct",
      "type_mapping": [
        [
          "id",
          "LockIdentifier"
        ],
        [
          "amount",
          "Balance"
        ],
        [
          "until",
          "BlockNumber"
        ],
        [
          "reasons",
          "WithdrawReasons"
        ]
      ]
    },
    "VestingSchedule": {
      "type": "struct",
      "type_mapping": [
        [
          "offset",
          "Balance"
        ],
        [
          "perBlock",
          "Balance"
        ],
        [
          "startingBlock",
          "BlockNumber"
        ]
      ]
    },
    "Account": {
      "type": "struct",
      "type_mapping": [
        [
          "nonce",
          "u256"
        ],
        [
          "balance",
          "u256"
        ]
      ]
    },
    "Log": {
      "type": "struct",
      "type_mapping": [
        [
          "address",
          "H160"
        ],
        [
          "topics",
          "Vec<H256>"
        ],
        [
          "data",
          "Bytes"
        ]
      ]
    },
    "Vicinity": {
      "type": "struct",
      "type_mapping": [
        [
          "gasPrice",
          "u256"
        ],
        [
          "origin",
          "H160"
        ]
      ]
    },
    "StorageKind": {
      "type": "enum",
      "value_list": [
        "__UNUSED",
        "PERSISTENT",
        "LOCAL"
      ]
    },
    "OpenTipTo225": {
      "type": "struct",
      "type_mapping": [
        [
          "reason",
          "Hash"
        ],
        [
          "who",
          "AccountId"
        ],
        [
          "finder",
          "Option<OpenTipFinderTo225>"
        ],
        [
          "closes",
          "Option<BlockNumber>"
        ],
        [
          "tips",
          "Vec<OpenTipTip>"
        ]
      ]
    },
    "OpenTipFinderTo225": "(AccountId, Balance)",
    "TreasuryProposal": {
      "type": "struct",
      "type_mapping": [
        [
          "proposer",
          "AccountId"
        ],
        [
          "value",
          "Balance"
        ],
        [
          "beneficiary",
          "AccountId"
        ],
        [
          "bond",
          "Balance"
        ]
      ]
    },
    "BabeAuthorityWeight": "u64",
    "BabeBlockWeight": "u32",
    "BabeEquivocationProof": {
      "type": "struct",
      "type_mapping": [
        [
          "offender",
          "AuthorityId"
        ],
        [
          "slotNumber",
          "SlotNumber"
        ],
        [
          "firstHeader",
          "Header"
        ],
        [
          "secondHeader",
          "Header"
        ]
      ]
    },
    "EquivocationProof<Header>": "BabeEquivocationProof",
    "BabeWeight": "u64",
    "EpochAuthorship": {
      "type": "struct",
      "type_mapping": [
        [
          "primary",
          "Vec<u64>"
        ],
        [
          "secondary",
          "Vec<u64>"
        ],
        [
          "secondary_vrf",
          "Vec<u64>"
        ]
      ]
    },
    "RawBabePreDigestTo159": {
      "type": "enum",
      "type_mapping": [
        [
          "Primary",
          "RawBabePreDigestPrimaryTo159"
        ],
        [
          "Secondary",
          "RawBabePreDigestSecondaryTo159"
        ]
      ]
    },
    "RawBabePreDigestPrimaryTo159": {
      "type": "struct",
      "type_mapping": [
        [
          "authorityIndex",
          "u32"
        ],
        [
          "slotNumber",
          "SlotNumber"
        ],
        [
          "weight",
          "BabeBlockWeight"
        ],
        [
          "vrfOutput",
          "VrfOutput"
        ],
        [
          "vrfProof",
          "VrfProof"
        ]
      ]
    },
    "RawBabePreDigestSecondaryTo159": {
      "type": "struct",
      "type_mapping": [
        [
          "authorityIndex",
          "u32"
        ],
        [
          "slotNumber",
          "SlotNumber"
        ],
        [
          "weight",
          "BabeBlockWeight"
        ]
      ]
    },
    "RawBabePreDigestCompat": {
      "type": "enum",
      "type_mapping": [
        [
          "Zero",
          "u32"
        ],
        [
          "One",
          "u32"
        ],
        [
          "Two",
          "u32"
        ],
        [
          "Three",
          "u32"
        ]
      ]
    },
    "VrfOutput": "[u8; 32]",
    "RpcMethods": {
      "type": "struct",
      "type_mapping": [
        [
          "version",
          "u32"
        ],
        [
          "methods",
          "Vec<Text>"
        ]
      ]
    },
    "AssetBalance": {
      "type": "struct",
      "type_mapping": [
        [
          "balance",
          "TAssetBalance"
        ],
        [
          "isFrozen",
          "bool"
        ],
        [
          "isZombie",
          "bool"
        ]
      ]
    },
    "AssetDetails": {
      "type": "struct",
      "type_mapping": [
        [
          "owner",
          "AccountId"
        ],
        [
          "issuer",
          "AccountId"
        ],
        [
          "admin",
          "AccountId"
        ],
        [
          "freezer",
          "AccountId"
        ],
        [
          "supply",
          "TAssetBalance"
        ],
        [
          "deposit",
          "TAssetDepositBalance"
        ],
        [
          "maxZombies",
          "u32"
        ],
        [
          "minBalance",
          "TAssetBalance"
        ],
        [
          "zombies",
          "u32"
        ],
        [
          "accounts",
          "u32"
        ]
      ]
    },
    "TAssetBalance": "Balance",
    "TAssetDepositBalance": "BalanceOf",
    "CreatedBlock": {
      "type": "struct",
      "type_mapping": [
        [
          "hash",
          "BlockHash"
        ],
        [
          "aux",
          "ImportedAux"
        ]
      ]
    },
    "ImportedAux": {
      "type": "struct",
      "type_mapping": [
        [
          "headerOnly",
          "bool"
        ],
        [
          "clearJustificationRequests",
          "bool"
        ],
        [
          "needsJustification",
          "bool"
        ],
        [
          "badJustification",
          "bool"
        ],
        [
          "needsFinalityProof",
          "bool"
        ],
        [
          "isNewBest",
          "bool"
        ]
      ]
    },
    "Conviction": {
      "type": "enum",
      "value_list": [
        "None",
        "Locked1x",
        "Locked2x",
        "Locked3x",
        "Locked4x",
        "Locked5x",
        "Locked6x"
      ]
    },
    "PropIndex": "u32",
    "Proposal": "Call",
    "ReferendumIndex": "u32",
    "ReferendumInfoTo239": {
      "type": "struct",
      "type_mapping": [
        [
          "end",
          "BlockNumber"
        ],
        [
          "proposalHash",
          "Hash"
        ],
        [
          "threshold",
          "VoteThreshold"
        ],
        [
          "delay",
          "BlockNumber"
        ]
      ]
    },
    "ApprovalFlag": "u32",
    "SetIndex": "u32",
    "Vote": "GenericVote",
    "VoteIndex": "u32",
    "VoterInfo": {
      "type": "struct",
      "type_mapping": [
        [
          "lastActive",
          "VoteIndex"
        ],
        [
          "lastWin",
          "VoteIndex"
        ],
        [
          "pot",
          "Balance"
        ],
        [
          "stake",
          "Balance"
        ]
      ]
    },
    "VoteThreshold": {
      "type": "enum",
      "value_list": [
        "Super majority approval",
        "Super majority rejection",
        "Simple majority"
      ]
    },
    "EthereumAddress": "H160",
    "AbridgedCandidateReceipt": {
      "type": "struct",
      "type_mapping": [
        [
          "parachainIndex",
          "ParaId"
        ],
        [
          "relayParent",
          "Hash"
        ],
        [
          "headData",
          "HeadData"
        ],
        [
          "collator",
          "CollatorId"
        ],
        [
          "signature",
          "CollatorSignature"
        ],
        [
          "povBlockHash",
          "Hash"
        ],
        [
          "commitments",
          "CandidateCommitments"
        ]
      ]
    },
    "Bidder": {
      "type": "enum",
      "type_mapping": [
        [
          "New",
          "NewBidder"
        ],
        [
          "Existing",
          "ParaId"
        ]
      ]
    },
    "BackedCandidate": {
      "type": "struct",
      "type_mapping": [
        [
          "candidate",
          "CommittedCandidateReceipt"
        ],
        [
          "validityVotes",
          "Vec<ValidityAttestation>"
        ],
        [
          "validatorIndices",
          "BitVec"
        ]
      ]
    },
    "CandidateCommitments": {
      "type": "struct",
      "type_mapping": [
        [
          "upwardMessages",
          "Vec<UpwardMessage>"
        ],
        [
          "horizontalMessages",
          "Vec<OutboundHrmpMessage>"
        ],
        [
          "newValidationCode",
          "Option<ValidationCode>"
        ],
        [
          "headData",
          "HeadData"
        ],
        [
          "processedDownwardMessages",
          "u32"
        ],
        [
          "hrmpWatermark",
          "BlockNumber"
        ]
      ]
    },
    "CandidateDescriptor": {
      "type": "struct",
      "type_mapping": [
        [
          "paraId",
          "u32"
        ],
        [
          "relayParent",
          "Hash"
        ],
        [
          "collatorId",
          "Hash"
        ],
        [
          "persistedValidationDataHash",
          "Hash"
        ],
        [
          "povHash",
          "Hash"
        ],
        [
          "erasureRoot",
          "Hash"
        ],
        [
          "signature",
          "Signature"
        ]
      ]
    },
    "CandidatePendingAvailablility": {
      "type": "struct",
      "type_mapping": [
        [
          "core",
          "u32"
        ],
        [
          "descriptor",
          "CandidateDescriptor"
        ],
        [
          "availabilityVotes",
          "BitVec"
        ],
        [
          "relayParentNumber",
          "BlockNumber"
        ],
        [
          "backedInNumber",
          "BlockNumber"
        ]
      ]
    },
    "CandidateReceipt": {
      "type": "struct",
      "type_mapping": [
        [
          "descriptor",
          "CandidateDescriptor"
        ],
        [
          "commitmentsHash",
          "Hash"
        ]
      ]
    },
    "CommittedCandidateReceipt": {
      "type": "struct",
      "type_mapping": [
        [
          "descriptor",
          "CandidateDescriptor"
        ],
        [
          "commitments",
          "CandidateCommitments"
        ]
      ]
    },
    "DownwardMessage": {
      "type": "enum",
      "type_mapping": [
        [
          "TransferInto",
          "(AccountId, Balance, Remark)"
        ],
        [
          "Opaque",
          "Vec<u8>"
        ]
      ]
    },
    "GlobalValidationSchedule": {
      "type": "struct",
      "type_mapping": [
        [
          "maxCodeSize",
          "u32"
        ],
        [
          "maxHeadDataSize",
          "u32"
        ],
        [
          "blockNumber",
          "BlockNumber"
        ]
      ]
    },
    "HeadData": "Bytes",
    "HrmpChannelId": {
      "type": "struct",
      "type_mapping": [
        [
          "sender",
          "u32"
        ],
        [
          "receiver",
          "u32"
        ]
      ]
    },
    "LocalValidationData": {
      "type": "struct",
      "type_mapping": [
        [
          "parentHead",
          "HeadData"
        ],
        [
          "balance",
          "Balance"
        ],
        [
          "codeUpgradeAllowed",
          "Option<BlockNumber>"
        ]
      ]
    },
    "ParachainDispatchOrigin": {
      "type": "enum",
      "value_list": [
        "Signed",
        "Parachain",
        "Root"
      ]
    },
    "RelayChainBlockNumber": "BlockNumber",
    "Remark": "[u8; 32]",
    "Retriable": {
      "type": "enum",
      "type_mapping": [
        [
          "Never",
          "Null"
        ],
        [
          "WithRetries",
          "u32"
        ]
      ]
    },
    "Scheduling": {
      "type": "enum",
      "value_list": [
        "Always",
        "Dynamic"
      ]
    },
    "SignedAvailabilityBitfield": {
      "type": "struct",
      "type_mapping": [
        [
          "payload",
          "BitVec"
        ],
        [
          "validatorIndex",
          "u32"
        ],
        [
          "signature",
          "Signature"
        ]
      ]
    },
    "SignedAvailabilityBitfields": "Vec<SignedAvailabilityBitfield>",
    "UpwardMessage": "Bytes",
    "AssetOptions": {
      "type": "struct",
      "type_mapping": [
        [
          "initalIssuance",
          "Compact<Balance>"
        ],
        [
          "permissions",
          "PermissionLatest"
        ]
      ]
    },
    "Owner": {
      "type": "enum",
      "type_mapping": [
        [
          "None",
          "Null"
        ],
        [
          "Address",
          "AccountId"
        ]
      ]
    },
    "PermissionsV1": {
      "type": "struct",
      "type_mapping": [
        [
          "update",
          "Owner"
        ],
        [
          "mint",
          "Owner"
        ],
        [
          "burn",
          "Owner"
        ]
      ]
    },
    "PermissionVersions": {
      "type": "enum",
      "type_mapping": [
        [
          "V1",
          "PermissionsV1"
        ]
      ]
    },
    "PermissionLatest": "PermissionsV1",
    "Approvals": "[bool; 4]",
    "ContractExecResultSuccessTo255": {
      "type": "struct",
      "type_mapping": [
        [
          "status",
          "u8"
        ],
        [
          "data",
          "Raw"
        ]
      ]
    },
    "ContractExecResultTo255": {
      "type": "enum",
      "type_mapping": [
        [
          "Success",
          "ContractExecResultSuccessTo255"
        ],
        [
          "Error",
          "Null"
        ]
      ]
    },
    "AccountStatus": {
      "type": "struct",
      "type_mapping": [
        [
          "validity",
          "AccountValidity"
        ],
        [
          "freeBalance",
          "Balance"
        ],
        [
          "lockedBalance",
          "Balance"
        ],
        [
          "signature",
          "Vec<u8>"
        ],
        [
          "vat",
          "Permill"
        ]
      ]
    },
    "AccountValidity": {
      "type": "enum",
      "value_list": [
        "Invalid",
        "Initiated",
        "Pending",
        "ValidLow",
        "ValidHigh",
        "Completed"
      ]
    }
  }
}