{
  "types": {
    "()": "Null",
    "Type": "GenericStringType",
    "Text": "String",
    "Hash": "H256",
    "Call": "GenericCall",
    "BlockNumber": "U32",
    "SlotNumber": "u64",
    "VrfOutput": "[u8; 32]",
    "VrfProof": "[u8; 64]",
    "RawAuraPreDigest": {
      "type": "struct",
      "type_mapping": [
        [
          "slot_number",
          "u64"
        ]
      ]
    },
    "RawBabePreDigest": {
      "type": "enum",
      "type_mapping": [
        [
          "Phantom",
          "Null"
        ],
        [
          "Primary",
          "RawBabePreDigestPrimary"
        ],
        [
          "SecondaryPlain",
          "RawBabePreDigestSecondaryPlain"
        ],
        [
          "SecondaryVRF",
          "RawBabePreDigestSecondaryVRF"
        ]
      ]
    },
    "RawBabePreDigestPrimary": {
      "type": "struct",
      "type_mapping": [
        [
          "authority_index",
          "u32"
        ],
        [
          "slot_number",
          "SlotNumber"
        ],
        [
          "vrf_output",
          "VrfOutput"
        ],
        [
          "vrf_proof",
          "VrfProof"
        ]
      ]
    },
    "RawBabePreDigestSecondaryPlain": {
      "type": "struct",
      "type_mapping": [
        [
          "authority_index",
          "u32"
        ],
        [
          "slot_number",
          "SlotNumber"
        ]
      ]
    },
    "RawBabePreDigestSecondaryVRF": {
      "type": "struct",
      "type_mapping": [
        [
          "authority_index",
          "u32"
        ],
        [
          "slot_number",
          "SlotNumber"
        ],
        [
          "vrf_output",
          "VrfOutput"
        ],
        [
          "vrf_proof",
          "VrfProof"
        ]
      ]
    },
    "DoubleMapTypeV9": {
      "type": "struct",
      "type_mapping": [
        [
          "hasher",
          "StorageHasherV9"
        ],
        [
          "key1",
          "Type"
        ],
        [
          "key2",
          "Type"
        ],
        [
          "value",
          "Type"
        ],
        [
          "key2_hasher",
          "StorageHasherV9"
        ]
      ]
    },
    "ErrorMetadataV9": {
      "type": "struct",
      "base_class": "GenericErrorMetadata",
      "type_mapping": [
        [
          "name",
          "Text"
        ],
        [
          "documentation",
          "Vec<Text>"
        ]
      ]
    },
    "EventMetadataV9": {
      "type": "struct",
      "base_class": "GenericEventMetadata",
      "type_mapping": [
        [
          "name",
          "Text"
        ],
        [
          "args",
          "Vec<Type>"
        ],
        [
          "documentation",
          "Vec<Text>"
        ]
      ]
    },
    "FunctionArgumentMetadataV9": {
      "type": "struct",
      "base_class": "GenericFunctionArgumentMetadata",
      "type_mapping": [
        [
          "name",
          "Text"
        ],
        [
          "type",
          "Type"
        ]
      ]
    },
    "FunctionMetadataV9": {
      "type": "struct",
      "base_class": "GenericFunctionMetadata",
      "type_mapping": [
        [
          "name",
          "Text"
        ],
        [
          "args",
          "Vec<FunctionArgumentMetadataV9>"
        ],
        [
          "documentation",
          "Vec<Text>"
        ]
      ]
    },
    "MapTypeV9": {
      "type": "struct",
      "type_mapping": [
        [
          "hasher",
          "StorageHasherV9"
        ],
        [
          "key",
          "Type"
        ],
        [
          "value",
          "Type"
        ],
        [
          "linked",
          "bool"
        ]
      ]
    },
    "MetadataV9": {
      "type": "struct",
      "type_mapping": [
        [
          "modules",
          "Vec<ModuleMetadataV9>"
        ]
      ]
    },
    "ModuleConstantMetadataV9": {
      "type": "struct",
      "base_class": "GenericModuleConstantMetadata",
      "type_mapping": [
        [
          "name",
          "Text"
        ],
        [
          "type",
          "Type"
        ],
        [
          "value",
          "Bytes"
        ],
        [
          "documentation",
          "Vec<Text>"
        ]
      ]
    },
    "ModuleMetadataV9": {
      "type": "struct",
      "base_class": "GenericPalletMetadata",
      "type_mapping": [
        [
          "name",
          "Text"
        ],
        [
          "storage",
          "Option<StorageMetadataV9>"
        ],
        [
          "calls",
          "Option<Vec<FunctionMetadataV9>>"
        ],
        [
          "events",
          "Option<Vec<EventMetadataV9>>"
        ],
        [
          "constants",
          "Vec<ModuleConstantMetadataV9>"
        ],
        [
          "errors",
          "Vec<ErrorMetadataV9>"
        ]
      ]
    },
    "StorageEntryMetadataV9": {
      "type": "struct",
      "base_class": "GenericStorageEntryMetadata",
      "type_mapping": [
        [
          "name",
          "String"
        ],
        [
          "modifier",
          "StorageEntryModifierV9"
        ],
        [
          "type",
          "StorageEntryTypeV9"
        ],
        [
          "default",
          "Bytes"
        ],
        [
          "documentation",
          "Vec<Text>"
        ]
      ]
    },
    "StorageEntryModifierV9": {
      "type": "enum",
      "value_list": [
        "Optional",
        "Default",
        "Required"
      ]
    },
    "StorageEntryTypeV9": {
      "type": "enum",
      "type_mapping": [
        [
          "Plain",
          "Type"
        ],
        [
          "Map",
          "MapTypeV9"
        ],
        [
          "DoubleMap",
          "DoubleMapTypeV9"
        ]
      ]
    },
    "StorageHasherV9": {
      "type": "enum",
      "type_mapping": [
        [
          "Blake2_128",
          null
        ],
        [
          "Blake2_256",
          null
        ],
        [
          "Blake2_128Concat",
          null
        ],
        [
          "Twox128",
          null
        ],
        [
          "Twox256",
          null
        ],
        [
          "Twox64Concat",
          null
        ]
      ]
    },
    "StorageMetadataV9": {
      "type": "struct",
      "type_mapping": [
        [
          "prefix",
          "Text"
        ],
        [
          "entries",
          "Vec<StorageEntryMetadataV9>"
        ]
      ]
    },
    "DoubleMapTypeV10": {
      "type": "struct",
      "type_mapping": [
        [
          "hasher",
          "StorageHasherV10"
        ],
        [
          "key1",
          "Type"
        ],
        [
          "key2",
          "Type"
        ],
        [
          "value",
          "Type"
        ],
        [
          "key2_hasher",
          "StorageHasherV10"
        ]
      ]
    },
    "ErrorMetadataV10": "ErrorMetadataV9",
    "EventMetadataV10": "EventMetadataV9",
    "FunctionArgumentMetadataV10": "FunctionArgumentMetadataV9",
    "FunctionMetadataV10": "FunctionMetadataV9",
    "MapTypeV10": {
      "type": "struct",
      "type_mapping": [
        [
          "hasher",
          "StorageHasherV10"
        ],
        [
          "key",
          "Type"
        ],
        [
          "value",
          "Type"
        ],
        [
          "linked",
          "bool"
        ]
      ]
    },
    "MetadataV10": {
      "type": "struct",
      "type_mapping": [
        [
          "modules",
          "Vec<ModuleMetadataV10>"
        ]
      ]
    },
    "ModuleConstantMetadataV10": "ModuleConstantMetadataV9",
    "ModuleMetadataV10": {
      "type": "struct",
      "base_class": "GenericPalletMetadata",
      "type_mapping": [
        [
          "name",
          "Text"
        ],
        [
          "storage",
          "Option<StorageMetadataV10>"
        ],
        [
          "calls",
          "Option<Vec<FunctionMetadataV10>>"
        ],
        [
          "events",
          "Option<Vec<EventMetadataV10>>"
        ],
        [
          "constants",
          "Vec<ModuleConstantMetadataV10>"
        ],
        [
          "errors",
          "Vec<ErrorMetadataV10>"
        ]
      ]
    },
    "StorageEntryModifierV10": "StorageEntryModifierV9",
    "StorageEntryMetadataV10": {
      "type": "struct",
      "base_class": "GenericStorageEntryMetadata",
      "type_mapping": [
        [
          "name",
          "String"
        ],
        [
          "modifier",
          "StorageEntryModifierV10"
        ],
        [
          "type",
          "StorageEntryTypeV10"
        ],
        [
          "default",
          "Bytes"
        ],
        [
          "documentation",
          "Vec<Text>"
        ]
      ]
    },
    "StorageEntryTypeV10": {
      "type": "enum",
      "type_mapping": [
        [
          "Plain",
          "Type"
        ],
        [
          "Map",
          "MapTypeV10"
        ],
        [
          "DoubleMap",
          "DoubleMapTypeV10"
        ]
      ]
    },
    "StorageMetadataV10": {
      "type": "struct",
      "type_mapping": [
        [
          "prefix",
          "Text"
        ],
        [
          "entries",
          "Vec<StorageEntryMetadataV10>"
        ]
      ]
    },
    "StorageHasherV10": {
      "type": "enum",
      "type_mapping": [
        [
          "Blake2_128",
          null
        ],
        [
          "Blake2_256",
          null
        ],
        [
          "Blake2_128Concat",
          null
        ],
        [
          "Twox128",
          null
        ],
        [
          "Twox256",
          null
        ],
        [
          "Twox64Concat",
          null
        ]
      ]
    },
    "DoubleMapTypeV11": {
      "type": "struct",
      "type_mapping": [
        [
          "hasher",
          "StorageHasherV11"
        ],
        [
          "key1",
          "Type"
        ],
        [
          "key2",
          "Type"
        ],
        [
          "value",
          "Type"
        ],
        [
          "key2_hasher",
          "StorageHasherV11"
        ]
      ]
    },
    "ErrorMetadataV11": "ErrorMetadataV10",
    "EventMetadataV11": "EventMetadataV10",
    "ExtrinsicMetadataV11": {
      "type": "struct",
      "type_mapping": [
        [
          "version",
          "u8"
        ],
        [
          "signed_extensions",
          "Vec<Text>"
        ]
      ]
    },
    "FunctionArgumentMetadataV11": "FunctionArgumentMetadataV10",
    "FunctionMetadataV11": "FunctionMetadataV10",
    "MapTypeV11": {
      "type": "struct",
      "type_mapping": [
        [
          "hasher",
          "StorageHasherV11"
        ],
        [
          "key",
          "Type"
        ],
        [
          "value",
          "Type"
        ],
        [
          "linked",
          "bool"
        ]
      ]
    },
    "MetadataV11": {
      "type": "struct",
      "type_mapping": [
        [
          "modules",
          "Vec<ModuleMetadataV11>"
        ],
        [
          "extrinsic",
          "ExtrinsicMetadataV11"
        ]
      ]
    },
    "ModuleConstantMetadataV11": "ModuleConstantMetadataV10",
    "ModuleMetadataV11": {
      "type": "struct",
      "base_class": "GenericPalletMetadata",
      "type_mapping": [
        [
          "name",
          "Text"
        ],
        [
          "storage",
          "Option<StorageMetadataV11>"
        ],
        [
          "calls",
          "Option<Vec<FunctionMetadataV11>>"
        ],
        [
          "events",
          "Option<Vec<EventMetadataV11>>"
        ],
        [
          "constants",
          "Vec<ModuleConstantMetadataV11>"
        ],
        [
          "errors",
          "Vec<ErrorMetadataV11>"
        ]
      ]
    },
    "StorageEntryModifierV11": "StorageEntryModifierV10",
    "StorageEntryMetadataV11": {
      "type": "struct",
      "base_class": "GenericStorageEntryMetadata",
      "type_mapping": [
        [
          "name",
          "Text"
        ],
        [
          "modifier",
          "StorageEntryModifierV11"
        ],
        [
          "type",
          "StorageEntryTypeV11"
        ],
        [
          "default",
          "Bytes"
        ],
        [
          "documentation",
          "Vec<Text>"
        ]
      ]
    },
    "StorageEntryTypeV11": {
      "type": "enum",
      "type_mapping": [
        [
          "Plain",
          "Type"
        ],
        [
          "Map",
          "MapTypeV11"
        ],
        [
          "DoubleMap",
          "DoubleMapTypeV11"
        ]
      ]
    },
    "StorageMetadataV11": {
      "type": "struct",
      "type_mapping": [
        [
          "prefix",
          "Text"
        ],
        [
          "entries",
          "Vec<StorageEntryMetadataV11>"
        ]
      ]
    },
    "StorageHasherV11": {
      "type": "enum",
      "value_list": [
          "Blake2_128",
          "Blake2_256",
          "Blake2_128Concat",
          "Twox128",
          "Twox256",
          "Twox64Concat",
          "Identity"
      ]
    },
    "DoubleMapTypeV12": "DoubleMapTypeV11",
    "ErrorMetadataV12": "ErrorMetadataV11",
    "EventMetadataV12": "EventMetadataV11",
    "ExtrinsicMetadataV12": "ExtrinsicMetadataV11",
    "FunctionArgumentMetadataV12": "FunctionArgumentMetadataV11",
    "FunctionMetadataV12": "FunctionMetadataV11",
    "MapTypeV12": "MapTypeV11",
    "MetadataV12": {
      "type": "struct",
      "type_mapping": [
        [
          "modules",
          "Vec<ModuleMetadataV12>"
        ],
        [
          "extrinsic",
          "ExtrinsicMetadataV12"
        ]
      ]
    },
    "ModuleConstantMetadataV12": "ModuleConstantMetadataV11",
    "ModuleMetadataV12": {
      "type": "struct",
      "base_class": "GenericPalletMetadata",
      "type_mapping": [
        [
          "name",
          "Text"
        ],
        [
          "storage",
          "Option<StorageMetadataV12>"
        ],
        [
          "calls",
          "Option<Vec<FunctionMetadataV12>>"
        ],
        [
          "events",
          "Option<Vec<EventMetadataV12>>"
        ],
        [
          "constants",
          "Vec<ModuleConstantMetadataV12>"
        ],
        [
          "errors",
          "Vec<ErrorMetadataV12>"
        ],
        [
          "index",
          "u8"
        ]
      ]
    },
    "StorageEntryModifierV12": "StorageEntryModifierV11",
    "StorageEntryMetadataV12": "StorageEntryMetadataV11",
    "StorageEntryTypeV12": "StorageEntryTypeV11",
    "StorageMetadataV12": "StorageMetadataV11",
    "StorageHasherV12": "StorageHasherV11",
    "DoubleMapTypeV13": "DoubleMapTypeV12",
    "ErrorMetadataV13": "ErrorMetadataV12",
    "EventMetadataV13": "EventMetadataV12",
    "ExtrinsicMetadataV13": "ExtrinsicMetadataV12",
    "FunctionArgumentMetadataV13": "FunctionArgumentMetadataV12",
    "FunctionMetadataV13": "FunctionMetadataV12",
    "MapTypeV13": "MapTypeV12",
    "MetadataV13": {
      "type": "struct",
      "type_mapping": [
        [
          "modules",
          "Vec<ModuleMetadataV13>"
        ],
        [
          "extrinsic",
          "ExtrinsicMetadataV13"
        ]
      ]
    },
    "ModuleConstantMetadataV13": "ModuleConstantMetadataV9",
    "ModuleMetadataV13": {
      "type": "struct",
      "base_class": "GenericPalletMetadata",
      "type_mapping": [
        [
          "name",
          "Text"
        ],
        [
          "storage",
          "Option<StorageMetadataV13>"
        ],
        [
          "calls",
          "Option<Vec<FunctionMetadataV13>>"
        ],
        [
          "events",
          "Option<Vec<EventMetadataV13>>"
        ],
        [
          "constants",
          "Vec<ModuleConstantMetadataV13>"
        ],
        [
          "errors",
          "Vec<ErrorMetadataV13>"
        ],
        [
          "index",
          "u8"
        ]
      ]
    },
    "NMapTypeV13": {
      "type": "struct",
      "type_mapping": [
        [
          "keys",
          "Vec<Type>"
        ],
        [
          "hashers",
          "Vec<StorageHasherV13>"
        ],
        [
          "value",
          "Type"
        ]
      ]
    },
    "StorageEntryModifierV13": "StorageEntryModifierV12",
    "StorageEntryMetadataV13": {
      "type": "struct",
      "base_class": "GenericStorageEntryMetadata",
      "type_mapping": [
        [
          "name",
          "String"
        ],
        [
          "modifier",
          "StorageEntryModifierV13"
        ],
        [
          "type",
          "StorageEntryTypeV13"
        ],
        [
          "default",
          "Bytes"
        ],
        [
          "documentation",
          "Vec<Text>"
        ]
      ]
    },
    "StorageEntryTypeV13": {
      "type": "enum",
      "type_mapping": [
        [
          "Plain",
          "Type"
        ],
        [
          "Map",
          "MapTypeV13"
        ],
        [
          "DoubleMap",
          "DoubleMapTypeV13"
        ],
        [
          "NMap",
          "NMapTypeV13"
        ]
      ]
    },
    "StorageMetadataV13": {
      "type": "struct",
      "type_mapping": [
        [
          "prefix",
          "Text"
        ],
        [
          "entries",
          "Vec<StorageEntryMetadataV13>"
        ]
      ]
    },
    "StorageHasherV13": "StorageHasherV12",
    "DoubleMapTypeLatest": "DoubleMapTypeV13",
    "ErrorMetadataLatest": "ErrorMetadataV13",
    "EventMetadataLatest": "EventMetadataV13",
    "ExtrinsicMetadataLatest": "ExtrinsicMetadataV13",
    "FunctionArgumentMetadataLatest": "FunctionArgumentMetadataV13",
    "FunctionMetadataLatest": "FunctionMetadataV13",
    "MapTypeLatest": "MapTypeV13",
    "MetadataLatest": "MetadataV13",
    "ModuleConstantMetadataLatest": "ModuleConstantMetadataV13",
    "ModuleMetadataLatest": "ModuleMetadataV13",
    "NMapTypeLatest": "NMapTypeV13",
    "StorageEntryMetadataLatest": "StorageEntryMetadataV13",
    "StorageEntryModifierLatest": "StorageEntryModifierV13",
    "StorageEntryTypeLatest": "StorageEntryTypeV13",
    "StorageMetadataLatest": "StorageMetadataV13",
    "StorageHasher": "StorageHasherV13",
    "MetadataAll": {
      "type": "enum",
      "base_class": "GenericMetadataAll",
      "type_mapping": [
        [
          "V0",
          "TypeNotSupported<MetadataV0>"
        ],
        [
          "V1",
          "TypeNotSupported<MetadataV1>"
        ],
        [
          "V2",
          "TypeNotSupported<MetadataV2>"
        ],
        [
          "V3",
          "TypeNotSupported<MetadataV3>"
        ],
        [
          "V4",
          "TypeNotSupported<MetadataV4>"
        ],
        [
          "V5",
          "TypeNotSupported<MetadataV5>"
        ],
        [
          "V6",
          "TypeNotSupported<MetadataV6>"
        ],
        [
          "V7",
          "TypeNotSupported<MetadataV7>"
        ],
        [
          "V8",
          "TypeNotSupported<MetadataV8>"
        ],
        [
          "V9",
          "MetadataV9"
        ],
        [
          "V10",
          "MetadataV10"
        ],
        [
          "V11",
          "MetadataV11"
        ],
        [
          "V12",
          "MetadataV12"
        ],
        [
          "V13",
          "MetadataV13"
        ],
        [
          "V14",
          "MetadataV14"
        ]
      ]
    },
    "MetadataVersioned": {
      "type": "tuple",
      "base_class": "GenericMetadataVersioned",
      "type_mapping": ["[u8; 4]", "MetadataAll"]
    },
    "MetadataV0": "Null",
    "MetadataV1": "Null",
    "MetadataV2": "Null",
    "MetadataV3": "Null",
    "MetadataV4": "Null",
    "MetadataV5": "Null",
    "MetadataV6": "Null",
    "MetadataV7": "Null",
    "MetadataV8": "Null",
    "MetadataV14": {
      "type": "struct",
      "type_mapping": [
        [
          "types",
          "PortableRegistry"
        ],
        [
          "pallets",
          "Vec<PalletMetadataV14>"
        ],
        [
          "extrinsic",
          "ExtrinsicMetadataV14"
        ],
        [
          "runtime_type",
          "SiLookupTypeId"
        ]
      ]
    },
    "PalletMetadataV14": {
      "type": "struct",
      "base_class": "ScaleInfoPalletMetadata",
      "type_mapping": [
        [
          "name",
          "Text"
        ],
        [
          "storage",
          "Option<StorageMetadataV14>"
        ],
        [
          "calls",
          "Option<PalletCallMetadataV14>"
        ],
        [
          "event",
          "Option<PalletEventMetadataV14>"
        ],
        [
          "constants",
          "Vec<PalletConstantMetadataV14>"
        ],
        [
          "error",
          "Option<PalletErrorMetadataV14>"
        ],
        [
          "index",
          "u8"
        ]
      ]
    },
    "SiLookupTypeId": "Compact<u32>",
    "StorageMetadataV14": {
      "type": "struct",
      "type_mapping": [
        [
          "prefix",
          "Text"
        ],
        [
          "entries",
          "Vec<StorageEntryMetadataV14>"
        ]
      ]
    },
    "StorageEntryMetadataV14": {
      "type": "struct",
      "base_class": "ScaleInfoStorageEntryMetadata",
      "type_mapping": [
        [
          "name",
          "String"
        ],
        [
          "modifier",
          "StorageEntryModifierV13"
        ],
        [
          "type",
          "StorageEntryTypeV14"
        ],
        [
          "default",
          "Bytes"
        ],
        [
          "documentation",
          "Vec<Text>"
        ]
      ]
    },
    "StorageEntryTypeV14": {
      "type": "enum",
      "type_mapping": [
        [
          "Plain",
          "SiLookupTypeId"
        ],
        [
          "Map",
          "MapTypeV14"
        ]
      ]
    },
    "MapTypeV14": {
      "type": "struct",
      "type_mapping": [
        [
          "hashers",
          "Vec<StorageHasherV13>"
        ],
        [
          "key",
          "SiLookupTypeId"
        ],
        [
          "value",
          "SiLookupTypeId"
        ]
      ]
    },
    "PalletCallMetadataV14": {
      "type": "struct",
      "base_class": "ScaleInfoCallMetadata",
      "type_mapping": [
        [
          "ty",
          "SiLookupTypeId"
        ]
      ]
    },
    "FunctionArgumentMetadataV14": {
      "type": "struct",
      "base_class": "ScaleInfoFunctionArgumentMetadata",
      "type_mapping": [
        [
          "name",
          "Text"
        ],
        [
          "type",
          "SiLookupTypeId"
        ]
      ]
    },
    "FunctionMetadataV14": {
      "type": "struct",
      "base_class": "GenericFunctionMetadata",
      "type_mapping": [
        [
          "name",
          "String"
        ],
        [
          "args",
          "Vec<FunctionArgumentMetadataV14>"
        ],
        [
          "documentation",
          "Vec<String>"
        ]
      ]
    },
    "PalletEventMetadataV14": {
      "type": "struct",
      "base_class": "ScaleInfoPalletEventMetadata",
      "type_mapping": [
        [
          "ty",
          "SiLookupTypeId"
        ]
      ]
    },
    "PalletConstantMetadataV14": {
      "type": "struct",
      "base_class": "ScaleInfoModuleConstantMetadata",
      "type_mapping": [
        [
          "name",
          "String"
        ],
         [
          "type",
          "SiLookupTypeId"
        ],
        [
          "value",
          "Bytes"
        ],
        [
          "documentation",
          "Vec<String>"
        ]
      ]
    },
    "PalletErrorMetadataV14": {
      "type": "struct",
      "base_class": "ScaleInfoPalletErrorMetadata",
      "type_mapping": [
        [
          "ty",
          "SiLookupTypeId"
        ]
      ]
    },
    "ExtrinsicMetadataV14": {
      "type": "struct",
      "type_mapping": [
        [
          "ty",
          "SiLookupTypeId"
        ],
        [
          "version",
          "u8"
        ],
        [
          "signed_extensions",
          "Vec<SignedExtensionMetadataV14>"
        ]
      ]
    },
    "SignedExtensionMetadataV14": {
      "type": "struct",
      "type_mapping": [
        [
          "identifier",
          "String"
        ],
        [
          "ty",
          "SiLookupTypeId"
        ],
        [
          "additional_signed",
          "SiLookupTypeId"
        ]
      ]
    },
    "TypeParameter": {
      "type": "struct",
      "type_mapping": [
        [
          "name",
          "String"
        ],
        [
          "type",
          "Option<SiLookupTypeId>"
        ]
      ]
    },
    "RegistryType": {
      "type": "struct",
      "base_class": "GenericRegistryType",
      "type_mapping": [
        [
          "path",
          "Vec<String>"
        ],
        [
          "params",
          "Vec<TypeParameter>"
        ],
        [
          "def",
          "TypeDef"
        ],
        [
          "docs",
          "Vec<String>"
        ]
      ]
    },
    "PortableType": {
      "type": "struct",
      "type_mapping": [
        [
          "id",
          "SiLookupTypeId"
        ],
        [
          "type",
          "RegistryType"
        ]
      ]
    },
    "PortableRegistry": {
      "type": "struct",
      "type_mapping": [
        [
          "types",
          "Vec<PortableType>"
        ]
      ]
    },
    "TypeDef": {
      "type": "enum",
      "type_mapping": [
        [
          "composite",
          "TypeDefComposite"
        ],
        [
          "variant",
          "TypeDefVariant"
        ],
        [
          "sequence",
          "TypeDefSequence"
        ],
        [
          "array",
          "TypeDefArray"
        ],
        [
          "tuple",
          "TypeDefTuple"
        ],
        [
          "primitive",
          "TypeDefPrimitive"
        ],
        [
          "compact",
          "TypeDefCompact"
        ],
        [
          "bitsequence",
          "TypeDefBitSequence"
        ]
      ]
    },
    "Field": {
      "type": "struct",
      "base_class": "GenericField",
      "type_mapping": [
        [
          "name",
          "Option<String>"
        ],
        [
          "type",
          "SiLookupTypeId"
        ],
        [
          "typeName",
          "Option<String>"
        ],
        [
          "docs",
          "Vec<String>"
        ]
      ]
    },
    "TypeDefComposite": {
      "type": "struct",
      "base_class": "GenericTypeDefComposite",
      "type_mapping": [
        [
          "fields",
          "Vec<Field>"
        ]
      ]
    },
    "TypeDefVariant": {
      "type": "struct",
      "base_class": "GenericTypeDefVariant",
      "type_mapping": [
        [
          "variants",
          "Vec<Variant>"
        ]
      ]
    },
    "Variant": {
      "type": "struct",
      "base_class": "GenericVariant",
      "type_mapping": [
        [
          "name",
          "String"
        ],
        [
          "fields",
          "Vec<Field>"
        ],
        [
          "index",
          "u8"
        ],
        [
          "docs",
          "Vec<String>"
        ]
      ]
    },
    "TypeDefSequence": {
      "type": "struct",
      "type_mapping": [
        [
          "type",
          "SiLookupTypeId"
        ]
      ]
    },
    "TypeDefArray": {
      "type": "struct",
      "type_mapping": [
        [
          "len",
          "u32"
        ],
        [
          "type",
          "SiLookupTypeId"
        ]
      ]
    },
    "TypeDefTuple": "Vec<SiLookupTypeId>",
    "TypeDefPrimitive": {
      "type": "enum",
      "value_list": [
          "bool",
          "char",
          "str",
          "u8",
          "u16",
          "u32",
          "u64",
          "u128",
          "u256",
          "i8",
          "i16",
          "i32",
          "i64",
          "i128",
          "i256"
      ]
    },
    "TypeDefCompact": {
      "type": "struct",
      "type_mapping": [
        [
          "type",
          "SiLookupTypeId"
        ]
      ]
    },
    "TypeDefPhantom": "Null",
    "TypeDefBitSequence": {
      "type": "struct",
      "type_mapping": [
        [
          "bit_store_type",
          "SiLookupTypeId"
        ],
        [
          "bit_order_type",
          "SiLookupTypeId"
        ]
      ]
    },
    "Extrinsic": "GenericExtrinsic",
    "Inherent": {
      "type": "struct",
      "type_mapping": [
        [
          "call",
          "Call"
        ]
      ]
    },
    "ExtrinsicSignature": "MultiSignature",
    "ExtrinsicV4": {
      "type": "struct",
      "base_class": "GenericExtrinsicV4",
      "type_mapping": [
        [
          "address",
          "Address"
        ],
        [
          "signature",
          "ExtrinsicSignature"
        ],
        [
          "era",
          "Era"
        ],
        [
          "nonce",
          "Compact<Index>"
        ],
        [
          "tip",
          "Compact<Balance>"
        ],
        [
          "call",
          "Call"
        ]
      ]
    },
    "ExtrinsicPayloadValue": {
      "type": "struct",
      "type_mapping": [
        [
          "call",
          "CallBytes"
        ],
        [
          "era",
          "Era"
        ],
        [
          "nonce",
          "Compact<Index>"
        ],
        [
          "tip",
          "Compact<Balance>"
        ],
        [
          "spec_version",
          "u32"
        ],
        [
          "transaction_version",
          "u32"
        ],
        [
          "genesis_hash",
          "Hash"
        ],
        [
          "block_hash",
          "Hash"
        ]
      ]
    },
    "MultiAddress": "GenericMultiAddress",
    "Address": "MultiAddress",
    "AccountId": "GenericAccountId",
    "Signature": "H512",
    "Index": "u32",
    "Balance": "u128",
    "EcdsaSignature": "[u8; 65]",
    "Ed25519Signature": "H512",
    "Sr25519Signature": "H512",
    "AnySignature": "H512",
    "MultiSignature": {
      "type": "enum",
      "type_mapping": [
        [
          "Ed25519",
          "Ed25519Signature"
        ],
        [
          "Sr25519",
          "Sr25519Signature"
        ],
        [
          "Ecdsa",
          "EcdsaSignature"
        ]
      ]
    },
    "Compact<Moment>": "CompactMoment",
    "primitive_types::H256": "H256",
    "primitive_types::U256": "U256",
    "sp_core::crypto::AccountId32": "GenericAccountId",
    "sp_runtime::multiaddress::MultiAddress": "GenericMultiAddress",
    "sp_runtime::generic::era::Era": "Era",
    "*::vote::Vote": "GenericVote",
    "pallet_identity::types::Data": "Data",
    "sp_core::bounded::bounded_vec::BoundedVec": "BoundedVec",
    "sp_core::bounded::weak_bounded_vec::WeakBoundedVec": "BoundedVec",
    "frame_support::storage::weak_bounded_vec::WeakBoundedVec": "BoundedVec",
    "frame_support::storage::bounded_vec::BoundedVec": "BoundedVec",
    "frame_support::traits::misc::WrapperKeepOpaque": "WrapperKeepOpaque",
    "*::Call": "GenericCall",
    "*::RuntimeCall": "GenericCall",
    "*::runtime::Call": "GenericCall",
    "*::Event": {
      "type": "struct",
      "base_class": "GenericScaleInfoEvent",
      "type_mapping": []
    },
    "*::RuntimeEvent": {
      "type": "struct",
      "base_class": "GenericScaleInfoEvent",
      "type_mapping": []
    },
    "*::runtime::Event": {
      "type": "struct",
      "base_class": "GenericScaleInfoEvent",
      "type_mapping": []
    },
    "*::EventRecord": {
      "type": "struct",
      "base_class": "GenericEventRecord",
      "type_mapping": []
    },
    "ink_env::types::AccountId": "GenericAccountId",
    "ink_primitives::types::AccountId": "GenericAccountId",
    "WeightV1": "u64",
    "WeightV2": "sp_weights::weight_v2::Weight",
    "ContractExecResultTo267": {
      "type": "struct",
      "base_class": "GenericContractExecResultV2",
      "type_mapping": [
        [
          "gas_consumed",
          "Weight"
        ],
        [
          "gas_required",
          "Weight"
        ],
        [
          "storage_deposit",
          "StorageDeposit"
        ],
        [
          "debug_message",
          "Bytes"
        ],
        [
          "result",
          "ContractExecResultResult"
        ]
      ]
    },
    "ContractExecResultTo269": {
      "type": "struct",
      "base_class": "GenericContractExecResultV2",
      "type_mapping": [
        [
          "gas_consumed",
          "Weight"
        ],
        [
          "gas_required",
          "Weight"
        ],
        [
          "storage_deposit",
          "StorageDeposit"
        ],
        [
          "debug_message",
          "Bytes"
        ],
        [
          "result",
          "ContractExecResultResult"
        ],
        [
          "events",
          "Option<Vec<frame_system::eventrecord>>"
        ]
      ]
    },
    "ContractExecResultResult": {
      "type": "enum",
      "type_mapping": [
        [
          "Ok",
          "ContractExecResultOk"
        ],
        [
          "Error",
          "sp_runtime::dispatcherror"
        ]
      ]
    },
    "ContractExecResultOk": {
      "type": "struct",
      "type_mapping": [
        [
          "flags",
          "ContractCallFlags"
        ],
        [
          "data",
          "Bytes"
        ]
      ]
    },
    "ContractCallFlags": {
      "type": "set",
      "value_type": "u32",
      "value_list": {
        "ForwardInput": 1,
        "CloneInput": 2,
        "TailCall": 4,
        "AllowReentry":  8
      }
    },
    "ContractExecResultTo260": {
      "type": "enum",
      "base_class": "GenericContractExecResult",
      "type_mapping": [
        [
          "Success",
          "ContractExecResultSuccessTo260"
        ],
        [
          "Error",
          "Null"
        ]
      ]
    },
    "ContractExecResultSuccessTo260": {
      "type": "struct",
      "type_mapping": [
        [
          "flags",
          "u32"
        ],
        [
          "data",
          "Bytes"
        ],
        [
          "gas_consumed",
          "u64"
        ]
      ]
    },
    "ContractExecResult": "ContractExecResultTo267",
    "RuntimeCallDefinition": {
      "type": "struct",
      "base_class": "GenericRuntimeCallDefinition",
      "type_mapping": [
        [
          "api",
          "String"
        ],
        [
          "method",
          "String"
        ],
        [
          "description",
          "String"
        ],
        [
          "params",
          "Vec<RuntimeCallDefinitionParam>"
        ],
        [
          "type",
          "String"
        ]
      ]
    },
    "RuntimeCallDefinitionParam": {
      "type": "struct",
      "type_mapping": [
        [
          "name",
          "String"
        ],
        [
          "type",
          "String"
        ]
      ]
    }
  },
  "runtime_api": {
    "AccountNonceApi": {
      "methods": {
        "account_nonce": {
          "description": "The API to query account nonce (aka transaction index)",
          "params": [
            {
              "name": "account_id",
              "type": "AccountId"
            }
          ],
          "type": "Index"
        }
      }
    },
    "AuthorityDiscoveryApi": {
      "methods": {
        "authorities": {
          "description": "Retrieve authority identifiers of the current and next authority set.",
          "params": [],
          "type": "Vec<AuthorityId>"
        }
      },
      "types": {
        "AuthorityId": "AccountId"
      }
    },
    "BlockBuilder": {
      "methods": {
        "apply_extrinsic": {
          "description": "Apply the given extrinsic.",
          "params": [
            {
              "name": "extrinsic",
              "type": "Extrinsic"
            }
          ],
          "type": "ApplyExtrinsicResult"
        },
        "finalise_block": {
          "description": "Finalize the current block.",
          "params": [],
          "type": "Header"
        }
      },
      "types": {
        "ApplyExtrinsicResult": {
          "type": "enum",
          "type_mapping": [
            [
              "Ok",
              "Result"
            ],
            [
              "Error",
              "TransactionValidityError"
            ]
          ]
        },
        "TransactionValidityError": {
          "type": "enum",
          "type_mapping": [
            [
              "Invalid",
              "InvalidTransaction"
            ],
            [
              "Unknown",
              "UnknownTransaction"
            ]
          ]
        },
        "UnknownTransaction": {
          "type": "enum",
          "type_mapping": [
            [
              "CannotLookup",
              "Null"
            ],
            [
              "NoUnsignedValidator",
              "Null"
            ],
            [
              "Custom",
              "u8"
            ]
          ]
        },
        "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"
            ],
            [
              "BadSigner",
              "Null"
            ]
          ]
        },
        "Header": {
          "type": "struct",
          "type_mapping": [
            [
              "parent_hash",
              "Hash"
            ],
            [
              "number",
              "Compact<BlockNumber>"
            ],
            [
              "state_root",
              "Hash"
            ],
            [
              "extrinsics_root",
              "Hash"
            ],
            [
              "digest",
              "sp_runtime::generic::digest::digest"
            ]
          ]
        }
      }
    },
    "ContractsApi": {
      "methods": {
        "call": {
          "description": "Perform a call from a specified account to a given contract.",
          "params": [
            {
              "name": "origin",
              "type": "AccountId"
            },
            {
              "name": "dest",
              "type": "AccountId"
            },
            {
              "name": "value",
              "type": "Balance"
            },
            {
              "name": "gas_limit",
              "type": "Option<Weight>"
            },
            {
              "name": "storage_deposit_limit",
              "type": "Option<Balance>"
            },
            {
              "name": "input_data",
              "type": "Vec<u8>"
            }
          ],
          "type": "ContractExecResult"
        },
        "get_storage": {
          "description": "Query a given storage key in a given contract.",
          "params": [
            {
              "name": "address",
              "type": "AccountId"
            },
            {
              "name": "key",
              "type": "Bytes"
            }
          ],
          "type": "Option<Bytes>"
        },
        "upload_code": {
          "description": "Upload new code without instantiating a contract from it.",
          "params": [
            {
              "name": "origin",
              "type": "AccountId"
            },
            {
              "name": "code",
              "type": "Bytes"
            },
            {
              "name": "storage_deposit_limit",
              "type": "Option<Balance>"
            }
          ],
          "type": "CodeUploadResult"
        },
        "instantiate": {
          "description": "Instantiate a new contract.",
          "params": [
            {
              "name": "origin",
              "type": "AccountId"
            },
            {
              "name": "value",
              "type": "Balance"
            },
            {
              "name": "gas_limit",
              "type": "Option<Weight>"
            },
            {
              "name": "storage_deposit_limit",
              "type": "Option<Balance>"
            },
            {
              "name": "code",
              "type": "CodeSource"
            },
            {
              "name": "data",
              "type": "Bytes"
            },
            {
              "name": "salt",
              "type": "Bytes"
            }
          ],
          "type": "ContractInstantiateResult"
        }
      },
      "types": {
        "CodeUploadResult": {
          "type": "enum",
          "type_mapping": [
            [
              "Ok",
              "CodeUploadResultValue"
            ],
            [
              "Error",
              "sp_runtime::dispatcherror"
            ]
          ]
        },
        "CodeHash": "Hash",
        "CodeUploadResultValue": {
          "type": "struct",
          "type_mapping": [
            [
              "code_hash",
              "CodeHash"
            ],
            [
              "deposit",
              "Balance"
            ]
          ]
        },
        "CodeSource": {
          "type": "enum",
          "type_mapping": [
            [
              "Upload",
              "Bytes"
            ],
            [
              "Existing",
              "Hash"
            ]
          ]
        },
        "ContractInstantiateResult": {
          "type": "struct",
          "type_mapping": [
            [
              "gas_consumed",
              "u64"
            ],
            [
              "gas_required",
              "u64"
            ],
            [
              "storage_deposit",
              "StorageDeposit"
            ],
            [
              "debug_message",
              "Text"
            ],
            [
              "result",
              "InstantiateReturnValue"
            ]
          ]
        },
        "StorageDeposit": {
          "type": "enum",
          "type_mapping": [
            [
              "Refund",
              "Balance"
            ],
            [
              "Charge",
              "Balance"
            ]
          ]
        },
        "InstantiateReturnValue": {
          "type": "enum",
          "type_mapping": [
            [
              "Ok",
              "InstantiateReturnValueOk"
            ],
            [
              "Error",
              "sp_runtime::dispatcherror"
            ]
          ]
        },
        "InstantiateReturnValueOk": {
          "type": "struct",
          "type_mapping": [
            [
              "result",
              "ExecReturnValue"
            ],
            [
              "account_id",
              "AccountId"
            ]
          ]
        },
        "ExecReturnValue": {
          "type": "struct",
          "type_mapping": [
            [
              "flags",
              "ContractReturnFlags"
            ],
            [
              "data",
              "Bytes"
            ]
          ]
        },
        "ContractReturnFlags": {
          "type": "set",
          "value_list": {
            "Display": 1
          }
        }
      }
    },
    "ConvertTransactionRuntimeApi": {
      "methods": {
        "convert_transaction": {
          "description": "Converts an Ethereum-style transaction to Extrinsic",
          "params": [
            {
              "name": "transaction",
              "type": "TransactionV2"
            }
          ],
          "type": "Extrinsic"
        },
        "initialise_block": {
          "description": "Initialize a block with the given header.",
          "params": [
            {
              "name": "header",
              "type": "Header"
            }
          ],
          "type": "Null"
        }
      },
      "types": {
        "TransactionV2": {
          "type": "enum",
          "type_mapping": [
            ["Legacy", "LegacyTransaction"],
            ["EIP2930", "EIP2930Transaction"],
            ["EIP1559", "EIP1559Transaction"]
          ]
        },
        "LegacyTransaction": {
          "type": "struct",
          "type_mapping": [
             ["nonce", "U256"],
             ["gas_price", "U256"],
             ["gas_limit", "U256"],
             ["action", "EthTransactionAction"],
             ["value", "U256"],
             ["input", "Bytes"],
             ["signature", "EthTransactionSignature"]
          ]
        },
        "EthAddress": "H160",
        "EthAccessListItem": {
          "type": "struct",
          "type_mapping": [
            ["address", "EthAddress"],
            ["slots", "Vec<H256>"]
          ]
        },
        "EthAccessList": "Vec<EthAccessListItem>",
        "EIP2930Transaction": {
          "type": "struct",
          "type_mapping": [
             ["chain_id", "u64"],
             ["nonce", "U256"],
             ["gas_price", "U256"],
             ["gas_limit", "U256"],
             ["action", "EthTransactionAction"],
             ["value", "U256"],
             ["input", "Bytes"],
             ["access_list", "EthAccessList"],
             ["odd_y_parity", "bool"],
             ["r", "H256"],
             ["s", "H256"]
          ]
        },
        "EIP1559Transaction": {
          "type": "struct",
          "type_mapping": [
             ["chain_id", "u64"],
             ["nonce", "U256"],
             ["max_priority_fee_per_gas", "U256"],
             ["max_fee_per_gas", "U256"],
             ["gas_limit", "U256"],
             ["action", "EthTransactionAction"],
             ["value", "U256"],
             ["input", "Bytes"],
             ["access_list", "EthAccessList"],
             ["odd_y_parity", "bool"],
             ["r", "H256"],
             ["s", "H256"]
          ]
        },
        "EthTransactionAction": {
          "type": "enum",
          "type_mapping": [
            [
              "Call",
              "H160"
            ],
            [
              "Create",
              "Null"
            ]
          ]
        },
        "EthTransactionSignature": {
          "type": "struct",
          "type_mapping": [
             ["v", "u64"],
             ["r", "H256"],
             ["s", "H256"]
          ]
        },
        "Header": {
          "type": "struct",
          "type_mapping": [
            [
              "parent_hash",
              "Hash"
            ],
            [
              "number",
              "Compact<BlockNumber>"
            ],
            [
              "state_root",
              "Hash"
            ],
            [
              "extrinsics_root",
              "Hash"
            ],
            [
              "digest",
              "sp_runtime::generic::digest::digest"
            ]
          ]
        }
      }
    },
    "Core": {
      "methods": {
        "version": {
          "description": "Returns the version of the runtime.",
          "params": [],
          "type": "RuntimeVersion"
        },
        "initialise_block": {
          "description": "Initialize a block with the given header.",
          "params": [
            {
              "name": "header",
              "type": "Header"
            }
          ],
          "type": "Null"
        }
      },
      "types": {
        "RuntimeVersion": {
          "type": "struct",
          "type_mapping": [
            ["spec_name", "Text"],
            ["impl_name", "Text"],
            ["authoring_version", "u32"],
            ["spec_version", "u32"],
            ["impl_version", "u32"],
            ["apis", "Vec<RuntimeVersionApi>"],
            ["transaction_version", "u32"],
            ["state_version", "u8"]
          ]
        },
        "ApiId": "[u8; 8]",
        "RuntimeVersionApi": "(ApiId, u32)",
        "Header": {
          "type": "struct",
          "type_mapping": [
            [
              "parent_hash",
              "Hash"
            ],
            [
              "number",
              "Compact<BlockNumber>"
            ],
            [
              "state_root",
              "Hash"
            ],
            [
              "extrinsics_root",
              "Hash"
            ],
            [
              "digest",
              "sp_runtime::generic::digest::digest"
            ]
          ]
        }
      }
    },
    "EthereumRuntimeRPCApi": {
      "methods": {
        "account_basic": {
          "description": "Returns pallet_evm::Accounts by address.",
          "params": [
            {
              "name": "address",
              "type": "H160"
            }
          ],
          "type": "EvmAccount"
        },
        "account_code_at": {
          "description": "For a given account address, returns pallet_evm::AccountCodes.",
          "params": [
            {
              "name": "address",
              "type": "H160"
            }
          ],
          "type": "Bytes"
        },
        "author": {
          "description": "Returns the converted FindAuthor::find_author authority id.",
          "params": [],
          "type": "H160"
        },
        "call": {
          "description": "Returns a frame_ethereum::call response. If `estimate` is true,",
          "params": [
            {
              "name": "from",
              "type": "H160"
            },
            {
              "name": "to",
              "type": "H160"
            },
            {
              "name": "data",
              "type": "Bytes"
            },
            {
              "name": "value",
              "type": "u256"
            },
            {
              "name": "gas_limit",
              "type": "u256"
            },
            {
              "name": "max_fee_per_gas",
              "type": "Option<u256>"
            },
            {
              "name": "max_priority_per_gas",
              "type": "Option<u256>"
            },
            {
              "name": "nonce",
              "type": "Option<u256>"
            },
            {
              "name": "estimate",
              "type": "bool"
            },
            {
              "name": "access_list",
              "type": "Option<Vec<(H160, Vec<H256>)>>"
            }
          ],
          "type": "EvmCallResult"
        },
        "chain_id": {
          "description": "Returns runtime defined pallet_evm::ChainId.",
          "params": [],
          "type": "u64"
        },
        "create": {
          "description": "Returns a frame_ethereum::call response.",
          "params": [
            {
              "name": "from",
              "type": "H160"
            },
            {
              "name": "data",
              "type": "Bytes"
            },
            {
              "name": "value",
              "type": "u256"
            },
            {
              "name": "gas_limit",
              "type": "u256"
            },
            {
              "name": "max_fee_per_gas",
              "type": "Option<u256>"
            },
            {
              "name": "max_priority_per_gas",
              "type": "Option<u256>"
            },
            {
              "name": "nonce",
              "type": "Option<u256>"
            },
            {
              "name": "estimate",
              "type": "bool"
            },
            {
              "name": "access_list",
              "type": "Option<Vec<(H160, Vec<H256>)>>"
            }
          ],
          "type": "EvmCreateResult"
        },
        "current_all": {
          "description": "Return all the current data for a block in a single runtime call.",
          "params": [],
          "type": "(Option<BlockV2>, Option<Vec<EthReceiptV3>>, Option<Vec<EthTransactionStatus>>)"
        },
        "current_block": {
          "description": "Return the current block.",
          "params": [],
          "type": "BlockV2"
        },
        "current_receipts": {
          "description": "Return the current receipt.",
          "params": [],
          "type": "Option<Vec<EthReceiptV3>>"
        },
        "current_transaction_statuses": {
          "description": "Return the current transaction status.",
          "params": [],
          "type": "Option<Vec<EthTransactionStatus>>"
        },
        "elasticity": {
          "description": "Return the elasticity multiplier.",
          "params": [],
          "type": "Option<Permill>"
        },
        "extrinsic_filter": {
          "description": "Receives a `Vec<OpaqueExtrinsic>` and filters all the ethereum transactions.",
          "params": [
            {
              "name": "xts",
              "type": "Vec<Extrinsic>"
            }
          ],
          "type": "Vec<TransactionV2>"
        },
        "gas_price": {
          "description": "Returns FixedGasPrice::min_gas_price",
          "params": [],
          "type": "u256"
        },
        "storage_at": {
          "description": "For a given account address and index, returns pallet_evm::AccountStorages.",
          "params": [
            {
              "name": "address",
              "type": "H160"
            },
            {
              "name": "index",
              "type": "u256"
            }
          ],
          "type": "H256"
        }
      },
      "types": {
        "EvmAccount": {
          "type": "struct",
          "type_mapping": [
            [
              "nonce",
              "u256"
            ],
            [
              "balance",
              "u256"
            ]
          ]
        },
        "EthReceiptV3": {
          "type": "struct",
          "type_mapping": [
             ["transaction_hash", "Option<H256>"],
             ["transaction_index", "Option<U256>"],
             ["block_hash", "Option<H256>"],
             ["from", "Option<EthAddress>"],
             ["to", "Option<EthAddress>"],
             ["block_number", "Option<U256>"],
             ["cumulative_gas_used", "U256"],
             ["gas_used", "Option<U256>"],
             ["contract_address", "Option<EthAddress>"],
             ["logs", "Vec<EthLog>"],
             ["root", "Option<H256>"],
             ["logs_bloom", "EthBloom"],
             ["status_code", "Option<U64>"]
          ]
        },
        "EthLog": {
           "type": "struct",
          "type_mapping": [
             ["address", "EthAddress"],
             ["topics", "Vec<H256>"],
             ["data", "Bytes"],
             ["block_hash", "Option<H256>"],
             ["block_number", "Option<U256>"],
             ["transaction_hash", "Option<H256>"],
             ["transaction_index", "Option<U256>"],
             ["log_index", "Option<U256>"],
             ["transaction_log_index", "Option<U256>"],
             ["removed", "bool"]
          ]
        },
        "EthTransactionStatus": {
          "type": "struct",
          "type_mapping": [
             ["transaction_hash", "H256"],
             ["transaction_index", "U32"],
             ["from", "EthAddress"],
             ["to", "Option<EthAddress>"],
             ["contract_address", "Option<EthAddress>"],
             ["logs", "Vec<EthLog>"],
             ["logs_bloom", "EthBloom"]
          ]
        },
        "EvmCreateResult": {
          "type": "enum",
          "type_mapping": [
            [
              "Ok",
              "EvmCreateInfo"
            ],
            [
              "Error",
              "sp_runtime::dispatcherror"
            ]
          ]
        },
        "EvmCreateInfo": {
          "type": "struct",
          "type_mapping": [
            [
              "exit_reason",
              "ExitReason"
            ],
            [
              "value",
              "H160"
            ],
            [
              "used_gas",
              "U256"
            ],
            [
              "logs",
              "Vec<EvmLog>"
            ]
          ]
        },
        "EvmCallResult": {
          "type": "enum",
          "type_mapping": [
            [
              "Ok",
              "EvmCallInfo"
            ],
            [
              "Error",
              "sp_runtime::dispatcherror"
            ]
          ]
        },
        "EvmCallInfo": {
          "type": "struct",
          "type_mapping": [
            [
              "exit_reason",
              "ExitReason"
            ],
            [
              "value",
              "Bytes"
            ],
            [
              "used_gas",
              "U256"
            ],
            [
              "logs",
              "Vec<EvmLog>"
            ]
          ]
        },
        "EvmLog": {
          "type": "struct",
          "type_mapping": [
            [
              "address",
              "H160"
            ],
            [
              "topics",
              "Vec<H256>"
            ],
            [
              "data",
              "Bytes"
            ]
          ]
        },
        "ExitReason": {
          "type": "enum",
          "type_mapping": [
            [
              "Succeed",
              "ExitSucceed"
            ],
            [
              "Error",
              "ExitError"
            ],
            [
              "Revert",
              "ExitRevert"
            ],
            [
              "Fatal",
              "ExitFatal"
            ]
          ]
        },
        "ExitSucceed": {
          "type": "enum",
          "value_list": [
            "Stopped",
            "Returned",
            "Suicided"
          ]
        },
        "ExitError": {
          "type": "enum",
          "type_mapping": [
            [
              "StackUnderflow",
              "Null"
            ],
            [
              "StackOverflow",
              "Null"
            ],
            [
              "InvalidJump",
              "Null"
            ],
            [
              "InvalidRange",
              "Null"
            ],
            [
              "DesignatedInvalid",
              "Null"
            ],
            [
              "CallTooDeep",
              "Null"
            ],
            [
              "CreateCollision",
              "Null"
            ],
            [
              "CreateContractLimit",
              "Null"
            ],
            [
              "OutOfOffset",
              "Null"
            ],
            [
              "OutOfGas",
              "Null"
            ],
            [
              "OutOfFund",
              "Null"
            ],
            [
              "PCUnderflow",
              "Null"
            ],
            [
              "CreateEmpty",
              "Null"
            ],
            [
              "Other",
              "Text"
            ]
          ]
        },
        "ExitRevert": {
          "type": "enum",
          "value_list": [
            "Reverted"
          ]
        },
        "ExitFatal": {
          "type": "enum",
          "type_mapping": [
            [
              "NotSupported",
              "Null"
            ],
            [
              "UnhandledInterrupt",
              "Null"
            ],
            [
              "CallErrorAsFatal",
              "ExitError"
            ],
            [
              "Other",
              "Text"
            ]
          ]
        },
        "BlockV2": {
          "type": "struct",
          "type_mapping": [
            [
              "header",
              "EthHeader"
            ],
            [
              "transactions",
              "Vec<TransactionV2>"
            ],
            [
              "ommers",
              "Vec<EthHeader>"
            ]
          ]
        },
        "EthHeader": {
          "type": "struct",
          "type_mapping": [
             ["parent_hash", "H256"],
             ["ommers_hash", "H256"],
             ["beneficiary", "EthAddress"],
             ["state_root", "H256"],
             ["transactions_root", "H256"],
             ["receipts_root", "H256"],
             ["logs_bloom", "EthBloom"],
             ["difficulty", "U256"],
             ["number", "U256"],
             ["gas_limit", "U256"],
             ["gas_used", "U256"],
             ["timestamp", "u64"],
             ["extra_data", "Bytes"],
             ["mix_mash", "H256"],
             ["nonce", "H64"]
          ]
        },
        "EthBloom": "H2048",
        "H2048": "[u8; 256]",
        "H64": "[u8; 8]",
        "Permill": "u32",
        "TransactionV2": {
          "type": "enum",
          "type_mapping": [
            ["Legacy", "LegacyTransaction"],
            ["EIP2930", "EIP2930Transaction"],
            ["EIP1559", "EIP1559Transaction"]
          ]
        },
        "LegacyTransaction": {
          "type": "struct",
          "type_mapping": [
             ["nonce", "U256"],
             ["gas_price", "U256"],
             ["gas_limit", "U256"],
             ["action", "EthTransactionAction"],
             ["value", "U256"],
             ["input", "Bytes"],
             ["signature", "EthTransactionSignature"]
          ]
        },
        "EthTransactionAction": {
          "type": "enum",
          "type_mapping": [
            [
              "Call",
              "H160"
            ],
            [
              "Create",
              "Null"
            ]
          ]
        },
        "EthTransactionSignature": {
          "type": "struct",
          "type_mapping": [
             ["v", "u64"],
             ["r", "H256"],
             ["s", "H256"]
          ]
        },
        "EthAccessListItem": {
          "type": "struct",
          "type_mapping": [
            ["address", "EthAddress"],
            ["slots", "Vec<H256>"]
          ]
        },
        "EthAccessList": "Vec<EthAccessListItem>",
        "EIP2930Transaction": {
          "type": "struct",
          "type_mapping": [
             ["chain_id", "u64"],
             ["nonce", "U256"],
             ["gas_price", "U256"],
             ["gas_limit", "U256"],
             ["action", "EthTransactionAction"],
             ["value", "U256"],
             ["input", "Bytes"],
             ["access_list", "EthAccessList"],
             ["odd_y_parity", "bool"],
             ["r", "H256"],
             ["s", "H256"]
          ]
        },
        "EIP1559Transaction": {
          "type": "struct",
          "type_mapping": [
             ["chain_id", "u64"],
             ["nonce", "U256"],
             ["max_priority_fee_per_gas", "U256"],
             ["max_fee_per_gas", "U256"],
             ["gas_limit", "U256"],
             ["action", "EthTransactionAction"],
             ["value", "U256"],
             ["input", "Bytes"],
             ["access_list", "EthAccessList"],
             ["odd_y_parity", "bool"],
             ["r", "H256"],
             ["s", "H256"]
          ]
        }
      }
    },
    "Metadata": {
      "methods": {
        "metadata": {
          "description": "Returns the metadata of a runtime",
          "params": [],
          "type": "Bytes"
        }
      },
      "types": {}
    },
    "NominationPoolsApi": {
      "methods": {
        "pending_rewards": {
          "description": "Returns the pending rewards for the given member.",
          "params": [
            {
              "name": "member",
              "type": "AccountId"
            }
          ],
          "type": "Balance"
        }
      },
      "types": {}
    },
    "SessionKeys": {
      "methods": {
        "decode_session_keys": {
          "description": "Decode the given public session keys.",
          "params": [
            {
              "name": "encoded",
              "type": "Bytes"
            }
          ],
          "type": "Option<Vec<(Bytes, KeyTypeId)>>"
        },
        "generate_session_keys": {
          "description": "Generate a set of session keys with optionally using the given seed.",
          "params": [
            {
              "name": "seed",
              "type": "Option<Bytes>"
            }
          ],
          "type": "Bytes"
        }
      },
      "types": {
        "KeyTypeId": "u32"
      }
    },
    "TransactionPaymentApi": {
      "methods": {
        "query_fee_details": {
          "description": "The transaction fee details",
          "params": [
            {
              "name": "uxt",
              "type": "Extrinsic"
            },
            {
              "name": "len",
              "type": "u32"
            }
          ],
          "type": "FeeDetails"
        },
        "query_info": {
          "description": "The transaction info",
          "params": [
            {
              "name": "uxt",
              "type": "Extrinsic"
            },
            {
              "name": "len",
              "type": "u32"
            }
          ],
          "type": "RuntimeDispatchInfo"
        }
      },
      "types": {
        "FeeDetails": {
          "type": "struct",
          "type_mapping": [
            ["inclusion_fee", "Option<InclusionFee>"],
            ["tip", "Balance"]
          ]
        },
        "InclusionFee": {
          "type": "struct",
          "type_mapping": [
            ["base_fee", "Balance"],
            ["len_fee", "Balance"],
            ["adjusted_weight_fee", "Balance"]
          ]
        },
        "DispatchClass": {
          "type": "enum",
          "value_list": [
            "Normal",
            "Operational",
            "Mandatory"
          ]
        },
        "RuntimeDispatchInfo": {
          "type": "struct",
          "type_mapping": [
            ["weight", "Weight"],
            ["class", "DispatchClass"],
            ["partialFee", "Balance"]
          ]
        }
      }
    },
    "TransactionPaymentCallApi": {
      "methods": {
        "query_call_fee_details": {
          "description": "The call fee details",
          "params": [
            {
              "name": "call",
              "type": "Call"
            },
            {
              "name": "len",
              "type": "u32"
            }
          ],
          "type": "FeeDetails"
        },
        "query_call_info": {
          "description": "The call info",
          "params": [
            {
              "name": "call",
              "type": "Call"
            },
            {
              "name": "len",
              "type": "u32"
            }
          ],
          "type": "RuntimeDispatchInfo"
        }
      },
      "types": {
        "FeeDetails": {
          "type": "struct",
          "type_mapping": [
            ["inclusion_fee", "Option<InclusionFee>"],
            ["tip", "Balance"]
          ]
        },
        "InclusionFee": {
          "type": "struct",
          "type_mapping": [
            ["base_fee", "Balance"],
            ["len_fee", "Balance"],
            ["adjusted_weight_fee", "Balance"]
          ]
        },
        "DispatchClass": {
          "type": "enum",
          "value_list": [
            "Normal",
            "Operational",
            "Mandatory"
          ]
        },
        "RuntimeDispatchInfo": {
          "type": "struct",
          "type_mapping": [
            ["weight", "Weight"],
            ["class", "DispatchClass"],
            ["partialFee", "Balance"]
          ]
        }
      }
    }
  }
}
