scale.rb 0.2.7 → 0.2.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0f61b15677d177f1c1ee76f1c77e8cc0ecabd1df98b50685eff13574bffeda29
-  data.tar.gz: 6e4eb45f8fbc1d67330c80948c7cee056e2f62fd4281610a69d40d9406d0b26d
+  metadata.gz: f37a51e33372d5c51aa45cf538fba59a4094becf5c50c40df6a5e2700f0c89a6
+  data.tar.gz: 5ff9199c46a0f0a51096b3a1acda708664d71ddb755b93e6c2096534ade5c6a4
 SHA512:
-  metadata.gz: 4dca6ff3b87b3071a82453bb8e66d0cb33f00615a0844baace80d84ad02e8e4f1ce7c53f1d90ce193ab5b8957fb41d975dce3d67128813a47f01894e2daf99d5
-  data.tar.gz: 8f783a33623ac5fb63d6384f4b58b17e97c90ee57815af8e7efd2556fc9a58bcc4955f171f9da6e1704431a3883cb4e967eadb010c4cb691806f72042e6b8004
+  metadata.gz: 2fe1f22eb8928b9986d6a8d2223f023f568c8afbb9e8dc3eea36f45705f540f9324e478b05cb916409303d75c9831622643adaade346134cd22665361989624c
+  data.tar.gz: 2cdbadcbf36cc61e04964b76581c41ccf76ca44aa72cf9241b18e73be115f2b183ef863ec32794fd71039fa264404bb56e5eb90d57c5fc243a8caf5f0df98d0f

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    scale.rb (0.2.7)
+    scale.rb (0.2.13)
       activesupport (>= 4.0.0)
       json (~> 2.3.0)
       substrate_common.rb (~> 0.1.9)
@@ -50,10 +50,10 @@ GEM
       xxhash
     thor (0.19.4)
     thread_safe (0.3.6)
-    tzinfo (1.2.7)
+    tzinfo (1.2.8)
       thread_safe (~> 0.1)
     xxhash (0.4.0)
-    zeitwerk (2.4.0)
+    zeitwerk (2.4.1)
 
 PLATFORMS
   ruby

data/README.md

@@ -10,7 +10,7 @@ This is a SCALE codec library implemented in ruby language for general use. It c
 
 This work is the prerequisite of our subsequent series of projects. We hope to familiarize and quickly access Polkadot and Substrate through ruby. We plan to develop the back end of our applications in ruby language, and then interact with nodes or synchronize data through this library.
 
-Please refer to the [official doc](https://substrate.dev/docs/en/overview/low-level-data-format) for more details about SCALE low-level data format.
+Please refer to the [official doc](https://substrate.dev/docs/en/knowledgebase/advanced/codec) for more details about SCALE low-level data format.
 
 Because the feature of ruby 2.6 is used, the ruby version is required to be >= 2.6. it will be compatible with older ruby versions when released.
 

data/lib/metadata/metadata.rb

@@ -6,7 +6,7 @@ module Scale
       def self.decode(scale_bytes)
         bytes = scale_bytes.get_next_bytes(4)
         if bytes.bytes_to_utf8 == "meta"
-          metadata_version = Scale::Types.type_of("Enum", %w[MetadataV0 MetadataV1 MetadataV2 MetadataV3 MetadataV4 MetadataV5 MetadataV6 MetadataV7 MetadataV8 MetadataV9 MetadataV10 MetadataV11]).decode(scale_bytes).value
+          metadata_version = Scale::Types.type_of("Enum", %w[MetadataV0 MetadataV1 MetadataV2 MetadataV3 MetadataV4 MetadataV5 MetadataV6 MetadataV7 MetadataV8 MetadataV9 MetadataV10 MetadataV11 MetadataV12]).decode(scale_bytes).value
           metadata = Metadata.new "Scale::Types::#{metadata_version}".constantize.decode(scale_bytes)
           metadata.version = metadata_version[9..].to_i
         else

data/lib/metadata/metadata_v12.rb

@@ -0,0 +1,85 @@
+module Scale
+  module Types
+    class MetadataV12
+      include SingleValue
+      attr_accessor :call_index, :event_index
+
+      def initialize(value)
+        @call_index = {}
+        @event_index = {}
+        super(value)
+      end
+
+      def self.decode(scale_bytes)
+        modules = Scale::Types.type_of("Vec<MetadataV12Module>").decode(scale_bytes).value
+
+        value = {
+          magicNumber: 1_635_018_093,
+          metadata: {
+            version: 12,
+            modules: modules.map(&:value)
+          }
+        }
+
+        result = MetadataV12.new(value)
+
+        call_module_index = 0
+        event_module_index = 0
+
+        modules.map(&:value).each_with_index do |m, module_index|
+          if m[:calls]
+            m[:calls].each_with_index do |call, index|
+              call[:lookup] = "%02x%02x" % [module_index, index]
+              result.call_index[call[:lookup]] = [m, call]
+            end
+          end
+
+          if m[:events]
+            m[:events].each_with_index do |event, index|
+              event[:lookup] = "%02x%02x" % [module_index, index]
+              result.event_index[event[:lookup]] = [m, event]
+            end
+          end
+        end
+
+        result
+      end
+    end
+
+    class MetadataV12Module
+      include SingleValue
+      def self.decode(scale_bytes)
+        name = String.decode(scale_bytes).value
+
+        result = {
+          name: name
+        }
+
+        has_storage = Bool.decode(scale_bytes).value
+        if has_storage
+          storage = MetadataV7ModuleStorage.decode(scale_bytes).value
+          result[:storage] = storage
+          result[:prefix] = storage[:prefix]
+        end
+
+        has_calls = Bool.decode(scale_bytes).value
+        if has_calls
+          calls = Scale::Types.type_of("Vec<MetadataModuleCall>").decode(scale_bytes).value
+          result[:calls] = calls.map(&:value)
+        end
+
+        has_events = Bool.decode(scale_bytes).value
+        if has_events
+          events = Scale::Types.type_of("Vec<MetadataModuleEvent>").decode(scale_bytes).value
+          result[:events] = events.map(&:value)
+        end
+
+        result[:constants] = Scale::Types.type_of("Vec<MetadataV7ModuleConstants>").decode(scale_bytes).value.map(&:value)
+        result[:errors] = Scale::Types.type_of("Vec<MetadataModuleError>").decode(scale_bytes).value.map(&:value)
+
+        result[:index] = U8.decode(scale_bytes).value
+        MetadataV12Module.new(result)
+      end
+    end
+  end
+end

data/lib/scale.rb

@@ -9,6 +9,7 @@ require "singleton"
 require "scale/base"
 require "scale/types"
 require "scale/block"
+require "scale/trie"
 
 require "metadata/metadata"
 require "metadata/metadata_v0"
@@ -23,6 +24,7 @@ require "metadata/metadata_v8"
 require "metadata/metadata_v9"
 require "metadata/metadata_v10"
 require "metadata/metadata_v11"
+require "metadata/metadata_v12"
 
 module Scale
   class Error < StandardError; end
@@ -91,14 +93,11 @@ module Scale
       end
 
       def type_traverse(type, types)
+        type = rename(type) if type.class == ::String
         if types.has_key?(type) && types[type] != type
           type_traverse(types[type], types)
         else
-          if type.class == ::String
-            rename(type)
-          else
-            type
-          end
+          type
         end
       end
   end

data/lib/scale/trie.rb

@@ -0,0 +1,121 @@
+module Scale
+  module Types
+    
+    class TrieNode
+      include SingleValue
+      EMPTY = 0
+      NIBBLE_PER_BYTE = 2
+      BITMAP_LENGTH = 2
+      NIBBLE_LENGTH = 16
+      NIBBLE_SIZE_BOUND = 65535
+
+      def self.decode(scale_bytes)
+        first = scale_bytes.get_next_bytes(1).first
+        if first == EMPTY
+          TrieNode.new({})
+        else
+          v = first & (0b11 << 6)
+          decode_size = -> {
+            result = first & 255 >> 2
+            return result if result < 63
+            result -= 1
+            while result <= NIBBLE_SIZE_BOUND
+              n = scale_bytes.get_next_bytes(1).first
+              return (result + n + 1) if n < 255 
+              result += 255
+            end
+            return NIBBLE_SIZE_BOUND
+          }
+
+          if v == 0b01 << 6 # leaf
+            nibble_count = decode_size.call
+            # if nibble_count is odd, the half of first byte of partial is 0
+            padding = (nibble_count % NIBBLE_PER_BYTE) != 0 
+            first_byte_of_partial = scale_bytes.bytes[scale_bytes.offset]
+            if padding && (first_byte_of_partial & 0xf0) != 0
+              raise "bad format"
+            end
+
+            ### partial decoding
+            partial_bytes = scale_bytes.get_next_bytes((nibble_count + (NIBBLE_PER_BYTE - 1)) / NIBBLE_PER_BYTE)
+
+            ### value
+            count = Compact.decode(scale_bytes).value
+            value_bytes = scale_bytes.get_next_bytes(count)
+
+            return TrieNode.new({
+              node_type: "leaf",
+              partial: {
+                hex: partial_bytes.bytes_to_hex, 
+                padding: padding
+              },
+              value: value_bytes.bytes_to_hex
+            })
+          elsif v == 0b10 << 6 || v == 0b11 << 6 # branch without mask || branch with mask
+            nibble_count = decode_size.call
+
+            ### check that the padding is valid (if any)
+            # if nibble_count is odd, the half of first byte of partial is 0
+            padding = nibble_count % NIBBLE_PER_BYTE != 0
+            first_byte_of_partial = scale_bytes.bytes[scale_bytes.offset]
+            if padding && (first_byte_of_partial & 0xf0) != 0 
+              raise "bad format"
+            end
+
+            ### partial decoding
+            partial_bytes = scale_bytes.get_next_bytes((nibble_count + (NIBBLE_PER_BYTE - 1)) / NIBBLE_PER_BYTE)
+
+            ### value decoding
+            if v == 0b11 << 6 # has value
+              count = Compact.decode(scale_bytes).value
+              value_bytes = scale_bytes.get_next_bytes(count)
+            end
+
+            ### children decoding
+            children = []
+            bitmap = U16.decode(scale_bytes).value
+            NIBBLE_LENGTH.times do |i|
+              has_child = (bitmap & (1 << i)) != 0
+              children[i] = nil
+              if has_child
+                count = Compact.decode(scale_bytes).value
+                if count == 32
+                  hash = H256.decode(scale_bytes).value
+                  children[i] = hash
+                else
+                  inline = scale_bytes.get_next_bytes count
+                  children[i] = inline.bytes_to_hex
+                end
+              end
+            end
+            # debug
+            # children.each_with_index do |child, i|
+            #   if child.nil?
+            #     puts "#{i}: NULL" 
+            #   else
+            #     puts "#{i}: #{child}"
+            #   end
+            # end
+
+            result = TrieNode.new({
+              node_type: "branch",
+              partial: {
+                hex: partial_bytes.bytes_to_hex, 
+                padding: padding
+              },
+              children: children
+            })
+
+            result[:value] = value_bytes.bytes_to_hex if value_bytes
+
+            return result
+          else
+            puts "Not support"
+          end
+
+        end
+      end
+    end
+
+  end
+end

data/lib/scale/types.rb

@@ -225,59 +225,71 @@ module Scale
       end
     end
 
-    class Address
+    class GenericAddress
       include SingleValue
-      attr_accessor :account_length, :account_index, :account_id, :account_idx
 
+      # https://github.com/paritytech/substrate/wiki/External-Address-Format-(SS58)
+      # base58encode ( concat ( <address-type>, <address>, <checksum> ) )
+      #                                         ^^^^^^^^^
+      # the <address> is 32 byte account id or 1, 2, 4, 8 byte account index
+      # scale_bytes: account length byte  + <address>'s bytes
       def self.decode(scale_bytes)
         account_length = scale_bytes.get_next_bytes(1).first
 
-        if account_length == 0xff # 255
+        if account_length == 0xff # 32 bytes address(Public key)
           account_id = scale_bytes.get_next_bytes(32).bytes_to_hex
-          account_length = account_length.to_s(16)
-          Address.new(account_id)
+          account_length = [account_length].bytes_to_hex
+
+          Address.new({
+            account_id: account_id,
+            account_length: account_length
+          })
         else
           account_index =
-            if account_length == 0xfc
+            if account_length == 0xfc # 2 bytes address(account index)
               scale_bytes.get_next_bytes(2).bytes_to_hex
-            elsif account_length == 0xfd
+            elsif account_length == 0xfd # 4 bytes address(account index)
               scale_bytes.get_next_bytes(4).bytes_to_hex
-            elsif account_length == 0xfe
+            elsif account_length == 0xfe # 8 bytes address(account index)
               scale_bytes.get_next_bytes(8).bytes_to_hex
             else
               [account_length].bytes_to_hex
             end
-          # account_idx = 
-          account_length = account_length.to_s(16)
-          Address.new(account_index)
+          # TODO: add account_idx 
+          account_length = [account_length].bytes_to_hex
+
+          Address.new({
+            account_index: account_index,
+            account_length: account_length
+          })
         end
       end
 
-      def encode(ss58=false, addr_type=42)
-        if value.start_with?("0x")
-          if ss58 === true
-            ::Address.encode(value, addr_type)
-          else
-            prefix = if value.length == 66
-              "ff"
-            elsif value.length == 6
-              "fc"
-            elsif value.length == 10
-              "fd"
-            elsif value.length == 18
-              "fe"
-            else
-              ""
-            end
-            "#{prefix}#{value[2..]}"
-          end
+      def encode
+        if self.value[:account_id]
+          "#{self.value[:account_length][2..]}#{self.value[:account_id][2..]}"
         else
-          raise "Format error"
+          "#{self.value[:account_length][2..]}#{self.value[:account_index][2..]}"
         end
       end
     end
 
-    class RawAddress < Address; end
+    class Address < GenericAddress; end
+
+    class RawAddress < GenericAddress; end
+
+    class AccountIdAddress < GenericAddress
+      def self.decode(scale_bytes)
+        AccountIdAddress.new({
+          account_id: AccountId.decode(scale_bytes).value,
+          account_length: "0xff"
+        })
+      end
+
+      def encode
+        "ff#{self.value[:account_id][2..]}"
+      end
+    end
 
     class AccountId < H256; end
 

data/lib/scale/version.rb

@@ -1,3 +1,3 @@
 module Scale
-  VERSION = "0.2.7".freeze
+  VERSION = "0.2.13".freeze
 end

data/lib/type_registry/crab-28.json

@@ -0,0 +1,662 @@
+{
+  "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"
+        ]
+      ]
+    },
+    "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"
+        ]
+      ]
+    },
+    "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>"
+        ],
+        [
+          "deposit_items",
+          "Vec<TimeDepositItem>"
+        ],
+        [
+          "ring_staking_lock",
+          "StakingLock"
+        ],
+        [
+          "kton_staking_lock",
+          "StakingLock"
+        ],
+        [
+          "claimed_rewards",
+          "Vec<EraIndex>"
+        ]
+      ]
+    },
+    "TimeDepositItem": {
+      "type": "struct",
+      "type_mapping": [
+        [
+          "value",
+          "Compact<Balance>"
+        ],
+        [
+          "start_time",
+          "Compact<TsInMs>"
+        ],
+        [
+          "expire_time",
+          "Compact<TsInMs>"
+        ]
+      ]
+    },
+    "ExposureT": {
+      "type": "struct",
+      "type_mapping": [
+        [
+          "own_ring_balance",
+          "Compact<Balance>"
+        ],
+        [
+          "own_kton_balance",
+          "Compact<Balance>"
+        ],
+        [
+          "own_power",
+          "Power"
+        ],
+        [
+          "total_power",
+          "Power"
+        ],
+        [
+          "others",
+          "Vec<IndividualExposure>"
+        ]
+      ]
+    },
+    "IndividualExposure": {
+      "type": "struct",
+      "type_mapping": [
+        [
+          "who",
+          "AccountId"
+        ],
+        [
+          "ring_balance",
+          "Compact<Balance>"
+        ],
+        [
+          "kton_balance",
+          "Compact<Balance>"
+        ],
+        [
+          "power",
+          "Power"
+        ]
+      ]
+    },
+    "ElectionResultT": {
+      "type": "struct",
+      "type_mapping": [
+        [
+          "elected_stashes",
+          "Vec<AccountId>"
+        ],
+        [
+          "exposures",
+          "Vec<(AccountId, ExposureT)>"
+        ],
+        [
+          "compute",
+          "ElectionCompute"
+        ]
+      ]
+    },
+    "RKT": {
+      "type": "struct",
+      "type_mapping": [
+        [
+          "r",
+          "Balance"
+        ],
+        [
+          "k",
+          "Balance"
+        ]
+      ]
+    },
+    "SpanRecord": {
+      "type": "struct",
+      "type_mapping": [
+        [
+          "slashed",
+          "RKT"
+        ],
+        [
+          "paid_out",
+          "RKT"
+        ]
+      ]
+    },
+    "UnappliedSlash": {
+      "type": "struct",
+      "type_mapping": [
+        [
+          "validator",
+          "AccountId"
+        ],
+        [
+          "own",
+          "RKT"
+        ],
+        [
+          "others",
+          "Vec<(AccountId, RKT)>"
+        ],
+        [
+          "reporters",
+          "Vec<AccountId>"
+        ],
+        [
+          "payout",
+          "RKT"
+        ]
+      ]
+    },
+    "TreasuryProposal": {
+      "type": "struct",
+      "type_mapping": [
+        [
+          "proposer",
+          "AccountId"
+        ],
+        [
+          "beneficiary",
+          "AccountId"
+        ],
+        [
+          "ring_value",
+          "Balance"
+        ],
+        [
+          "kton_value",
+          "Balance"
+        ],
+        [
+          "ring_bond",
+          "Balance"
+        ],
+        [
+          "kton_bond",
+          "Balance"
+        ]
+      ]
+    },
+    "MappedRing": "u128",
+    "EthereumTransactionIndex": "(H256, u64)",
+    "EthereumBlockNumber": "u64",
+    "EthereumHeader": {
+      "type": "struct",
+      "type_mapping": [
+        [
+          "parent_hash",
+          "H256"
+        ],
+        [
+          "timestamp",
+          "u64"
+        ],
+        [
+          "number",
+          "EthereumBlockNumber"
+        ],
+        [
+          "author",
+          "EthereumAddress"
+        ],
+        [
+          "transactions_root",
+          "H256"
+        ],
+        [
+          "uncles_hash",
+          "H256"
+        ],
+        [
+          "extra_data",
+          "Bytes"
+        ],
+        [
+          "state_root",
+          "H256"
+        ],
+        [
+          "receipts_root",
+          "H256"
+        ],
+        [
+          "log_bloom",
+          "Bloom"
+        ],
+        [
+          "gas_used",
+          "U256"
+        ],
+        [
+          "gas_limit",
+          "U256"
+        ],
+        [
+          "difficulty",
+          "U256"
+        ],
+        [
+          "seal",
+          "Vec<Bytes>"
+        ],
+        [
+          "hash",
+          "Option<H256>"
+        ]
+      ]
+    },
+    "EthereumAddress": "H160",
+    "Bloom": "[u8; 256]",
+    "H128": "[u8; 16]",
+    "EthashProof": {
+      "type": "struct",
+      "type_mapping": [
+        [
+          "dag_nodes",
+          "(H512, H512)"
+        ],
+        [
+          "proof",
+          "Vec<H128>"
+        ]
+      ]
+    },
+    "EthereumReceipt": {
+      "type": "struct",
+      "type_mapping": [
+        [
+          "gas_used",
+          "U256"
+        ],
+        [
+          "log_bloom",
+          "Bloom"
+        ],
+        [
+          "logs",
+          "Vec<LogEntry>"
+        ],
+        [
+          "outcome",
+          "TransactionOutcome"
+        ]
+      ]
+    },
+    "EthereumNetworkType": {
+      "type": "enum",
+      "type_mapping": [
+        [
+          "Mainnet",
+          "Null"
+        ],
+        [
+          "Ropsten",
+          "Null"
+        ]
+      ]
+    },
+    "RedeemFor": {
+      "type": "enum",
+      "type_mapping": [
+        [
+          "Token",
+          "Null"
+        ],
+        [
+          "Deposit",
+          "Null"
+        ]
+      ]
+    },
+    "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>"
+        ]
+      ]
+    },
+    "EthereumRelayHeaderParcel": {
+      "type": "struct",
+      "type_mapping": [
+        [
+          "header",
+          "EthereumHeader"
+        ],
+        [
+          "mmr_root",
+          "H256"
+        ]
+      ]
+    },
+    "EthereumRelayProofs": {
+      "type": "struct",
+      "type_mapping": [
+        [
+          "ethash_proof",
+          "Vec<EthashProof>"
+        ],
+        [
+          "mmr_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"
+        ]
+      ]
+    },
+    "RelayHeaderId": "EthereumBlockNumber",
+    "RelayHeaderParcel": "EthereumRelayHeaderParcel",
+    "RelayProofs": "EthereumRelayProofs",
+    "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"
+        ]
+      ]
+    },
+    "RelayVotingState": {
+      "type": "struct",
+      "type_mapping": [
+        [
+          "ayes",
+          "Vec<AccountId>"
+        ],
+        [
+          "nays",
+          "Vec<AccountId>"
+        ]
+      ]
+    },
+    "ProxyType": {
+      "type": "enum",
+      "type_mapping": [
+        [
+          "Any",
+          "Null"
+        ],
+        [
+          "NonTransfer",
+          "Null"
+        ],
+        [
+          "Governance",
+          "Null"
+        ],
+        [
+          "Staking",
+          "Null"
+        ],
+        [
+          "IdentityJudgement",
+          "Null"
+        ],
+        [
+          "EthereumBridge",
+          "Null"
+        ]
+      ]
+    },
+    "BalancesRuntimeDispatchInfo": {
+      "type": "struct",
+      "type_mapping": [
+        [
+          "usable_balance",
+          "Balance"
+        ]
+      ]
+    },
+    "StakingRuntimeDispatchInfo": {
+      "type": "struct",
+      "type_mapping": [
+        [
+          "power",
+          "Power"
+        ]
+      ]
+    }
+  }
+}