scale_rb 0.1.14 → 0.2.0

data/lib/client/http_client_storage.rb

@@ -0,0 +1,180 @@
+module ScaleRb
+  module HttpClient
+    class << self
+      # get_storage3 is a more ruby style function
+      #
+      # pallet_name and storage_name is pascal style like 'darwinia_staking'
+      def get_storage3(url, pallet_name, storage_name, key_part1: nil, key_part2: nil, metadata: nil, at: nil)
+        # Get metadata if not provided, and cache it.
+        # The default dir is `metadata` dir under the caller's dir.
+        # You can change it by setting `SCALE_RB_METADATA_DIR` env variable
+        metadata = get_metadata_cached(url, at: at) if metadata.nil?
+
+        pallet_name = to_pascal pallet_name
+        storage_name = to_pascal storage_name
+        ScaleRb.logger.debug "#{pallet_name}.#{storage_name}(#{[key_part1, key_part2].compact.join(', ')})"
+
+        key = [key_part1, key_part2].compact.map { |part_of_key| c(part_of_key) }
+        ScaleRb.logger.debug "converted key: #{key}"
+
+        get_storage2(
+          url,
+          pallet_name,
+          storage_name,
+          key,
+          metadata,
+          at
+        )
+      end
+
+      private
+
+      def query_storage_at(url, storage_keys, type_id, default, registry, at = nil)
+        result = 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 = 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
+
+      # 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'
+      #   },
+      #   ..
+      #
+      # TODO: part of the key is provided, but not all
+      def get_storage(url, pallet_name, item_name, key, value, registry, at = nil)
+        if key
+          if key[:value].nil? || key[:value].empty?
+            # map, but no key's value provided. get all storages under the partial storage key
+            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
+            )
+          elsif key[:value].length != key[:hashers].length
+            # map with multi parts, but not have all values
+            partial_storage_key = StorageHelper.encode_storage_key(pallet_name, item_name, key, registry)._to_hex
+            get_storages_by_partial_key(
+              url,
+              partial_storage_key,
+              value[:type],
+              value[:modifier] == 'Default' ? value[:fallback] : nil,
+              registry,
+              at
+            )
+          end
+        else
+          storage_key = StorageHelper.encode_storage_key(pallet_name, item_name, key, registry)._to_hex
+          data = state_getStorage(url, storage_key, at)
+          StorageHelper.decode_storage(data, value[:type], value[:modifier] == 'Optional', value[:fallback], registry)
+        end
+      end
+
+      def get_storage2(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
+        )
+        raise "No such storage item: `#{pallet_name}`.`#{item_name}`" if item.nil?
+
+        modifier = item._get(:modifier) # Default | Optional
+        fallback = item._get(:fallback)
+        type = item._get(:type)
+
+        plain = type._get(:plain)
+        map = type._get(:map)
+        # debug
+
+        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_storage(url, pallet_name, item_name, key, value, registry, at)
+      end
+
+      def to_pascal(str)
+        str.split('_').collect(&:capitalize).join
+      end
+
+      # convert key to byte array
+      def c(key)
+        if key.start_with?('0x')
+          key._to_bytes
+        elsif key.to_i.to_s == key # check if key is a number
+          key.to_i
+        else
+          key
+        end
+      end
+    end
+  end
+end

data/lib/client/rpc_request_builder.rb

@@ -2,52 +2,54 @@
 
 require 'json'
 
-module RpcRequestBuilder
-  def build_json_rpc_body(method, params, id)
-    {
-      'id' => id,
-      'jsonrpc' => '2.0',
-      'method' => method,
-      'params' => params.reject(&:nil?)
-    }.to_json
-  end
+module ScaleRb
+  module RpcRequestBuilder
+    def build_json_rpc_body(method, params, id)
+      {
+        'id' => id,
+        'jsonrpc' => '2.0',
+        'method' => method,
+        'params' => params.reject(&:nil?)
+      }.to_json
+    end
 
-  def respond_to_missing?(*_args)
-    true
-  end
+    def respond_to_missing?(*_args)
+      true
+    end
 
-  # example:
-  #   state_getStorage(1, '0x363a..', 563_868)
-  #
-  #   ==
-  #
-  #   build_json_rpc_body('state_getStorage', ['0x363a..', 563_868], 1)
-  def method_missing(method, *args)
-    build_json_rpc_body(method, args[1..], args[0])
-  end
+    # example:
+    #   state_getStorage(1, '0x363a..', 563_868)
+    #
+    #   ==
+    #
+    #   build_json_rpc_body('state_getStorage', ['0x363a..', 563_868], 1)
+    def method_missing(method, *args)
+      build_json_rpc_body(method, args[1..], args[0])
+    end
 
-  ###################################
-  # derived functions
-  ###################################
-  def derived_state_get_storage(rpc_id, pallet_name, item_name, key = nil, registry = nil)
-    storage_key = StorageHelper.encode_storage_key(pallet_name, item_name, key, registry).to_hex
-    state_getStorage(rpc_id, [storage_key])
-  end
+    ###################################
+    # derived functions
+    ###################################
+    def derived_state_get_storage(rpc_id, pallet_name, item_name, key = nil, registry = nil)
+      storage_key = StorageHelper.encode_storage_key(pallet_name, item_name, key, registry)._to_hex
+      state_getStorage(rpc_id, [storage_key])
+    end
 
-  def derived_state_subscribe_storage(rpc_id, pallet_name, item_name, key = nil, registry = nil)
-    storage_key = StorageHelper.encode_storage_key(pallet_name, item_name, key, registry).to_hex
-    state_subscribeStorage(rpc_id, [storage_key])
-  end
+    def derived_state_subscribe_storage(rpc_id, pallet_name, item_name, key = nil, registry = nil)
+      storage_key = StorageHelper.encode_storage_key(pallet_name, item_name, key, registry)._to_hex
+      state_subscribeStorage(rpc_id, [storage_key])
+    end
 
-  def derived_eth_call(rpc_id, to, data, at = nil)
-    eth_call(
-      rpc_id,
-      [
-        {
-          'from' => nil, 'to' => to, 'data' => data
-        },
-        at
-      ]
-    )
+    def derived_eth_call(rpc_id, to, data, at = nil)
+      eth_call(
+        rpc_id,
+        [
+          {
+            'from' => nil, 'to' => to, 'data' => data
+          },
+          at
+        ]
+      )
+    end
   end
 end

data/lib/codec.rb

@@ -145,12 +145,12 @@ module ScaleRb
       when 0
         [bytes[0] >> 2, bytes[1..]]
       when 1
-        [bytes[0..1].flip.to_uint >> 2, bytes[2..]]
+        [bytes[0..1]._flip._to_uint >> 2, bytes[2..]]
       when 2
-        [bytes[0..3].flip.to_uint >> 2, bytes[4..]]
+        [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..]]
+        [bytes[1..length]._flip._to_uint, bytes[length + 1..]]
       else
         raise Unreachable, 'type: Compact'
       end
@@ -191,9 +191,9 @@ module ScaleRb
   # Decode
   class << self
     def decode(type, bytes, registry = {})
-      logger.debug '--------------------------------------------------'
-      debug 'decoding type', type
-      debug 'bytes', bytes&.length
+      # logger.debug '--------------------------------------------------'
+      # debug 'decoding type', type
+      # debug 'bytes', bytes&.length
 
       if type.instance_of?(String)
         return decode_bytes(bytes) if bytes?(type) # Bytes
@@ -220,9 +220,9 @@ module ScaleRb
 
     def decode_bytes(bytes)
       length, remaining_bytes = _do_decode_compact(bytes)
-      value = remaining_bytes[0...length].to_hex
-      debug 'length', length
-      debug 'value', value
+      value = remaining_bytes[0...length]._to_hex
+      # debug 'length', length
+      # debug 'value', value
       [
         value,
         remaining_bytes[length..]
@@ -238,7 +238,7 @@ module ScaleRb
         else
           raise InvalidBytesError, 'type: Boolean'
         end
-      debug 'value', value
+      # debug 'value', value
       [value, bytes[1..]]
     end
 
@@ -246,9 +246,9 @@ module ScaleRb
       length, remaining_bytes = _do_decode_compact(bytes)
       raise NotEnoughBytesError, 'type: String' if remaining_bytes.length < length
 
-      value = remaining_bytes[0...length].to_utf8
-      debug 'byte length', length
-      debug 'value', value.inspect
+      value = remaining_bytes[0...length]._to_utf8
+      # debug 'byte length', length
+      # debug 'value', value.inspect
       [
         value,
         remaining_bytes[length..]
@@ -260,8 +260,8 @@ module ScaleRb
       byte_length = bit_length / 8
       raise NotEnoughBytesError, "type: #{type}" if bytes.length < byte_length
 
-      value = bytes[0...byte_length].flip.to_int(bit_length)
-      debug 'value', value
+      value = bytes[0...byte_length]._flip._to_int(bit_length)
+      # debug 'value', value
       [
         value,
         bytes[byte_length..]
@@ -273,8 +273,8 @@ module ScaleRb
       byte_length = bit_length / 8
       raise NotEnoughBytesError, "type: #{type_def}" if bytes.length < byte_length
 
-      value = bytes[0...byte_length].flip.to_uint
-      debug 'value', value
+      value = bytes[0...byte_length]._flip._to_uint
+      # debug 'value', value
       [
         value,
         bytes[byte_length..]
@@ -282,9 +282,8 @@ module ScaleRb
     end
 
     def decode_compact(bytes)
-      result = _do_decode_compact(bytes)
-      debug 'value', result[0]
-      result
+      _do_decode_compact(bytes)
+      # debug 'value', result[0]
     end
 
     def decode_option(type_def, bytes, registry = {})
@@ -304,7 +303,7 @@ module ScaleRb
     def decode_vec(type_def, bytes, registry = {})
       inner_type = parse_vec(type_def)
       length, remaining_bytes = _do_decode_compact(bytes)
-      debug 'length', length
+      # debug 'length', length
       _decode_types([inner_type] * length, remaining_bytes, registry)
     end
 
@@ -331,7 +330,7 @@ module ScaleRb
       raise IndexOutOfRangeError, "type: #{type_def}" if index > items.length - 1
 
       item = items.to_a[index] # 'name' or [:name, inner_type]
-      debug 'value', item.inspect
+      # debug 'value', item.inspect
       return [item, bytes[1..]] if item.instance_of?(String)
 
       value, remaining_bytes = decode(item[1], bytes[1..], registry)
@@ -353,9 +352,9 @@ module ScaleRb
   # Encode
   class << self
     def encode(type, value, registry = {})
-      logger.debug '--------------------------------------------------'
-      debug 'encoding type', type
-      debug 'value', value
+      # logger.debug '--------------------------------------------------'
+      # debug 'encoding type', type
+      # debug 'value', value
 
       if type.instance_of?(String)
         return encode_bytes(value) if bytes?(type)
@@ -397,16 +396,16 @@ module ScaleRb
 
     def encode_compact(value)
       return [value << 2] if (value >= 0) && (value < 64)
-      return ((value << 2) + 1).to_bytes.flip if value < 2**14
-      return ((value << 2) + 2).to_bytes.flip if value < 2**30
+      return ((value << 2) + 1)._to_bytes._flip if value < 2**14
+      return ((value << 2) + 2)._to_bytes._flip if value < 2**30
 
-      bytes = value.to_bytes.flip
+      bytes = value._to_bytes._flip
       [(((bytes.length - 4) << 2) + 3)] + bytes
     end
 
     def encode_uint(type, value)
       bit_length = type[1..].to_i
-      value.to_bytes(bit_length).flip
+      value._to_bytes(bit_length)._flip
     end
 
     def encode_option(type, value, registry = {})

data/lib/hasher.rb

@@ -3,52 +3,54 @@
 require 'xxhash'
 require 'blake2b'
 
-module Hasher
-  class << self
-    # params:
-    #   hasher: 'Identity' | 'Twox64Concat' | 'Blake2128Concat'
-    #    bytes: u8 array
-    # return: u8 array
-    def apply_hasher(hasher, bytes)
-      function_name = hasher.gsub('_', '').underscore
-      Hasher.send(function_name, bytes)
+module ScaleRb
+  module Hasher
+    class << self
+      # params:
+      #   hasher: 'Identity' | 'Twox64Concat' | 'Blake2128Concat'
+      #    bytes: u8 array
+      # return: u8 array
+      def apply_hasher(hasher, bytes)
+        function_name = hasher.gsub('_', '')._underscore
+        Hasher.send(function_name, bytes)
+      end
     end
-  end
 
-  class << self
-    def identity(bytes)
-      bytes
-    end
+    class << self
+      def identity(bytes)
+        bytes
+      end
 
-    def twox64_concat(bytes)
-      data = bytes.to_utf8
-      twox64(data) + bytes
-    end
+      def twox64_concat(bytes)
+        data = bytes._to_utf8
+        twox64(data) + bytes
+      end
 
-    def blake2128_concat(bytes)
-      blake2_128(bytes) + bytes
-    end
+      def blake2128_concat(bytes)
+        blake2_128(bytes) + bytes
+      end
 
-    def twox64(str)
-      result = XXhash.xxh64 str, 0
-      result.to_bytes.reverse
-    end
+      def twox64(str)
+        result = XXhash.xxh64 str, 0
+        result._to_bytes.reverse
+      end
 
-    def twox128(str)
-      bytes = []
-      2.times do |i|
-        result = XXhash.xxh64 str, i
-        bytes += result.to_bytes.reverse
+      def twox128(str)
+        bytes = []
+        2.times do |i|
+          result = XXhash.xxh64 str, i
+          bytes += result._to_bytes.reverse
+        end
+        bytes
       end
-      bytes
-    end
 
-    def blake2_128(bytes)
-      Blake2b.hex(bytes, 16).to_bytes
-    end
+      def blake2_128(bytes)
+        Blake2b.hex(bytes, 16)._to_bytes
+      end
 
-    def blake2_256(bytes)
-      Blake2b.hex(bytes, 32).to_bytes
+      def blake2_256(bytes)
+        Blake2b.hex(bytes, 32)._to_bytes
+      end
     end
   end
 end