scale_rb 0.1.13 → 0.1.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e442bed63503c0e8c7210753df2fa8a293a094c4df6e095f649997923a4d65c6
-  data.tar.gz: 97c1bc3b28346baf2f28a93a5a302240d327b663fc7acad7f0bdbd5c558a8e2e
+  metadata.gz: d49c850c60bd8f6807d0c04995d3b8a5262f63dc627b585e683d774e91ed96ab
+  data.tar.gz: adbba1bbba8cf9bbf3f559893a2b69f90d94a41a259db713f1a7db6dcb83b29f
 SHA512:
-  metadata.gz: b233f131d753ca6bb5f632523da0d09be97d2f721a9933c63c6def842ea55de30fd6a7f46081c0113b114b48ce15ed1193b5b834e382379e2406a8eb3416c012
-  data.tar.gz: 7f97fd3d9927fd3873717226e1294209af285062314850af0d9000e46cdb657b033c3536d19da6cd1bbc6baaeed6f39d729ea7ec3bfcd0c381e75bcfcf1afd5b
+  metadata.gz: b0b06fa722621edab033346e30d78ea8096d98fe032f285845f2685593b6cce266aaa18cd8126cdf1632b1e85f6bcdeea6e6858c12534608ab7fb98a27dbd777
+  data.tar.gz: e57dc6323f7bd0024041ce0ed46bcc006f588e770f895d530d836755981248e1d37abf4d33c529da0e5db57dac231a941bcd506a8822170b8f074b72ba4877cc

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    scale_rb (0.1.13)
+    scale_rb (0.1.15)
       base58
       blake2b_rs (~> 0.1.4)
       xxhash
@@ -14,7 +14,7 @@ GEM
       ffi (~> 1.0)
       thermite (~> 0)
     diff-lcs (1.5.0)
-    ffi (1.15.5)
+    ffi (1.16.3)
     minitar (0.9)
     rake (12.3.3)
     rspec (3.11.0)

data/lib/address.rb

@@ -14,7 +14,7 @@ class Address
     # Darwinia Live
     18,
     # Dothereum (SS58, AccountId)
-    20, 21, 
+    20, 21,
     # Generic Substrate wildcard (SS58, AccountId)
     42, 43,
 
@@ -30,54 +30,62 @@ class Address
   ]
 
   class << self
-
     def array_to_hex_string(arr)
       body = arr.map { |i| i.to_s(16).rjust(2, '0') }.join
       "0x#{body}"
     end
 
-    def decode(address, addr_type = 42, ignore_checksum = true)
+    def decode(address, addr_type = 42, _ignore_checksum = true)
       decoded = Base58.base58_to_binary(address, :bitcoin)
       is_pubkey = decoded.size == 35
 
-      size = decoded.size - ( is_pubkey ? 2 : 1 )
+      size = decoded.size - (is_pubkey ? 2 : 1)
+
+      prefix = decoded[0, 1].unpack1('C*')
 
-      prefix = decoded[0, 1].unpack("C*").first
+      raise 'Invalid address type' unless TYPES.include?(addr_type)
 
-      raise "Invalid address type" unless TYPES.include?(addr_type)
-      
       hash_bytes = make_hash(decoded[0, size])
-      if is_pubkey
-        is_valid_checksum = decoded[-2].unpack("C*").first == hash_bytes[0] && decoded[-1].unpack("C*").first == hash_bytes[1]
-      else
-        is_valid_checksum = decoded[-1].unpack("C*").first == hash_bytes[0]
-      end
+      is_valid_checksum =
+        if is_pubkey
+          decoded[-2].unpack1('C*') == hash_bytes[0] && decoded[-1].unpack1('C*') == hash_bytes[1]
+        else
+          decoded[-1].unpack1('C*') == hash_bytes[0]
+        end
 
       # raise "Invalid decoded address checksum" unless is_valid_checksum && ignore_checksum
 
-      decoded[1...size].unpack("H*").first
+      decoded[1...size].unpack1('H*')
     end
 
-
     def encode(pubkey, addr_type = 42)
       pubkey = pubkey[2..-1] if pubkey =~ /^0x/i
-      key = [pubkey].pack("H*")
-
-      u8_array = key.bytes
-
-      u8_array.unshift(addr_type)
-
-      bytes = make_hash(u8_array.pack("C*"))
-      
-      checksum = bytes[0, key.size == 32 ? 2 : 1]
-
-      u8_array.push(*checksum)
-
-      u8_array = u8_array.map { |i| if i.is_a?(String) then i.to_i(16) else i end }
-      # u8_array = [42, 202, 122, 179, 154, 86, 153, 242, 157, 207, 38, 115, 170, 163, 73, 75, 72, 81, 26, 186, 224, 220, 60, 101, 15, 243, 152, 246, 95, 229, 225, 18, 56, 0x7e]
-      input = u8_array.pack("C*")
-
-      Base58.binary_to_base58(input, :bitcoin)
+      key = [pubkey].pack('H*')
+
+      pubkey_bytes = key.bytes
+
+      checksum_length = case pubkey_bytes.length
+                        when 32, 33
+                          2
+                        when 1, 2, 4, 8
+                          1
+                        else
+                          raise 'Invalid pubkey length'
+                        end
+
+      ss58_format_bytes = if addr_type < 64
+                            [addr_type].pack('C*')
+                          else
+                            [
+                              ((ss58_format & 0b0000_0000_1111_1100) >> 2) | 0b0100_0000,
+                              (ss58_format >> 8) | ((ss58_format & 0b0000_0000_0000_0011) << 6)
+                            ].pack('C*')
+                          end
+
+      input_bytes = ss58_format_bytes.bytes + pubkey_bytes
+      checksum = Blake2b.hex(SS58_PREFIX.bytes + input_bytes, 64).to_bytes
+
+      Base58.binary_to_base58((input_bytes + checksum[0...checksum_length]).pack('C*'), :bitcoin)
     end
 
     def make_hash(body)
@@ -87,11 +95,11 @@ class Address
     def is_ss58_address?(address)
       begin
         decode(address)
-      rescue
+      rescue StandardError
         return false
       end
-      return true
+      true
     end
-
   end
-end
+end
+

data/lib/client/http_client.rb

@@ -3,6 +3,8 @@
 require 'uri'
 require 'net/http'
 require 'json'
+require_relative './http_client_metadata'
+require_relative './http_client_storage'
 
 # TODO: method_name = cmd.gsub(/([a-z\d])([A-Z])/, '\1_\2').downcase
 module ScaleRb
@@ -59,163 +61,6 @@ module ScaleRb
         result = json_rpc_call(url, 'rpc_methods', [])
         result['methods']
       end
-
-      def get_metadata(url, at = nil)
-        hex = 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 = 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)
-        # map, but no key's value provided. get all storages under the partial storage key
-        if key && (key[:value].nil? || key[:value].empty?)
-          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
-          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
-
-      # get_storage3 is a more ruby style function
-      #
-      # pallet_name and storage_name is pascal style like 'darwinia_staking'
-      def get_storage3(url, metadata, pallet_name, storage_name, key_part1: nil, key_part2: nil, at: 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 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/http_client_metadata.rb

@@ -0,0 +1,78 @@
+require 'json'
+require 'fileutils'
+
+module ScaleRb
+  module HttpClient
+    class << self
+      def get_metadata(url, at = nil)
+        hex = state_getMetadata(url, at)
+        Metadata.decode_metadata(hex.strip.to_bytes)
+      end
+
+      # cached version of get_metadata
+      # get metadata from cache first
+      def get_metadata_cached(url, at: nil, dir: nil)
+        dir = ENV['SCALE_RB_METADATA_DIR'] || File.join(Dir.pwd, 'metadata') if dir.nil?
+
+        at = ScaleRb::HttpClient.chain_getFinalizedHead(url) if at.nil?
+        spec_name, spec_version = get_spec(url, at)
+
+        # get metadata from cache first
+        metadata = metadata_cached(
+          spec_name: spec_name,
+          spec_version: spec_version,
+          dir: dir
+        )
+        return metadata if metadata
+
+        # get metadata from rpc
+        metadata = ScaleRb::HttpClient.get_metadata(url, at)
+
+        # cache it
+        ScaleRb.logger.debug "caching metadata `#{spec_name}_#{spec_version}.json`"
+        save_metadata_to_file(
+          spec_name: spec_name,
+          spec_version: spec_version,
+          metadata: metadata,
+          dir: dir
+        )
+
+        metadata
+      end
+
+      private
+
+      def get_spec(url, at)
+        runtime_version = ScaleRb::HttpClient.state_getRuntimeVersion(url, at)
+        spec_name = runtime_version['specName']
+        spec_version = runtime_version['specVersion']
+        [spec_name, spec_version]
+      end
+
+      def metadata_cached(spec_name:, spec_version:, dir:)
+        raise 'spec_version is required' unless spec_version
+        raise 'spec_name is required' unless spec_name
+
+        file_path = File.join(dir, "#{spec_name}_#{spec_version}.json")
+        return unless File.exist?(file_path)
+
+        ScaleRb.logger.debug "found metadata `#{spec_name}_#{spec_version}.json` in cache"
+        JSON.parse(File.read(file_path))
+      end
+
+      def save_metadata_to_file(spec_name:, spec_version:, metadata:, dir:)
+        FileUtils.mkdir_p(dir)
+
+        File.open(File.join(dir, "#{spec_name}_#{spec_version}.json"), 'w') do |f|
+          f.write(JSON.pretty_generate(metadata))
+        end
+      end
+
+      def require_block_hash_correct(url, block_hash)
+        return unless ScaleRb::HttpClient.chain_getHeader(url, block_hash).nil?
+
+        raise 'Unable to retrieve header and parent from supplied hash'
+      end
+    end
+  end
+end

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/codec.rb

@@ -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
@@ -221,8 +221,8 @@ 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
+      # 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
 
@@ -247,8 +247,8 @@ module ScaleRb
       raise NotEnoughBytesError, 'type: String' if remaining_bytes.length < length
 
       value = remaining_bytes[0...length].to_utf8
-      debug 'byte length', length
-      debug 'value', value.inspect
+      # debug 'byte length', length
+      # debug 'value', value.inspect
       [
         value,
         remaining_bytes[length..]
@@ -261,7 +261,7 @@ module ScaleRb
       raise NotEnoughBytesError, "type: #{type}" if bytes.length < byte_length
 
       value = bytes[0...byte_length].flip.to_int(bit_length)
-      debug 'value', value
+      # debug 'value', value
       [
         value,
         bytes[byte_length..]
@@ -274,7 +274,7 @@ module ScaleRb
       raise NotEnoughBytesError, "type: #{type_def}" if bytes.length < byte_length
 
       value = bytes[0...byte_length].flip.to_uint
-      debug 'value', value
+      # 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)

data/lib/scale_rb/version.rb

@@ -1,3 +1,3 @@
 module ScaleRb
-  VERSION = '0.1.13'
+  VERSION = '0.1.15'
 end

data/lib/storage_helper.rb

@@ -12,26 +12,26 @@ module StorageHelper
 
       if key && registry
 
-        key_types, key_values =
+        key_types, key_values, key_hashers =
           if key[:hashers].length == 1
             [
               [key[:type]],
-              key[:value]
+              key[:value],
+              key[:hashers]
             ]
           else
             [
-              registry[key[:type]]._get(:def)._get(:tuple),
-              key[:value]
+              registry[key[:type]]._get(:def)._get(:tuple).first(key[:value].length),
+              key[:value],
+              key[:hashers].first(key[:value].length)
             ]
           end
 
-        # debug
-        # p "encode_storage_key -----------------------"
-        # p key_types
-        # p key_values
-        # p "encode_storage_key -----------------------"
-        raise "Key's value doesn't match key's type, key's value: #{key_values.inspect}, but key's type: #{key_types.inspect}. Please check your key's value." if key_types.class != key_values.class || key_types.length != key_values.length
-        storage_key + PortableCodec._encode_types_with_hashers(key_types, key_values, registry, key[:hashers])
+        if key_types.class != key_values.class || key_types.length != key_values.length
+          raise "Key's value doesn't match key's type, key's value: #{key_values.inspect}, but key's type: #{key_types.inspect}. Please check your key's value."
+        end
+
+        storage_key + PortableCodec._encode_types_with_hashers(key_types, key_values, registry, key_hashers)
       else
         storage_key
       end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: scale_rb
 version: !ruby/object:Gem::Version
-  version: 0.1.13
+  version: 0.1.15
 platform: ruby
 authors:
 - Aki Wu
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-08-25 00:00:00.000000000 Z
+date: 2023-10-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: blake2b_rs
@@ -76,6 +76,8 @@ files:
 - lib/address.rb
 - lib/client/abstract_ws_client.rb
 - lib/client/http_client.rb
+- lib/client/http_client_metadata.rb
+- lib/client/http_client_storage.rb
 - lib/client/rpc_request_builder.rb
 - lib/codec.rb
 - lib/hasher.rb