scale.rb 0.2.18 → 0.3.2

data/lib/scale_bytes.rb

@@ -0,0 +1,63 @@
+module Scale
+  class Bytes
+    attr_reader :data, :bytes
+    attr_reader :offset
+
+    def initialize(data)
+      if (data.class == Array) && data.is_byte_array?
+        @bytes = data
+      elsif (data.class == String) && data.start_with?("0x") && (data.length % 2 == 0)
+        arr = data[2..].scan(/../).map(&:hex)
+        @bytes = arr
+      else
+        raise "Provided data is not valid"
+      end
+
+      @data = data
+      @offset = 0
+    end
+
+    def reset_offset
+      @offset = 0
+    end
+
+    def get_next_bytes(length)
+      result = @bytes[@offset...@offset + length]
+      if result.length < length
+        str = @data[(2 + @offset * 2)..]
+        str = str.length > 40 ? (str[0...40]).to_s + "..." : str
+        raise "No enough data: #{str}, expect length: #{length}, but #{result.length}" 
+      end
+      @offset += length
+      result
+    rescue RangeError => ex
+      puts "length: #{length}"
+      puts ex.message
+      puts ex.backtrace
+    end
+
+    def get_remaining_bytes
+      @bytes[offset..]
+    end
+
+    def to_hex_string
+      @bytes.bytes_to_hex
+    end
+
+    def to_bin_string
+      @bytes.bytes_to_bin
+    end
+
+    def to_ascii 
+      @bytes[0...offset].pack("C*") + "<================================>" + @bytes[offset..].pack("C*")
+    end
+
+    def ==(other)
+      bytes == other.bytes && offset == other.offset
+    end
+
+    def to_s
+      green(@bytes[0...offset].bytes_to_hex) + yellow(@bytes[offset..].bytes_to_hex[2..])
+    end
+  end
+end

data/lib/substrate_client.rb

@@ -39,6 +39,7 @@ class SubstrateClient
     @url = url
     @request_id = 1
     @metadata_cache = {}
+    init_types_and_metadata
   end
 
   def request(method, params)
@@ -121,8 +122,8 @@ class SubstrateClient
     block = self.chain_getBlock(block_hash)
     SubstrateClient::Helper.decode_block(block)
   rescue => ex
-    puts ex.message
-    puts ex.backtrace.join("\n\t")
+    Scale::Types.logger.error ex
+    Scale::Types.logger.error ex.backtrace.join("\n\t")
   end
 
   def get_block_events(block_hash=nil)
@@ -136,16 +137,18 @@ class SubstrateClient
     [events_data, decoded]
   end
 
-  # Plain: client.get_storage("Sudo", "Key")
-  # Plain: client.get_storage("Balances", "TotalIssuance")
-  # Map: client.get_storage("System", "Account", ["0xd43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d"])
-  # DoubleMap: client.get_storage("ImOnline", "AuthoredBlocks", [2818, "0x749ddc93a65dfec3af27cc7478212cb7d4b0c0357fef35a0163966ab5333b757"])
   def get_storage(module_name, storage_name, params = nil, block_hash = nil)
     self.init_types_and_metadata(block_hash)
 
-    storage_key, return_type = SubstrateClient::Helper.generate_storage_key_from_metadata(@metadata, module_name, storage_name, params)
+    storage_key, return_type, storage_item = SubstrateClient::Helper.generate_storage_key_from_metadata(@metadata, module_name, storage_name, params)
+
     data = self.state_getStorage(storage_key, block_hash)
-    return unless data
+
+    if data.nil?
+      return if storage_item[:modifier] == "Optional"
+
+      data = storage_item[:fallback]
+    end
 
     bytes = Scale::Bytes.new(data)
     type = Scale::Types.get(return_type)

data/lib/type_builder.rb

@@ -0,0 +1,280 @@
+module Scale
+  module Types
+    class << self
+
+      # type_info: type_string or type_def
+      #   type_string: hard coded type name, Compact, H128, Vec<Compact>, (U32, U128), ...
+      #   type_def   : struct, enum, set
+      #
+      # if type_string start_with Scale::Types::, it is treat as a hard coded type
+      def get(type_info)
+        if type_info.class == ::String 
+          if type_info.start_with?('Scale::Types::')
+            return get_hard_coded_type(type_info)
+          end
+
+          # find the final type from registry
+          type_info = fix_name(type_info)
+          type_info = get_final_type_from_registry(type_info)
+        end
+
+        build_type(type_info)
+      end
+
+      private
+        def build_type(type_info)
+          # 1. hard coded types, 2. Vec<...>, 3. Option<...>, 4. [xx; x], 5. (x, y)
+          if type_info.class == ::String 
+            type_string = fix_name(type_info)
+            if type_string =~ /\AVec<.+>\z/ 
+              build_vec(type_string)
+            elsif type_info =~ /\AOption<.+>\z/
+              build_option(type_string)
+            elsif type_info =~ /\A\[.+;\s*\d+\]\z/
+              build_array(type_string)
+            elsif type_info =~ /\A\(.+\)\z/
+              build_tuple(type_string)
+            else
+              get_hard_coded_type(type_string)
+            end
+
+          # 5. Struct, 6. Enum, 7. Set
+          else 
+
+            type_info.transform_keys!(&:to_sym)
+            if type_info[:type] == "struct"
+              build_struct(type_info)
+            elsif type_info[:type] == "enum"
+              build_enum(type_info)
+            elsif type_info[:type] == "set"
+              build_set(type_info)
+            else
+              raise Scale::TypeBuildError.new("Failed to build a type from #{type_info}")
+            end
+
+          end
+        end
+
+        def get_final_type_from_registry(type_info)
+          type_registry = TypeRegistry.instance
+          if type_registry.types.nil?
+            raise TypeRegistryNotLoadYet
+          end
+          TypeRegistry.instance.get(type_info)
+        end
+
+        def get_hard_coded_type(type_name)
+          # type_name = rename(type_name)
+          type_name = (type_name.start_with?("Scale::Types::") ? type_name : "Scale::Types::#{type_name}")
+          type_name.constantize2
+        rescue => e
+          raise Scale::TypeBuildError.new("Failed to get the hard coded type named `#{type_name}`")
+        end
+
+        def build_vec(type_string)
+          inner_type_str = type_string.scan(/\AVec<(.+)>\z/).first.first
+          inner_type = get(inner_type_str)
+
+          type_name = "Vec_#{inner_type.name.gsub('Scale::Types::', '')}_"
+
+          if !Scale::Types.const_defined?(type_name)
+            klass = Class.new do
+              include Scale::Types::Vec
+              inner_type inner_type
+            end
+            Scale::Types.const_set type_name, klass
+          else
+            Scale::Types.const_get type_name
+          end
+        end
+
+        def build_option(type_string)
+          inner_type_str = type_string.scan(/\AOption<(.+)>\z/).first.first
+
+          # an exception
+          # https://substrate.dev/docs/en/knowledgebase/advanced/codec#options
+          return get("Scale::Types::OptionBool") if inner_type_str.camelize2 == "Bool"
+
+          inner_type = get(inner_type_str)
+
+          type_name = "Option_#{inner_type.name.gsub('Scale::Types::', '')}_"
+
+          if !Scale::Types.const_defined?(type_name)
+            klass = Class.new do
+              include Scale::Types::Option
+              inner_type inner_type
+            end
+            Scale::Types.const_set type_name, klass
+          else
+            Scale::Types.const_get type_name
+          end
+        end
+
+        def build_array(type_string)
+          scan_result = type_string.scan /\[(.+);\s*(\d+)\]/
+
+          #
+          inner_type_str = scan_result[0][0]
+          inner_type = get(inner_type_str)
+
+          #
+          len = scan_result[0][1].to_i
+
+          type_name = "Array_#{inner_type.name.gsub('Scale::Types::', '')}_#{len}_"
+
+          if !Scale::Types.const_defined?(type_name)
+            klass = Class.new do
+              include Scale::Types::Array
+              inner_type inner_type
+              length len
+            end
+            Scale::Types.const_set type_name, klass
+          else
+            Scale::Types.const_get type_name
+          end
+        end
+
+        def build_tuple(type_string)
+          scan_result = type_string.scan /\A\((.+)\)\z/
+          inner_types_str = scan_result[0][0]
+          inner_type_strs = inner_types_str.split(",").map do |inner_type_str| 
+            inner_type_str.strip
+          end
+
+          inner_types = inner_type_strs.map do |inner_type_str|
+            get(inner_type_str)
+          end
+
+          type_name = "Tuple_#{inner_types.map {|inner_type| inner_type.name.gsub('Scale::Types::', '')}.join("_")}_"
+          if !Scale::Types.const_defined?(type_name)
+            klass = Class.new do
+              include Scale::Types::Tuple
+              inner_types(*inner_types)
+            end
+            Scale::Types.const_set type_name, klass
+          else
+            Scale::Types.const_get type_name
+          end
+        end
+
+        def build_struct(type_info)
+          # items: {"a" => Type}
+          items = type_info[:type_mapping].map do |item|
+            item_name = item[0]
+            item_type = get(item[1])
+            [item_name, item_type]
+          end.to_h
+
+          partials = []
+          items.each_pair do |item_name, item_type|
+            partials << item_name.camelize2 + 'In' + item_type.name.gsub('Scale::Types::', '') 
+          end
+          type_name = "Struct_#{partials.join('_')}_"
+
+          if !Scale::Types.const_defined?(type_name)
+            klass = Class.new do
+              include Scale::Types::Struct
+              items(**items)
+            end
+            Scale::Types.const_set type_name, klass
+          else
+            Scale::Types.const_get type_name
+          end
+        end
+
+        # not implemented: ["Compact", "Hex"]
+        def build_enum(type_info)
+          # type_mapping: [["Item1", "Compact"], [["Item2", "Hex"]]
+          if type_info.has_key?(:type_mapping)
+            # items: {a: Type}
+            items = type_info[:type_mapping].map do |item|
+              item_name = item[0]
+              item_type = get(item[1])
+              [item_name.to_sym, item_type]
+            end.to_h
+
+            partials = []
+            items.each_pair do |item_name, item_type|
+              partials << item_name.to_s.camelize2 + 'In' + item_type.name.gsub('Scale::Types::', '') 
+            end
+            type_name = "Enum_#{partials.join('_')}_"
+
+            if !Scale::Types.const_defined?(type_name)
+              klass = Class.new do
+                include Scale::Types::Enum
+                items(**items)
+              end
+
+              return Scale::Types.const_set type_name, klass
+            else
+              return Scale::Types.const_get type_name
+            end
+          end
+
+          # value_list: [1, "hello"]
+          if type_info.has_key?(:value_list)
+            type_name = "Enum#{type_info[:value_list].map {|value| value.to_s.camelize2}.join}"
+
+            if !Scale::Types.const_defined?(type_name)
+              klass = Class.new do
+                include Scale::Types::Enum
+                values *type_info[:value_list]
+              end
+              return Scale::Types.const_set type_name, klass
+            else
+              return Scale::Types.const_get type_name
+            end
+          end
+        end
+
+
+        # {
+          # value_type: u32,
+          # value_list: {
+          #   "TransactionPayment" => 0b00000001,
+          #   "Transfer" => 0b00000010,
+          #   "Reserve" => 0b00000100,
+          #   ...
+          # }
+        # }
+        def build_set(type_info)
+          type_name = "Set#{type_info[:value_list].keys.map(&:camelize2).join("")}"
+          if !Scale::Types.const_defined?(type_name)
+            bytes_length = type_info[:value_type][1..].to_i / 8
+            klass = Class.new do
+              include Scale::Types::Set
+              items type_info[:value_list], bytes_length
+            end
+            return Scale::Types.const_set type_name, klass
+          else
+            return Scale::Types.const_get type_name
+          end
+          Scale::Types.const_set fix(name), klass
+        end
+
+        def fix_name(type)
+          type = type.gsub("T::", "")
+            .gsub("<T>", "")
+            .gsub("<T as Trait>::", "")
+            .delete("\n")
+            .gsub(/(u)(\d+)/, 'U\2')
+          return "Bool" if type == "bool"
+          return "Null" if type == "()"
+          return "String" if type == "Vec<u8>"
+          return "Compact" if type == "Compact<u32>" || type == "Compact<U32>"
+          return "Address" if type == "<Lookup as StaticLookup>::Source"
+          return "Compact" if type == "<Balance as HasCompact>::Type"
+          return "Compact" if type == "<BlockNumber as HasCompact>::Type"
+          return "Compact" if type =~ /\ACompact<[a-zA-Z0-9\s]*>\z/
+          return "CompactMoment" if type == "<Moment as HasCompact>::Type"
+          return "CompactMoment" if type == "Compact<Moment>"
+          return "InherentOfflineReport" if type == "<InherentOfflineReport as InherentOfflineReport>::Inherent"
+          return "AccountData" if type == "AccountData<Balance>"
+          return "EventRecord" if type == "EventRecord<Event, Hash>"
+
+          type
+        end
+
+    end
+  end
+end

data/lib/type_registry/darwinia.json

@@ -1,143 +1,677 @@
 {
-  "types": {
-    "Address": "AccountId",
-    "LookupSource": "AccountId",
-    "BalanceLock": {
-      "type": "struct",
-      "type_mapping": [
-        [
-          "id",
-          "LockIdentifier"
-        ],
-        [
-          "lock_for",
-          "LockFor"
-        ],
-        [
-          "lock_reasons",
-          "LockReasons"
-        ]
-      ]
-    },
-    "LockFor": {
-      "type": "enum",
-      "type_mapping": [
-        [
-          "Common",
-          "Common"
-        ],
-        [
-          "Staking",
-          "StakingLock"
-        ]
-      ]
+  "versioning": [
+    {
+      "runtime_range": [
+        1,
+        23
+      ],
+      "types": {
+        "ElectionResultT": {
+          "type": "struct",
+          "type_mapping": [
+            [
+              "elected_stashes",
+              "Vec<AccountId>"
+            ],
+            [
+              "exposures",
+              "Vec<(AccountId, ExposureT)>"
+            ],
+            [
+              "compute",
+              "ElectionCompute"
+            ]
+          ]
+        }
+      }
     },
-    "Common": {
-      "type": "struct",
-      "type_mapping": [
-        [
-          "amount",
-          "Balance"
-        ]
-      ]
+    {
+      "runtime_range": [
+        1,
+        22
+      ],
+      "types": {
+        "Address": "AccountId",
+        "LookupSource": "AccountId"
+      }
     },
-    "StakingLock": {
-      "type": "struct",
-      "type_mapping": [
-        [
-          "staking_amount",
-          "Balance"
-        ],
-        [
-          "unbondings",
-          "Vec<Unbonding>"
-        ]
-      ]
+    {
+      "runtime_range": [
+        16,
+        24
+      ],
+      "types": {
+        "ScheduledAuthoritiesChangeT": {
+          "type": "struct",
+          "type_mapping": [
+            [
+              "next_authorities",
+              "Vec<RelayAuthorityT>"
+            ],
+            [
+              "deadline",
+              "BlockNumber"
+            ]
+          ]
+        }
+      }
     },
-    "LockReasons": {
-      "type": "enum",
-      "type_mapping": [
-        [
-          "Fee",
-          "Null"
-        ],
-        [
-          "Misc",
-          "Null"
-        ],
-        [
-          "All",
-          "Null"
-        ]
-      ]
+    {
+      "runtime_range": [
+        15,
+        24
+      ],
+      "types": {
+        "OpCode": "[u8; 4]"
+      }
     },
-    "Unbonding": {
-      "type": "struct",
-      "type_mapping": [
-        [
-          "amount",
-          "Balance"
-        ],
-        [
-          "until",
-          "BlockNumber"
-        ]
-      ]
+    {
+      "runtime_range": [
+        15,
+        15
+      ],
+      "types": {
+        "ScheduledAuthoritiesChange": {
+          "type": "struct",
+          "type_mapping": [
+            [
+              "next_authorities",
+              "Vec<RelayAuthorityT>"
+            ],
+            [
+              "deadline",
+              "BlockNumber"
+            ]
+          ]
+        }
+      }
     },
-    "AccountData": {
-      "type": "struct",
-      "type_mapping": [
-        [
-          "free",
-          "Balance"
-        ],
-        [
-          "reserved",
-          "Balance"
-        ],
-        [
-          "free_kton",
-          "Balance"
-        ],
-        [
-          "reserved_kton",
-          "Balance"
-        ]
-      ]
+    {
+      "runtime_range": [
+        1,
+        9
+      ],
+      "types": {
+        "OtherSignature": {
+          "type": "enum",
+          "type_mapping": [
+            [
+              "Eth",
+              "EcdsaSignature"
+            ],
+            [
+              "Tron",
+              "EcdsaSignature"
+            ]
+          ]
+        },
+        "EcdsaSignature": "[u8; 65]",
+        "OtherAddress": {
+          "type": "enum",
+          "type_mapping": [
+            [
+              "Eth",
+              "[u8; 20]"
+            ],
+            [
+              "Tron",
+              "[u8; 20]"
+            ]
+          ]
+        },
+        "AddressT": "[u8; 20]",
+        "MerkleMountainRangeRootLog": {
+          "type": "struct",
+          "type_mapping": [
+            [
+              "prefix",
+              "[u8; 4]"
+            ],
+            [
+              "mmr_root",
+              "Hash"
+            ]
+          ]
+        }
+      }
     },
-    "RingBalance": "Balance",
-    "KtonBalance": "Balance",
-    "TsInMs": "u64",
-    "Power": "u32",
-    "DepositId": "U256",
-    "StakingBalanceT": {
-      "type": "enum",
-      "type_mapping": [
-        [
-          "RingBalance",
-          "Balance"
-        ],
-        [
-          "KtonBalance",
-          "Balance"
-        ]
-      ]
+    {
+      "runtime_range": [
+        10,
+        24
+      ],
+      "types": {
+        "EcdsaMessage": "[u8; 32]",
+        "RelayAuthoritySigner": "EthereumAddress",
+        "RelayAuthorityMessage": "EcdsaMessage",
+        "RelayAuthoritySignature": "EcdsaSignature",
+        "Term": "u32",
+        "RelayAuthorityT": {
+          "type": "struct",
+          "type_mapping": [
+            [
+              "account_id",
+              "AccountId"
+            ],
+            [
+              "signer",
+              "Signer"
+            ],
+            [
+              "stake",
+              "Balance"
+            ],
+            [
+              "term",
+              "BlockNumber"
+            ]
+          ]
+        },
+        "MMRRoot": "Hash",
+        "MerkleMountainRangeRootLog": {
+          "type": "struct",
+          "type_mapping": [
+            [
+              "prefix",
+              "[u8; 4]"
+            ],
+            [
+              "parent_mmr_root",
+              "Hash"
+            ]
+          ]
+        },
+        "EthereumRelayHeaderParcel": {
+          "type": "struct",
+          "type_mapping": [
+            [
+              "header",
+              "EthereumHeader"
+            ],
+            [
+              "parent_mmr_root",
+              "H256"
+            ]
+          ]
+        }
+      }
     },
-    "StakingLedgerT": {
-      "type": "struct",
-      "type_mapping": [
-        [
-          "stash",
-          "AccountId"
-        ],
-        [
-          "active_ring",
-          "Compact<Balance>"
-        ],
-        [
-          "active_deposit_ring",
-          "Compact<Balance>"
-        ],
+    {
+      "runtime_range": [
+        6,
+        24
+      ],
+      "types": {
+        "ProxyType": {
+          "type": "enum",
+          "type_mapping": [
+            [
+              "Any",
+              "Null"
+            ],
+            [
+              "NonTransfer",
+              "Null"
+            ],
+            [
+              "Governance",
+              "Null"
+            ],
+            [
+              "Staking",
+              "Null"
+            ],
+            [
+              "IdentityJudgement",
+              "Null"
+            ],
+            [
+              "EthereumBridge",
+              "Null"
+            ]
+          ]
+        },
+        "RelayProofs": "EthereumRelayProofs"
+      }
+    },
+    {
+      "runtime_range": [
+        5,
+        24
+      ],
+      "types": {
+        "RelayVotingState": {
+          "type": "struct",
+          "type_mapping": [
+            [
+              "ayes",
+              "Vec<AccountId>"
+            ],
+            [
+              "nays",
+              "Vec<AccountId>"
+            ]
+          ]
+        },
+        "RelayHeaderId": "EthereumBlockNumber",
+        "RelayHeaderParcel": "EthereumRelayHeaderParcel",
+        "RelayAffirmationId": {
+          "type": "struct",
+          "type_mapping": [
+            [
+              "game_id",
+              "EthereumBlockNumber"
+            ],
+            [
+              "round",
+              "u32"
+            ],
+            [
+              "index",
+              "u32"
+            ]
+          ]
+        },
+        "RelayAffirmationT": {
+          "type": "struct",
+          "type_mapping": [
+            [
+              "relayer",
+              "AccountId"
+            ],
+            [
+              "relay_header_parcels",
+              "EthereumRelayHeaderParcel"
+            ],
+            [
+              "bond",
+              "Balance"
+            ],
+            [
+              "maybe_extended_relay_affirmation_id",
+              "Option<RelayAffirmationId>"
+            ],
+            [
+              "verified",
+              "bool"
+            ]
+          ]
+        }
+      }
+    },
+    {
+      "runtime_range": [
+        5,
+        5
+      ],
+      "types": {
+        "ProxyType": {
+          "type": "enum",
+          "type_mapping": [
+            [
+              "Any",
+              "Null"
+            ],
+            [
+              "NonTransfer",
+              "Null"
+            ],
+            [
+              "Staking",
+              "Null"
+            ],
+            [
+              "IdentityJudgement",
+              "Null"
+            ],
+            [
+              "EthereumBridge",
+              "Null"
+            ],
+            [
+              "Governance",
+              "Null"
+            ]
+          ]
+        },
+        "RelayProofs": "EthereumRelayProof"
+      }
+    },
+    {
+      "runtime_range": [
+        1,
+        3
+      ],
+      "types": {
+        "EthereumHeaderBrief": {
+          "type": "struct",
+          "type_mapping": [
+            [
+              "total_difficulty",
+              "U256"
+            ],
+            [
+              "parent_hash",
+              "H256"
+            ],
+            [
+              "number",
+              "EthereumBlockNumber"
+            ],
+            [
+              "relayer",
+              "AccountId"
+            ]
+          ]
+        },
+        "EthereumHeaderThingWithProof": {
+          "type": "struct",
+          "type_mapping": [
+            [
+              "header",
+              "EthereumHeader"
+            ],
+            [
+              "ethash_proof",
+              "Vec<EthashProof>"
+            ],
+            [
+              "mmr_root",
+              "H256"
+            ],
+            [
+              "mmr_proof",
+              "Vec<H256>"
+            ]
+          ]
+        },
+        "EthereumHeaderThing": {
+          "type": "struct",
+          "type_mapping": [
+            [
+              "header",
+              "EthereumHeader"
+            ],
+            [
+              "mmr_root",
+              "H256"
+            ]
+          ]
+        },
+        "Round": "u64",
+        "TcHeaderThingWithProof": "EthereumHeaderThingWithProof",
+        "TcHeaderThing": "EthereumHeaderThing",
+        "TcBlockNumber": "u64",
+        "TcHeaderHash": "H256",
+        "GameId": "TcBlockNumber",
+        "RelayProposalT": {
+          "type": "struct",
+          "type_mapping": [
+            [
+              "relayer",
+              "AccountId"
+            ],
+            [
+              "bonded_proposal",
+              "Vec<(Balance, TcHeaderThing)>"
+            ],
+            [
+              "extend_from_header_hash",
+              "Option<TcHeaderHash>"
+            ]
+          ]
+        }
+      }
+    },
+    {
+      "runtime_range": [
+        4,
+        24
+      ],
+      "types": {
+        "EthereumRelayProofs": {
+          "type": "struct",
+          "type_mapping": [
+            [
+              "ethash_proof",
+              "Vec<EthashProof>"
+            ],
+            [
+              "mmr_proof",
+              "Vec<H256>"
+            ]
+          ]
+        }
+      }
+    },
+    {
+      "runtime_range": [
+        4,
+        9
+      ],
+      "types": {
+        "EthereumRelayHeaderParcel": {
+          "type": "struct",
+          "type_mapping": [
+            [
+              "header",
+              "EthereumHeader"
+            ],
+            [
+              "mmr_root",
+              "H256"
+            ]
+          ]
+        }
+      }
+    },
+    {
+      "runtime_range": [
+        4,
+        4
+      ],
+      "types": {
+        "RelayHeaderId": "Vec<u8>",
+        "RelayHeaderParcel": "Vec<u8>",
+        "RelayAffirmationId": {
+          "type": "struct",
+          "type_mapping": [
+            [
+              "relay_header_id",
+              "Vec<u8>"
+            ],
+            [
+              "round",
+              "u32"
+            ],
+            [
+              "index",
+              "u32"
+            ]
+          ]
+        },
+        "RelayAffirmationT": {
+          "type": "struct",
+          "type_mapping": [
+            [
+              "relayer",
+              "AccountId"
+            ],
+            [
+              "relay_header_parcels",
+              "Vec<u8>"
+            ],
+            [
+              "bond",
+              "Balance"
+            ],
+            [
+              "maybe_extended_relay_affirmation_id",
+              "Option<Vec<u8>>"
+            ],
+            [
+              "verified",
+              "bool"
+            ]
+          ]
+        },
+        "RelayProofs": "Vec<u8>"
+      }
+    }
+  ],
+  "types": {
+    "BalanceLock": {
+      "type": "struct",
+      "type_mapping": [
+        [
+          "id",
+          "LockIdentifier"
+        ],
+        [
+          "lock_for",
+          "LockFor"
+        ],
+        [
+          "lock_reasons",
+          "LockReasons"
+        ],
+        [
+          "amount",
+          "Balance"
+        ],
+        [
+          "reasons",
+          "Reasons"
+        ]
+      ]
+    },
+    "LockFor": {
+      "type": "enum",
+      "type_mapping": [
+        [
+          "Common",
+          "Common"
+        ],
+        [
+          "Staking",
+          "StakingLock"
+        ]
+      ]
+    },
+    "Common": {
+      "type": "struct",
+      "type_mapping": [
+        [
+          "amount",
+          "Balance"
+        ]
+      ]
+    },
+    "StakingLock": {
+      "type": "struct",
+      "type_mapping": [
+        [
+          "staking_amount",
+          "Balance"
+        ],
+        [
+          "unbondings",
+          "Vec<Unbonding>"
+        ]
+      ]
+    },
+    "LockReasons": {
+      "type": "enum",
+      "type_mapping": [
+        [
+          "Fee",
+          "Null"
+        ],
+        [
+          "Misc",
+          "Null"
+        ],
+        [
+          "All",
+          "Null"
+        ]
+      ]
+    },
+    "Unbonding": {
+      "type": "struct",
+      "type_mapping": [
+        [
+          "amount",
+          "Balance"
+        ],
+        [
+          "until",
+          "BlockNumber"
+        ]
+      ]
+    },
+    "AccountData": {
+      "type": "struct",
+      "type_mapping": [
+        [
+          "free",
+          "Balance"
+        ],
+        [
+          "reserved",
+          "Balance"
+        ],
+        [
+          "free_kton",
+          "Balance"
+        ],
+        [
+          "reserved_kton",
+          "Balance"
+        ],
+        [
+          "misc_frozen",
+          "Balance"
+        ],
+        [
+          "fee_frozen",
+          "Balance"
+        ]
+      ]
+    },
+    "RingBalance": "Balance",
+    "KtonBalance": "Balance",
+    "TsInMs": "u64",
+    "Power": "u32",
+    "DepositId": "U256",
+    "StakingBalanceT": {
+      "type": "enum",
+      "type_mapping": [
+        [
+          "RingBalance",
+          "Balance"
+        ],
+        [
+          "KtonBalance",
+          "Balance"
+        ]
+      ]
+    },
+    "StakingLedgerT": {
+      "type": "struct",
+      "type_mapping": [
+        [
+          "stash",
+          "AccountId"
+        ],
+        [
+          "active_ring",
+          "Compact<Balance>"
+        ],
+        [
+          "active_deposit_ring",
+          "Compact<Balance>"
+        ],
         [
           "active_kton",
           "Compact<Balance>"
@@ -157,6 +691,18 @@
         [
           "claimed_rewards",
           "Vec<EraIndex>"
+        ],
+        [
+          "total",
+          "Compact<Balance>"
+        ],
+        [
+          "active",
+          "Compact<Balance>"
+        ],
+        [
+          "unlocking",
+          "Vec<UnlockChunk>"
         ]
       ]
     },
@@ -220,23 +766,10 @@
         [
           "power",
           "Power"
-        ]
-      ]
-    },
-    "ElectionResultT": {
-      "type": "struct",
-      "type_mapping": [
-        [
-          "elected_stashes",
-          "Vec<AccountId>"
-        ],
-        [
-          "exposures",
-          "Vec<(AccountId, ExposureT)>"
         ],
         [
-          "compute",
-          "ElectionCompute"
+          "value",
+          "Compact<Balance>"
         ]
       ]
     },
@@ -451,415 +984,58 @@
         ]
       ]
     },
-    "EthereumReceiptProof": {
-      "type": "struct",
-      "type_mapping": [
-        [
-          "index",
-          "u64"
-        ],
-        [
-          "proof",
-          "Bytes"
-        ],
-        [
-          "header_hash",
-          "H256"
-        ]
-      ]
-    },
-    "EthereumReceiptProofThing": "(EthereumHeader, EthereumReceiptProof, MMRProof)",
-    "MMRProof": {
-      "type": "struct",
-      "type_mapping": [
-        [
-          "member_leaf_index",
-          "u64"
-        ],
-        [
-          "last_leaf_index",
-          "u64"
-        ],
-        [
-          "proof",
-          "Vec<H256>"
-        ]
-      ]
-    },
-    "OtherSignature": {
-      "type": "enum",
-      "type_mapping": [
-        [
-          "Eth",
-          "EcdsaSignature"
-        ],
-        [
-          "Tron",
-          "EcdsaSignature"
-        ]
-      ]
-    },
-    "EcdsaSignature": "[u8; 65]",
-    "OtherAddress": {
-      "type": "enum",
-      "type_mapping": [
-        [
-          "Eth",
-          "[u8; 20]"
-        ],
-        [
-          "Tron",
-          "[u8; 20]"
-        ]
-      ]
-    },
-    "AddressT": "[u8; 20]",
-    "MerkleMountainRangeRootLog": {
-      "type": "struct",
-      "type_mapping": [
-        [
-          "prefix",
-          "[u8; 4]"
-        ],
-        [
-          "mmr_root",
-          "Hash"
-        ]
-      ]
-    },
-    "BalancesRuntimeDispatchInfo": {
-      "type": "struct",
-      "type_mapping": [
-        [
-          "usable_balance",
-          "Balance"
-        ]
-      ]
-    },
-    "StakingRuntimeDispatchInfo": {
-      "type": "struct",
-      "type_mapping": [
-        [
-          "power",
-          "Power"
-        ]
-      ]
-    }
-  },
-  "versioning": [
-    {
-      "runtime_range": [
-        6,
-        9
-      ],
-      "types": {
-        "ProxyType": {
-          "type": "enum",
-          "type_mapping": [
-            [
-              "Any",
-              "Null"
-            ],
-            [
-              "NonTransfer",
-              "Null"
-            ],
-            [
-              "Governance",
-              "Null"
-            ],
-            [
-              "Staking",
-              "Null"
-            ],
-            [
-              "IdentityJudgement",
-              "Null"
-            ],
-            [
-              "EthereumBridge",
-              "Null"
-            ]
-          ]
-        },
-        "RelayProofs": "EthereumRelayProofs"
-      }
-    },
-    {
-      "runtime_range": [
-        5,
-        9
-      ],
-      "types": {
-        "RelayVotingState": {
-          "type": "struct",
-          "type_mapping": [
-            [
-              "ayes",
-              "Vec<AccountId>"
-            ],
-            [
-              "nays",
-              "Vec<AccountId>"
-            ]
-          ]
-        },
-        "RelayHeaderId": "EthereumBlockNumber",
-        "RelayHeaderParcel": "EthereumRelayHeaderParcel",
-        "RelayAffirmationId": {
-          "type": "struct",
-          "type_mapping": [
-            [
-              "game_id",
-              "EthereumBlockNumber"
-            ],
-            [
-              "round",
-              "u32"
-            ],
-            [
-              "index",
-              "u32"
-            ]
-          ]
-        },
-        "RelayAffirmationT": {
-          "type": "struct",
-          "type_mapping": [
-            [
-              "relayer",
-              "AccountId"
-            ],
-            [
-              "relay_header_parcels",
-              "EthereumRelayHeaderParcel"
-            ],
-            [
-              "bond",
-              "Balance"
-            ],
-            [
-              "maybe_extended_relay_affirmation_id",
-              "Option<RelayAffirmationId>"
-            ],
-            [
-              "verified",
-              "bool"
-            ]
-          ]
-        }
-      }
-    },
-    {
-      "runtime_range": [
-        5,
-        5
-      ],
-      "types": {
-        "ProxyType": {
-          "type": "enum",
-          "type_mapping": [
-            [
-              "Any",
-              "Null"
-            ],
-            [
-              "NonTransfer",
-              "Null"
-            ],
-            [
-              "Staking",
-              "Null"
-            ],
-            [
-              "IdentityJudgement",
-              "Null"
-            ],
-            [
-              "EthereumBridge",
-              "Null"
-            ],
-            [
-              "Governance",
-              "Null"
-            ]
-          ]
-        },
-        "RelayProofs": "EthereumRelayProof"
-      }
+    "EthereumReceiptProof": {
+      "type": "struct",
+      "type_mapping": [
+        [
+          "index",
+          "u64"
+        ],
+        [
+          "proof",
+          "Bytes"
+        ],
+        [
+          "header_hash",
+          "H256"
+        ]
+      ]
     },
-    {
-      "runtime_range": [
-        1,
-        3
-      ],
-      "types": {
-        "EthereumHeaderBrief": {
-          "type": "struct",
-          "type_mapping": [
-            [
-              "total_difficulty",
-              "U256"
-            ],
-            [
-              "parent_hash",
-              "H256"
-            ],
-            [
-              "number",
-              "EthereumBlockNumber"
-            ],
-            [
-              "relayer",
-              "AccountId"
-            ]
-          ]
-        },
-        "EthereumHeaderThingWithProof": {
-          "type": "struct",
-          "type_mapping": [
-            [
-              "header",
-              "EthereumHeader"
-            ],
-            [
-              "ethash_proof",
-              "Vec<EthashProof>"
-            ],
-            [
-              "mmr_root",
-              "H256"
-            ],
-            [
-              "mmr_proof",
-              "Vec<H256>"
-            ]
-          ]
-        },
-        "EthereumHeaderThing": {
-          "type": "struct",
-          "type_mapping": [
-            [
-              "header",
-              "EthereumHeader"
-            ],
-            [
-              "mmr_root",
-              "H256"
-            ]
-          ]
-        },
-        "Round": "u64",
-        "TcHeaderThingWithProof": "EthereumHeaderThingWithProof",
-        "TcHeaderThing": "EthereumHeaderThing",
-        "TcBlockNumber": "u64",
-        "TcHeaderHash": "H256",
-        "GameId": "TcBlockNumber",
-        "RelayProposalT": {
-          "type": "struct",
-          "type_mapping": [
-            [
-              "relayer",
-              "AccountId"
-            ],
-            [
-              "bonded_proposal",
-              "Vec<(Balance, TcHeaderThing)>"
-            ],
-            [
-              "extend_from_header_hash",
-              "Option<TcHeaderHash>"
-            ]
-          ]
-        }
-      }
+    "EthereumReceiptProofThing": "(EthereumHeader, EthereumReceiptProof, MMRProof)",
+    "MMRProof": {
+      "type": "struct",
+      "type_mapping": [
+        [
+          "member_leaf_index",
+          "u64"
+        ],
+        [
+          "last_leaf_index",
+          "u64"
+        ],
+        [
+          "proof",
+          "Vec<H256>"
+        ]
+      ]
     },
-    {
-      "runtime_range": [
-        4,
-        9
-      ],
-      "types": {
-        "EthereumRelayHeaderParcel": {
-          "type": "struct",
-          "type_mapping": [
-            [
-              "header",
-              "EthereumHeader"
-            ],
-            [
-              "mmr_root",
-              "H256"
-            ]
-          ]
-        },
-        "EthereumRelayProofs": {
-          "type": "struct",
-          "type_mapping": [
-            [
-              "ethash_proof",
-              "Vec<EthashProof>"
-            ],
-            [
-              "mmr_proof",
-              "Vec<H256>"
-            ]
-          ]
-        }
-      }
+    "BalancesRuntimeDispatchInfo": {
+      "type": "struct",
+      "type_mapping": [
+        [
+          "usable_balance",
+          "Balance"
+        ]
+      ]
     },
-    {
-      "runtime_range": [
-        4,
-        4
-      ],
-      "types": {
-        "RelayHeaderId": "Vec<u8>",
-        "RelayHeaderParcel": "Vec<u8>",
-        "RelayAffirmationId": {
-          "type": "struct",
-          "type_mapping": [
-            [
-              "relay_header_id",
-              "Vec<u8>"
-            ],
-            [
-              "round",
-              "u32"
-            ],
-            [
-              "index",
-              "u32"
-            ]
-          ]
-        },
-        "RelayAffirmationT": {
-          "type": "struct",
-          "type_mapping": [
-            [
-              "relayer",
-              "AccountId"
-            ],
-            [
-              "relay_header_parcels",
-              "Vec<u8>"
-            ],
-            [
-              "bond",
-              "Balance"
-            ],
-            [
-              "maybe_extended_relay_affirmation_id",
-              "Option<Vec<u8>>"
-            ],
-            [
-              "verified",
-              "bool"
-            ]
-          ]
-        },
-        "RelayProofs": "Vec<u8>"
-      }
+    "StakingRuntimeDispatchInfo": {
+      "type": "struct",
+      "type_mapping": [
+        [
+          "power",
+          "Power"
+        ]
+      ]
     }
-  ]
+  }
 }