scale_rb 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3aacfcd3c4509dd0ba01d6cc0af5f16037f9bf17f5226a5cf615c916968e5a31
-  data.tar.gz: a8bc39ff0b80706cfd5614e906ea378ca7e08067aebe716095e3cf67710a54dc
+  metadata.gz: 97c7224f0e7d0a5f0d754206cee8d1d9cb5f1519c6c80e37b6c0b541aa0a4bcf
+  data.tar.gz: 51434a46e4f46a6c91bc0859575287076b0b1457e942ceff4ea66e74c0c89132
 SHA512:
-  metadata.gz: 2c84c953639ff54df078a86c343aa315cbcd743e5a3ddc9ed72663139628dc4a059e04f74016cb434568504d7967144476e778c717e7a4d63f4f7fe979d45628
-  data.tar.gz: 584fdaa093a917323b3a9b58331a242cf1fb9a9ea5965538b1521a56b5cf8758d10b9f1ed2b933973c137dba33d9cd0db14e8f0d468f4b7f0066f59f3a407834
+  metadata.gz: 6b0e80c6756b68f75d9f42e0d65f4c3205af0f63c3d57f51f5d3abf838057cb9dfc17d87b47f277aba5f95361bedf7618d4c31680a8c09ca57cde438c3be1020
+  data.tar.gz: 30351dad5922fffb55c37907225c19bbb1f771af842e231f18dd6ff1c43091876a70ed514536d3fbece2814528dc1b03d0c8a9a109cdb31e07bf1eed201ebf84

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    scale_rb (0.1.1)
+    scale_rb (0.1.2)
       blake2b_rs (~> 0.1.2)
       xxhash
 

data/exe/metadata

@@ -6,7 +6,7 @@ require 'json'
 require 'optparse'
 
 def print_metadata(url, at = nil)
-  puts JSON.pretty_generate(Client.get_metadata(url, at))
+  puts JSON.pretty_generate(Substrate::Client.get_metadata(url, at))
 end
 
 # ./bin/metadata http://g2.dev.darwinia.network:2234 -b 0x23ebddd6519aaf1b7fc916c3709af13d7a4010943fb53038406581171000a58e
@@ -31,10 +31,10 @@ else
       block_hash = @options[:block]
     else
       block_number = @options[:block].to_i
-      block_hash = RPC.chain_getBlockHash url, block_number
+      block_hash = Substrate::RPC.chain_getBlockHash url, block_number
     end
   else
-    block_hash = RPC.chain_getBlockHash url
+    block_hash = Substrate::RPC.chain_getBlockHash url
   end
 
   print_metadata url, block_hash

data/lib/codec.rb

@@ -1,81 +1,176 @@
 # frozen_string_literal: true
 
+module ScaleRb
+  class Error < StandardError; end
+  class NotImplemented < Error; end
+  class NilTypeError < Error; end
+  class TypeParseError < Error; end
+  class NotEnoughBytesError < Error; end
+  class InvalidBytesError < Error; end
+  class Unreachable < Error; end
+  class IndexOutOfRangeError < Error; end
+  class LengthNotEqualErr < Error; end
+  class InvalidValueError < Error; end
+end
+
 # TODO: set, bitvec
+module ScaleRb
+  class << self
+    def bytes?(type)
+      type.downcase == 'bytes'
+    end
 
-def bytes?(type)
-  type.downcase == 'bytes'
-end
+    def boolean?(type)
+      type.downcase == 'bool' || type.downcase == 'boolean'
+    end
 
-def boolean?(type)
-  type.downcase == 'bool' || type.downcase == 'boolean'
-end
+    def string?(type)
+      type.downcase == 'str' || type.downcase == 'string' || type.downcase == 'text'
+    end
 
-def string?(type)
-  type.downcase == 'str' || type.downcase == 'string' || type.downcase == 'text'
-end
+    def compact?(type)
+      type.downcase == 'compact' ||
+        (type[0..7].downcase == 'compact<' && type[-1] == '>')
+    end
 
-def compact?(type)
-  type.downcase == 'compact' ||
-    (type[0..7].downcase == 'compact<' && type[-1] == '>')
-end
+    def int?(type)
+      type[0].downcase == 'i' && type[1..] =~ /\A(8|16|32|64|128|256|512)\z/
+    end
 
-def int?(type)
-  type[0].downcase == 'i' && type[1..] =~ /\A(8|16|32|64|128|256|512)\z/
-end
+    def uint?(type)
+      type[0].downcase == 'u' && type[1..] =~ /\A(8|16|32|64|128|256|512)\z/
+    end
 
-def uint?(type)
-  type[0].downcase == 'u' && type[1..] =~ /\A(8|16|32|64|128|256|512)\z/
-end
+    def option?(type)
+      type[0..6].downcase == 'option<' && type[-1] == '>'
+    end
 
-# def bitvec?(type)
-# end
+    def array?(type)
+      type[0] == '[' && type[-1] == ']'
+    end
 
-def option?(type)
-  type[0..6].downcase == 'option<' && type[-1] == '>'
-end
+    def vec?(type)
+      type[0..3].downcase == 'vec<' && type[-1] == '>'
+    end
 
-def array?(type)
-  type[0] == '[' && type[-1] == ']'
-end
+    def tuple?(type)
+      type[0] == '(' && type[-1] == ')'
+    end
 
-def vec?(type)
-  type[0..3].downcase == 'vec<' && type[-1] == '>'
-end
+    def struct?(type)
+      type.instance_of?(Hash)
+    end
 
-def tuple?(type)
-  type[0] == '(' && type[-1] == ')'
+    def enum?(type)
+      type.instance_of?(Hash) && type.key?(:_enum)
+    end
+  end
 end
 
-def struct?(type)
-  type.instance_of?(Hash)
-end
+module ScaleRb
+  class << self
+    def parse_option(type)
+      type.scan(/\A[O|o]ption<(.+)>\z/).first.first
+    end
 
-def enum?(type)
-  type.instance_of?(Hash) && type.key?(:_enum)
-end
+    def parse_array(type)
+      scan_out = type.scan(/\A\[\s*(.+)\s*;\s*(\d+)\s*\]\z/)
+      raise ScaleRb::TypeParseError, type if scan_out.empty?
+      raise ScaleRb::TypeParseError, type if scan_out[0].length != 2
 
-def parse_fixed_array(type)
-  scan_out = type.scan(/\A\[\s*(.+)\s*;\s*(\d+)\s*\]\z/)
-  raise ScaleRb::TypeParseError, type if scan_out.empty?
-  raise ScaleRb::TypeParseError, type if scan_out[0].length != 2
+      inner_type = scan_out[0][0]
+      length = scan_out[0][1].to_i
+      [inner_type, length]
+    end
+
+    def parse_vec(type)
+      type.scan(/\A[V|v]ec<(.+)>\z/).first.first
+    end
 
-  inner_type = scan_out[0][0]
-  length = scan_out[0][1].to_i
-  [inner_type, length]
+    def parse_tuple(type)
+      type.scan(/\A\(\s*(.+)\s*\)\z/)[0][0].split(',').map(&:strip)
+    end
+  end
 end
 
+# Helper functions
 module ScaleRb
-  class Error < StandardError; end
-  class NotImplemented < Error; end
-  class NilTypeError < Error; end
-  class TypeParseError < Error; end
-  class NotEnoughBytesError < Error; end
-  class InvalidBytesError < Error; end
-  class Unreachable < Error; end
-  class IndexOutOfRangeError < Error; end
-  class LengthNotEqualErr < Error; end
-  class InvalidValueError < Error; end
+  class << self
+    def _get_final_type_from_registry(registry, type)
+      mapped_type = registry[type]
+      if mapped_type.nil?
+        nil
+      elsif registry[mapped_type].nil?
+        mapped_type
+      else
+        _get_final_type_from_registry(registry, mapped_type)
+      end
+    end
+
+    def _decode_types(types, bytes, registry)
+      _decode_each(types, bytes) do |type, remaining_bytes|
+        decode(type, remaining_bytes, registry)
+      end
+    end
+
+    def _decode_each(types, bytes, &decode)
+      remaining_bytes = bytes
+      values = types.map do |type|
+        value, remaining_bytes = decode.call(type, remaining_bytes)
+        value
+      end
+      [values, remaining_bytes]
+    end
+
+    def _do_decode_compact(bytes)
+      case bytes[0] & 3
+      when 0
+        [bytes[0] >> 2, bytes[1..]]
+      when 1
+        [bytes[0..1].flip.to_uint >> 2, bytes[2..]]
+      when 2
+        [bytes[0..3].flip.to_uint >> 2, bytes[4..]]
+      when 3
+        length = 4 + (bytes[0] >> 2)
+        [bytes[1..length].flip.to_uint, bytes[length + 1..]]
+      else
+        raise Unreachable, 'type: Compact'
+      end
+    end
+
+    def _encode_each(types, values, &encode)
+      _encode_each_without_merge(types, values, &encode).flatten
+    end
+
+    def _encode_each_without_merge(types, values, &encode)
+      raise LengthNotEqualErr, "types: #{types}, values: #{values.inspect}" if types.length != values.length
+
+      types.map.with_index do |type, i|
+        encode.call(type, values[i])
+      end
+    end
+
+    def _encode_types(types, values, registry = {})
+      _encode_each(types, values) do |type, value|
+        encode(type, value, registry)
+      end
+    end
+
+    def _encode_each_with_hashers(types, values, hashers, &encode)
+      if !hashers.nil? && hashers.length != types.length
+        raise ScaleRb::LengthNotEqualErr, "types length: #{types.length}, hashers length: #{hashers.length}"
+      end
 
+      bytes_array = ScaleRb._encode_each_without_merge(types, values, &encode)
+      bytes_array.each_with_index.reduce([]) do |memo, (bytes, i)|
+        memo + Hasher.apply_hasher(hashers[i], bytes)
+      end
+    end
+  end
+end
+
+module ScaleRb
+  # Decode
   class << self
     def decode(type, bytes, registry = {})
       logger.debug '--------------------------------------------------'
@@ -95,7 +190,7 @@ module ScaleRb
         return decode_tuple(type, bytes, registry) if tuple?(type) # (u8, u8)
 
         # search the type from registry if not the types above
-        registry_type = get_final_type_from_registry(registry, type)
+        registry_type = _get_final_type_from_registry(registry, type)
         return decode(registry_type, bytes, registry) if registry_type
       elsif type.instance_of?(Hash)
         return decode_enum(type, bytes, registry) if enum?(type)
@@ -106,7 +201,7 @@ module ScaleRb
     end
 
     def decode_bytes(bytes)
-      length, remaining_bytes = do_decode_compact(bytes)
+      length, remaining_bytes = _do_decode_compact(bytes)
       value = remaining_bytes[0...length].to_hex
       debug 'length', length
       debug 'value', value
@@ -130,7 +225,7 @@ module ScaleRb
     end
 
     def decode_string(bytes)
-      length, remaining_bytes = do_decode_compact(bytes)
+      length, remaining_bytes = _do_decode_compact(bytes)
       raise NotEnoughBytesError, 'type: String' if remaining_bytes.length < length
 
       value = remaining_bytes[0...length].to_utf8
@@ -155,10 +250,10 @@ module ScaleRb
       ]
     end
 
-    def decode_uint(type, bytes)
-      bit_length = type[1..].to_i
+    def decode_uint(type_def, bytes)
+      bit_length = type_def[1..].to_i
       byte_length = bit_length / 8
-      raise NotEnoughBytesError, "type: #{type}" if bytes.length < byte_length
+      raise NotEnoughBytesError, "type: #{type_def}" if bytes.length < byte_length
 
       value = bytes[0...byte_length].flip.to_uint
       debug 'value', value
@@ -169,60 +264,63 @@ module ScaleRb
     end
 
     def decode_compact(bytes)
-      result = do_decode_compact(bytes)
+      result = _do_decode_compact(bytes)
       debug 'value', result[0]
       result
     end
 
-    def decode_option(type, bytes, registry = {})
-      inner_type = type.scan(/\A[O|o]ption<(.+)>\z/).first.first
+    def decode_option(type_def, bytes, registry = {})
+      inner_type = parse_option(type_def)
 
       return [nil, bytes[1..]] if bytes[0] == 0x00
       return decode(inner_type, bytes[1..], registry) if bytes[0] == 0x01
 
-      raise InvalidBytesError, "type: #{type}"
+      raise InvalidBytesError, "type: #{type_def}"
     end
 
-    def decode_array(type, bytes, registry = {})
-      inner_type, length = parse_fixed_array(type)
+    def decode_array(type_def, bytes, registry = {})
+      inner_type, length = parse_array(type_def)
       _decode_types([inner_type] * length, bytes, registry)
     end
 
-    def decode_vec(type, bytes, registry = {})
-      inner_type = type.scan(/\A[V|v]ec<(.+)>\z/).first.first
-      length, remaining_bytes = do_decode_compact(bytes)
+    def decode_vec(type_def, bytes, registry = {})
+      inner_type = parse_vec(type_def)
+      length, remaining_bytes = _do_decode_compact(bytes)
       debug 'length', length
       _decode_types([inner_type] * length, remaining_bytes, registry)
     end
 
-    def decode_tuple(tuple_type, bytes, registry = {})
-      inner_types = tuple_type.scan(/\A\(\s*(.+)\s*\)\z/)[0][0].split(',').map(&:strip)
+    def decode_tuple(type_def, bytes, registry = {})
+      inner_types = parse_tuple(type_def)
       _decode_types(inner_types, bytes, registry)
     end
 
-    # TODO: custrom index
-    def decode_enum(enum_type, bytes, registry = {})
+    # TODO: custom index?
+    # {
+    #   _enum: {
+    #     name1: type1,
+    #     name2: type2
+    #   }
+    # }
+    # or
+    # {
+    #   _enum: ['name1', 'name2']
+    # }
+    def decode_enum(type_def, bytes, registry = {})
       index = bytes[0]
-      raise IndexOutOfRangeError, "type: #{enum_type}" if index > enum_type[:_enum].length - 1
-
-      remaining_bytes = bytes[1..]
-      if enum_type[:_enum].instance_of?(Hash)
-        key = enum_type[:_enum].keys[index]
-        type = enum_type[:_enum].values[index]
-
-        value, remaining_bytes = decode(type, remaining_bytes, registry)
-        [
-          { key => value },
-          remaining_bytes
-        ]
-      elsif enum_type[:_enum].instance_of?(Array)
-        value = enum_type[:_enum][index]
-        debug 'value', value.inspect
-        [
-          value,
-          remaining_bytes
-        ]
-      end
+
+      items = type_def[:_enum]
+      raise IndexOutOfRangeError, "type: #{type_def}" if index > items.length - 1
+
+      item = items.to_a[index] # 'name' or [:name, inner_type]
+      debug 'value', item.inspect
+      return [item, remaining_bytes] if item.instance_of?(String)
+
+      value, remaining_bytes = decode(item[1], bytes[1..], registry)
+      [
+        { item[0].to_sym => value },
+        remaining_bytes
+      ]
     end
 
     def decode_struct(struct, bytes, registry = {})
@@ -234,56 +332,13 @@ module ScaleRb
     end
   end
 
-  def self.get_final_type_from_registry(registry, type)
-    mapped_type = registry[type]
-    if mapped_type.nil?
-      nil
-    elsif registry[mapped_type].nil?
-      mapped_type
-    else
-      get_final_type_from_registry(registry, mapped_type)
-    end
-  end
-
-  def self._decode_types(type_list, bytes, registry = {})
-    if type_list.empty?
-      [[], bytes]
-    else
-      value, remaining_bytes = decode(type_list.first, bytes, registry)
-      value_list, remaining_bytes = _decode_types(type_list[1..], remaining_bytes, registry)
-      [[value] + value_list, remaining_bytes]
-    end
-  end
-
-  def self.do_decode_compact(bytes)
-    case bytes[0] & 3
-    when 0
-      [bytes[0] >> 2, bytes[1..]]
-    when 1
-      [bytes[0..1].flip.to_uint >> 2, bytes[2..]]
-    when 2
-      [bytes[0..3].flip.to_uint >> 2, bytes[4..]]
-    when 3
-      length = 4 + (bytes[0] >> 2)
-      [bytes[1..length].flip.to_uint, bytes[length + 1..]]
-    else
-      raise Unreachable, 'type: Compact'
-    end
-  end
-
+  # Encode
   class << self
     def encode(type, value, registry = {})
-      logger.debug '>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>'
-      logger.debug "           type: #{type}"
-      logger.debug "          value: #{value}"
-
-      bytes = do_encode(type, value, registry)
-
-      logger.debug "        encoded: #{bytes}"
-      bytes
-    end
+      logger.debug '--------------------------------------------------'
+      debug 'encoding type', type
+      debug 'value', value
 
-    def do_encode(type, value, registry = {})
       if type.instance_of?(String)
         return encode_bytes(value) if bytes?(type)
         return encode_boolean(value) if boolean?(type)
@@ -295,8 +350,8 @@ module ScaleRb
         return encode_vec(type, value, registry) if vec?(type)
         return encode_tuple(type, value, registry) if tuple?(type)
 
-        registry_type = get_final_type_from_registry(registry, type)
-        return do_encode(registry_type, value, registry) if registry_type
+        registry_type = _get_final_type_from_registry(registry, type)
+        return encode(registry_type, value, registry) if registry_type
       elsif type.instance_of?(Hash)
         return encode_enum(type, value, registry) if enum?(type)
         return encode_struct(type, value, registry) if struct?(type)
@@ -340,11 +395,11 @@ module ScaleRb
       return [0x00] if value.nil?
 
       inner_type = type.scan(/\A[O|o]ption<(.+)>\z/).first.first
-      [0x01] + do_encode(inner_type, value, registry)
+      [0x01] + encode(inner_type, value, registry)
     end
 
     def encode_array(type, array, registry = {})
-      inner_type, length = parse_fixed_array(type)
+      inner_type, length = parse_array(type)
       raise LengthNotEqualErr, "type: #{type}, value: #{array.inspect}" if length != array.length
 
       _encode_types([inner_type] * length, array, registry)
@@ -366,22 +421,11 @@ module ScaleRb
       value = enum.values.first
       value_type = enum_type[:_enum][key]
       index = enum_type[:_enum].keys.index(key)
-      encode_uint('u8', index) + do_encode(value_type, value, registry)
+      encode_uint('u8', index) + encode(value_type, value, registry)
     end
 
     def encode_struct(struct_type, struct, registry = {})
       _encode_types(struct_type.values, struct.values, registry)
     end
-
-    def _encode_types(type_list, value_list, registry = {})
-      raise LengthNotEqualErr, "type: #{type_list}, value: #{value_list.inspect}" if type_list.length != value_list.length
-
-      if type_list.empty?
-        []
-      else
-        bytes = do_encode(type_list.first, value_list.first, registry)
-        bytes + _encode_types(type_list[1..], value_list[1..], registry)
-      end
-    end
   end
 end

data/lib/portable_codec.rb

@@ -47,9 +47,9 @@ module PortableCodec
     # Int, Bytes ?
     def decode_primitive(type_def, bytes)
       primitive = type_def._get(:primitive)
-      return ScaleRb.decode_uint(primitive, bytes) if uint?(primitive)
-      return ScaleRb.decode_string(bytes) if string?(primitive)
-      return ScaleRb.decode_boolean(bytes) if boolean?(primitive)
+      return ScaleRb.decode_uint(primitive, bytes) if ScaleRb.uint?(primitive)
+      return ScaleRb.decode_string(bytes) if ScaleRb.string?(primitive)
+      return ScaleRb.decode_boolean(bytes) if ScaleRb.boolean?(primitive)
       # return ScaleRb.decode_int(primitive, bytes) if int?(primitive)
       # return ScaleRb.decode_bytes(bytes) if bytes?(primitive)
     end
@@ -115,12 +115,8 @@ module PortableCodec
     end
 
     def _decode_types(ids, bytes, registry = {})
-      if ids.empty?
-        [[], bytes]
-      else
-        value, remaining_bytes = decode(ids.first, bytes, registry)
-        value_list, remaining_bytes = _decode_types(ids[1..], remaining_bytes, registry)
-        [[value] + value_list, remaining_bytes]
+      ScaleRb._decode_each(ids, bytes) do |id, remaining_bytes|
+        decode(id, remaining_bytes, registry)
       end
     end
 
@@ -148,9 +144,9 @@ module PortableCodec
 
     def encode_primitive(type_def, value)
       primitive = type_def._get(:primitive)
-      return ScaleRb.encode_uint(primitive, value) if uint?(primitive)
-      return ScaleRb.encode_string(value) if string?(primitive)
-      return ScaleRb.encode_boolean(value) if boolean?(primitive)
+      return ScaleRb.encode_uint(primitive, value) if ScaleRb.uint?(primitive)
+      return ScaleRb.encode_string(value) if ScaleRb.string?(primitive)
+      return ScaleRb.encode_boolean(value) if ScaleRb.boolean?(primitive)
     end
 
     def encode_compact(value)
@@ -225,26 +221,14 @@ module PortableCodec
     end
 
     def _encode_types(ids, values, registry)
-      _encode_types_without_merge(ids, values, registry).flatten
-    end
-
-    def _encode_types_with_hashers(values, type_ids, registry, hashers)
-      if !hashers.nil? && hashers.length != type_ids.length
-        raise ScaleRb::LengthNotEqualErr, "type_ids length: #{type_ids.length}, hashers length: #{hashers.length}"
-      end
-
-      bytes_array = _encode_types_without_merge(type_ids, values, registry)
-      bytes_array.each_with_index.reduce([]) do |memo, (bytes, i)|
-        memo + Hasher.apply_hasher(hashers[i], bytes)
+      ScaleRb._encode_each(ids, values) do |id, value|
+        encode(id, value, registry)
       end
     end
 
-    # return: [value1_bytes, value2_bytes, ...]
-    def _encode_types_without_merge(ids, values, registry)
-      raise ScaleRb::LengthNotEqualErr, "types: #{ids}, values: #{values.inspect}" if ids.length != values.length
-
-      ids.map.with_index do |type_id, i|
-        encode(type_id, values[i], registry)
+    def _encode_types_with_hashers(ids, values, registry, hashers)
+      ScaleRb._encode_each_with_hashers(ids, values, hashers) do |id, value|
+        encode(id, value, registry)
       end
     end
   end

data/lib/scale_rb/version.rb

@@ -1,3 +1,3 @@
 module ScaleRb
-  VERSION = '0.1.1'
+  VERSION = '0.1.2'
 end

data/lib/scale_rb.rb

@@ -16,8 +16,8 @@ require 'hasher'
 require 'storage_helper'
 
 # client
-require 'client/rpc'
-require 'client/client'
+require 'substrate/rpc'
+require 'substrate/client'
 
 # get registry from config
 require 'registry'

data/lib/storage_helper.rb

@@ -21,7 +21,7 @@ module StorageHelper
         type_ids = params[:type_ids]
         hashers = params[:hashers]
 
-        pallet_method_key + PortableCodec._encode_types_with_hashers(values, type_ids, registry, hashers)
+        pallet_method_key + PortableCodec._encode_types_with_hashers(type_ids, values, registry, hashers)
       end
     end
 

data/lib/substrate/client.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+module Substrate
+  module Client
+    class << self
+      def get_metadata(url, at = nil)
+        hex = Substrate::RPC.state_getMetadata(url, at)
+        Metadata.decode_metadata(hex.strip.to_bytes)
+      end
+
+      def query_storage_at(url, storage_keys, type_id, default, registry, at = nil)
+        result = Substrate::RPC.state_queryStorageAt(url, storage_keys, at)
+        result.map do |item|
+          item['changes'].map do |change|
+            storage_key = change[0]
+            data = change[1] || default
+            storage = data.nil? ? nil : PortableCodec.decode(type_id, data.to_bytes, registry)[0]
+            { storage_key: storage_key, storage: storage }
+          end
+        end.flatten
+      end
+
+      def get_storage_keys_by_partial_key(url, partial_storage_key, start_key = nil, at = nil)
+        storage_keys = Substrate::RPC.state_getKeysPaged(url, partial_storage_key, 1000, start_key, at)
+        if storage_keys.length == 1000
+          storage_keys + get_storage_keys_by_partial_key(url, partial_storage_key, storage_keys.last, at)
+        else
+          storage_keys
+        end
+      end
+
+      def get_storages_by_partial_key(url, partial_storage_key, type_id_of_value, default, registry, at = nil)
+        storage_keys = get_storage_keys_by_partial_key(url, partial_storage_key, partial_storage_key, at)
+        storage_keys.each_slice(250).map do |slice|
+          query_storage_at(
+            url,
+            slice,
+            type_id_of_value,
+            default,
+            registry,
+            at
+          )
+        end.flatten
+      end
+
+      # type_id: result type id
+      def get_storage(url, storage_key, type_id, default, registry, at = nil)
+        data = Substrate::RPC.state_getStorage(url, storage_key, at) || default
+        return nil if data.nil?
+
+        PortableCodec.decode(type_id, data.to_bytes, registry)[0]
+      end
+
+      # 1. Plain
+      #   key:   nil
+      #   value: { type: 3, modifier: 'Default', callback: '' }
+      #
+      # 2. Map
+      #   key:   { value: value, type: 0, hashers: ['Blake2128Concat'] }
+      #   value: { type: 3, modifier: 'Default', callback: '' }
+      #
+      # 3. Map, but key.value is nil
+      #   key:   { value: nil, type: 0, hashers: ['Blake2128Concat'] }
+      #   value: { type: 3, modifier: 'Default', callback: '' }
+      #
+      # example:
+      #   'System',
+      #   'Account',
+      #   key = {
+      #     value: [['0x724d50824542b56f422588421643c4a162b90b5416ef063f2266a1eae6651641'.to_bytes]], # [AccountId]
+      #     type: 0,
+      #     hashers: ['Blake2128Concat']
+      #   },
+      #   value = {
+      #     type: 3,
+      #     modifier: 'Default',
+      #     callback: '0x0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000'
+      #   },
+      #   ..
+      #
+      def get_storage2(url, pallet_name, item_name, key, value, registry, at = nil)
+        # map, but no key's value provided. get all storages under the partial storage key
+        if !key.nil? && key[:value].nil?
+          partial_storage_key = StorageHelper.encode_storage_key(pallet_name, item_name).to_hex
+          get_storages_by_partial_key(
+            url,
+            partial_storage_key,
+            value[:type],
+            value[:modifier] == 'Default' ? value[:fallback] : nil,
+            registry,
+            at
+          )
+        else
+          params = (StorageHelper.build_params(key[:value], key[:type], key[:hashers], registry) unless key.nil?)
+          storage_key = StorageHelper.encode_storage_key(pallet_name, item_name, params, registry).to_hex
+          get_storage(
+            url,
+            storage_key,
+            value[:type],
+            value[:modifier] == 'Default' ? value[:fallback] : nil,
+            registry,
+            at
+          )
+        end
+      end
+
+      def get_storage3(url, pallet_name, item_name, value_of_key, metadata, at = nil)
+        raise 'metadata should not be nil' if metadata.nil?
+
+        registry = Metadata.build_registry(metadata)
+        item = Metadata.get_storage_item(pallet_name, item_name, metadata)
+
+        modifier = item._get(:modifier) # Default | Optional
+        fallback = item._get(:fallback)
+        type = item._get(:type)
+
+        plain = type._get(:plain)
+        map = type._get(:map)
+        key, value =
+          if plain
+            [
+              nil,
+              { type: plain, modifier: modifier, fallback: fallback }
+            ]
+          elsif map
+            [
+              { value: value_of_key, type: map._get(:key), hashers: map._get(:hashers) },
+              { type: map._get(:value), modifier: modifier, fallback: fallback }
+            ]
+          else
+            raise 'NoSuchStorageType'
+          end
+        get_storage2(url, pallet_name, item_name, key, value, registry, at)
+      end
+    end
+  end
+end

data/lib/substrate/rpc.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require 'uri'
+require 'net/http'
+require 'json'
+
+module Substrate
+  module RPC
+    class << self
+      def json_rpc_call(method, params, url)
+        uri = URI(url)
+        req = Net::HTTP::Post.new(uri, 'Content-Type' => 'application/json')
+        req.body = {
+          'id' => 1,
+          'jsonrpc' => '2.0',
+          'method' => method,
+          'params' => params.reject(&:nil?)
+        }.to_json
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = true if uri.instance_of? URI::HTTPS
+        res = http.request(req)
+        # puts res unless res.is_a?(Net::HTTPSuccess)
+
+        result = JSON.parse(res.body)
+        raise result['error'] if result['error']
+
+        result['result']
+      end
+
+      def chain_getBlockHash(url, block_number = nil)
+        json_rpc_call('chain_getBlockHash', [block_number], url)
+      end
+
+      def chain_getBlock(url, at = nil)
+        json_rpc_call('chain_getBlock', [at], url)
+      end
+
+      def state_getRuntimeVersion(url, at = nil)
+        json_rpc_call('state_getRuntimeVersion', [at], url)
+      end
+
+      def state_getMetadata(url, at = nil)
+        json_rpc_call('state_getMetadata', [at], url)
+      end
+
+      def state_getStorage(url, key, at = nil)
+        json_rpc_call('state_getStorage', [key, at], url)
+      end
+
+      def state_queryStorageAt(url, keys, at = nil)
+        json_rpc_call('state_queryStorageAt', [keys, at], url)
+      end
+
+      def state_getKeysPaged(url, key, count, start_key = nil, at = nil)
+        json_rpc_call('state_getKeysPaged', [key, count, start_key, at], url)
+      end
+
+      def eth_call(url, to, data, at_block_number = nil)
+        json_rpc_call('eth_call', [
+                        {
+                          'from' => nil,
+                          'to' => to,
+                          'data' => data
+                        },
+                        at_block_number
+                      ], url)
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: scale_rb
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Aki Wu
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-10-04 00:00:00.000000000 Z
+date: 2022-10-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: blake2b_rs
@@ -59,8 +59,6 @@ files:
 - bin/console
 - bin/setup
 - exe/metadata
-- lib/client/client.rb
-- lib/client/rpc.rb
 - lib/codec.rb
 - lib/hasher.rb
 - lib/metadata.rb
@@ -71,6 +69,8 @@ files:
 - lib/scale_rb.rb
 - lib/scale_rb/version.rb
 - lib/storage_helper.rb
+- lib/substrate/client.rb
+- lib/substrate/rpc.rb
 - scale_rb.gemspec
 homepage: https://github.com/wuminzhe/scale_rb
 licenses:

data/lib/client/client.rb

@@ -1,78 +0,0 @@
-# frozen_string_literal: true
-
-module Client
-  class << self
-    def get_metadata(url, at = nil)
-      hex = RPC.state_getMetadata(url, at)
-      Metadata.decode_metadata(hex.strip.to_bytes)
-    end
-
-    # type_id: result type id
-    def get_storage(url, storage_key, type_id, default, registry, at = nil)
-      data = RPC.state_getStorage(url, storage_key, at) || default
-      return nil if data.nil?
-
-      PortableCodec.decode(type_id, data.to_bytes, registry)[0]
-    end
-
-    # key:   { value: .., type: 0, hashers: ['Blake2128Concat'] } | nil
-    # value: { type: 3, modifier: 'Default', callback: '' }
-    #
-    # example:
-    #   'System',
-    #   'Account',
-    #   key = {
-    #     value: [['0x724d50824542b56f422588421643c4a162b90b5416ef063f2266a1eae6651641'.to_bytes]], # [AccountId]
-    #     type: 0,
-    #     hashers: ['Blake2128Concat']
-    #   },
-    #   value = {
-    #     type: 3,
-    #     modifier: 'Default',
-    #     callback: '0x0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000'
-    #   },
-    #   ..
-    def get_storage2(url, pallet_name, item_name, key, value, registry, at = nil)
-      params = (StorageHelper.build_params(key[:value], key[:type], key[:hashers], registry) if key)
-
-      storage_key = StorageHelper.encode_storage_key(pallet_name, item_name, params, registry).to_hex
-      get_storage(
-        url,
-        storage_key,
-        value[:type],
-        value[:modifier] == 'Default' ? value[:fallback] : nil,
-        registry,
-        at
-      )
-    end
-
-    def get_storage3(url, pallet_name, item_name, key_value, metadata, at = nil)
-      raise 'metadata should not be nil' if metadata.nil?
-
-      registry = Metadata.build_registry(metadata)
-      item = Metadata.get_storage_item(pallet_name, item_name, metadata)
-
-      modifier = item._get(:modifier) # Default | Optional
-      fallback = item._get(:fallback)
-      type = item._get(:type)
-
-      plain = type._get(:plain)
-      map = type._get(:map)
-      key, value =
-        if plain
-          [
-            nil,
-            { type: plain, modifier: modifier, fallback: fallback }
-          ]
-        elsif map
-          [
-            { value: key_value, type: map._get(:key), hashers: map._get(:hashers) },
-            { type: map._get(:value), modifier: modifier, fallback: fallback }
-          ]
-        else
-          raise 'NoSuchStorageType'
-        end
-      get_storage2(url, pallet_name, item_name, key, value, registry, at)
-    end
-  end
-end

data/lib/client/rpc.rb

@@ -1,60 +0,0 @@
-# frozen_string_literal: true
-
-require 'uri'
-require 'net/http'
-require 'json'
-
-module RPC
-  class << self
-    def json_rpc_call(method, params, url)
-      uri = URI(url)
-      req = Net::HTTP::Post.new(uri, 'Content-Type' => 'application/json')
-      req.body = {
-        'id' => 1,
-        'jsonrpc' => '2.0',
-        'method' => method,
-        'params' => params.all?(nil) ? [] : params
-      }.to_json
-      http = Net::HTTP.new(uri.host, uri.port)
-      http.use_ssl = true if uri.instance_of? URI::HTTPS
-      res = http.request(req)
-      # puts res unless res.is_a?(Net::HTTPSuccess)
-
-      result = JSON.parse(res.body)
-      raise result['error'] if result['error']
-
-      result['result']
-    end
-
-    def chain_getBlockHash(url, block_number = nil)
-      json_rpc_call('chain_getBlockHash', [block_number], url)
-    end
-
-    def chain_getBlock(url, at = nil)
-      json_rpc_call('chain_getBlock', [at], url)
-    end
-
-    def state_getRuntimeVersion(url, at = nil)
-      json_rpc_call('state_getRuntimeVersion', [at], url)
-    end
-
-    def state_getMetadata(url, at = nil)
-      json_rpc_call('state_getMetadata', [at], url)
-    end
-
-    def state_getStorage(url, key, at = nil)
-      json_rpc_call('state_getStorage', [key, at], url)
-    end
-
-    def eth_call(url, to, data, at_block_number = nil)
-      json_rpc_call('eth_call', [
-                      {
-                        'from' => nil,
-                        'to' => to,
-                        'data' => data
-                      },
-                      at_block_number
-                    ], url)
-    end
-  end
-end