scale.rb 0.2.8 → 0.2.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a1efdbfb5ae89e2d4ff5abf3ca77717b3c95df5fbcd0e196066d813a03b80c7b
-  data.tar.gz: d8ce883df1522681efa389822fadd93da861685dbe5bc9e16206d2a97bd4a0de
+  metadata.gz: 992459c5f9a272f5d899027051cf702a4fd28b594bdfcb745e54e9106968c6b8
+  data.tar.gz: 9ae9fa80c0ee34e9988418e771d04c681ffc69585830e4c7d9ac3097f3d9d31d
 SHA512:
-  metadata.gz: ff7098aca9829ed818bcfe59a9a9cbeed492aead969619ab9acb62c47b6f6fce85d5519dc30a2e4d4816658528d0c9c1db2f4ff1c653b15646d2c1a4929d0435
-  data.tar.gz: 1034c3b87ffcbf8516cc23c4bcb5f524c096f78e6343901a10864ac4c94832f569c935807a70181fcb43b2ddbabc268b41902a649b5e45868377d5fe55b695a5
+  metadata.gz: eea2f91c1563cae8952a84f54be3dc26649356eb40aace9658e718396c9f8e89b2ed3709fd4ce2ca0222ed5978e8e8aabd5b3a301de1802250001f3ef12ce784
+  data.tar.gz: 5d0ac45c4c021363e48cb5e19efd2d2f794503b08daf8d48f22fb7d25e94117a2e97b0fdf185e9247c6d77513d0771989f9c1fcf9f03a6c5d2d710182ef140a8

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    scale.rb (0.2.8)
+    scale.rb (0.2.14)
       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_v12.rb

@@ -26,21 +26,19 @@ module Scale
         call_module_index = 0
         event_module_index = 0
 
-        modules.map(&:value).each do |m|
+        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" % [call_module_index, index]
+              call[:lookup] = "%02x%02x" % [module_index, index]
               result.call_index[call[:lookup]] = [m, call]
             end
-            call_module_index += 1
           end
 
           if m[:events]
             m[:events].each_with_index do |event, index|
-              event[:lookup] = "%02x%02x" % [event_module_index, index]
+              event[:lookup] = "%02x%02x" % [module_index, index]
               result.event_index[event[:lookup]] = [m, event]
             end
-            event_module_index += 1
           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"
@@ -92,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,171 @@
+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)
+        hash = "0x#{Crypto::blake2_256(scale_bytes.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({
+              hash: hash,
+              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
+                  h = H256.decode(scale_bytes).value
+                  children[i] = h
+                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({
+              hash: hash,
+              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
+
+      def self.check(root, proof, key)
+        key = Key.new(key)
+
+        nodes = proof.map {|node_data| 
+          node = TrieNode::decode(Scale::Bytes.new(node_data)).value
+          [node[:hash], node]
+        }.to_h
+
+        self.do_check(root, nodes, key)
+      end
+
+      private
+      def self.do_check(hash, nodes, key)
+        if node = nodes[hash]
+          if node[:children]
+            position = key.next_nibble(node[:partial][:hex], node[:partial][:padding]).to_i(16)
+            child = node[:children][position]
+            return self.do_check(child, nodes, key)
+          else
+            return node[:value]
+          end
+        else
+          raise "Fail"
+        end
+      end
+    end
+
+  end
+end
+
+class Key
+  def initialize(value)
+    @value = value[2..] if value.start_with?("0x")
+    @offset = 0
+  end
+
+  def next_nibble(partial, padding)
+    partial = partial[2..] if partial.start_with?("0x")
+    partial = partial[1..] if padding
+
+    new_offset = @offset + partial.length
+    if partial == @value[@offset...new_offset]
+      nibble = @value[new_offset]
+      @offset = new_offset + 1
+      return nibble
+    else
+      raise "Fail"
+    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.8".freeze
+  VERSION = "0.2.14".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"
+        ]
+      ]
+    }
+  }
+}