scale.rb 0.2.19 → 0.3.0

data/lib/type_builder.rb

@@ -0,0 +1,279 @@
+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 
+
+            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_info: [["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
+
+          # [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.rb

@@ -0,0 +1,91 @@
+module Scale
+
+  class TypeRegistry
+    include Singleton
+
+    # init by load, and will not change
+    attr_reader :spec_name, :types
+    attr_reader :versioning, :custom_types # optional
+
+    # will change by different spec version
+    attr_accessor :spec_version # optional
+    attr_accessor :metadata
+
+    def load(spec_name: nil, custom_types: nil)
+      @spec_name = nil
+      @types = nil
+      @versioning = nil
+      @custom_types = nil
+
+      default_types, _, _ = load_chain_spec_types("default")
+
+      if spec_name
+        begin
+          @spec_name = spec_name
+          spec_types, @versioning, @spec_version = load_chain_spec_types(spec_name)
+          @types = default_types.merge(spec_types)
+        rescue => ex
+          # TODO: check different errors
+          puts "There is no types json file named #{spec_name}"
+          @types = default_types
+        end
+      else
+        @spec_name = "default"
+        @types = default_types
+      end
+
+      self.custom_types = custom_types
+      true
+    end
+
+    def get(type_name)
+      all_types = self.all_types
+      type_traverse(type_name, all_types)
+    end
+
+    def custom_types=(custom_types)
+      @custom_types = custom_types.stringify_keys if (not custom_types.nil?) && custom_types.class.name == "Hash"
+    end
+
+    def all_types
+      all_types = {}.merge(@types)
+
+      if @spec_version && @versioning
+        @versioning.each do |item|
+          if @spec_version >= item["runtime_range"][0] && 
+              ( item["runtime_range"][1].nil? || @spec_version <= item["runtime_range"][1] )
+            all_types.merge!(item["types"])
+          end
+        end
+      end
+
+      all_types.merge!(@custom_types) if @custom_types
+      all_types
+    end
+
+    private
+
+      def load_chain_spec_types(spec_name)
+        file = File.join File.expand_path("../..", __FILE__), "lib", "type_registry", "#{spec_name}.json"
+        json_string = File.open(file).read
+        json = JSON.parse(json_string)
+
+        runtime_id = json["runtime_id"]
+
+        [json["types"], json["versioning"], runtime_id]
+      end
+
+      def type_traverse(type, types)
+        if type.class == ::String 
+          real_type = types[type]
+
+          return type if real_type.nil? || real_type == type
+
+          type_traverse(real_type, types)
+        else
+          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"
+        ]
+      ]
     }
-  ]
+  }
 }