scale_rb 0.1.14 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 82a0911194368a4fcefec7a414694346f087c0ded749d3865f6732f27c8afef0
-  data.tar.gz: 14b34a748f835c527726ebd42440cced5ed8b5c0d954cb15c41e288ce3e5aff6
+  metadata.gz: 9857ea16c7327b90a598f40ce8afe919ee3db3a1fada67ba9e1a5ee768c50fdf
+  data.tar.gz: 7bd319b972c1c4aa13f4f24c6af525294bcbd8b6361423db66ac6038e44ad990
 SHA512:
-  metadata.gz: 805efca604cc93794b5c1d4ee3dd1785d74d6a049b55f0ecc0503c85869c2759a37380b6735b8ecf874b6b33b31492f7b203870b7b414758740545821f98db19
-  data.tar.gz: d5f577ec96adf7a51ef7044b0d5f8bc874e3a12daf66e3cc743677a6a095ddda909267b941dd15a06646dc941caeabe810fd960140c1c94261d173796ee40b9d
+  metadata.gz: db6452725e87b88cd0bdffe419588c8b9b8cfe892bdac01df226e9008bf02e45d56c9c25447a932d8ddf43bdfecf6ade0095710c9e056ee14ef2813f7b500b75
+  data.tar.gz: 2c6d01fd6726cc7ff5ed7c303b5e3c7ffe48347267a7b6989a6cda032741c47cfe339fa4c51871166b78f794a999cf8b0e6104cf44d013912bf5dbac0599cb45

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    scale_rb (0.1.14)
+    scale_rb (0.2.0)
       base58
       blake2b_rs (~> 0.1.4)
       xxhash

data/lib/address.rb

@@ -1,105 +1,101 @@
 require 'base58'
 
 # Warning: Just for test
-class Address
-  SS58_PREFIX = 'SS58PRE'
-
-  TYPES = [
-    # Polkadot Live (SS58, AccountId)
-    0, 1,
-    # Polkadot Canary (SS58, AccountId)
-    2, 3,
-    # Kulupu (SS58, Reserved)
-    16, 17,
-    # Darwinia Live
-    18,
-    # Dothereum (SS58, AccountId)
-    20, 21,
-    # Generic Substrate wildcard (SS58, AccountId)
-    42, 43,
-
-    # Schnorr/Ristretto 25519 ("S/R 25519") key
-    48,
-    # Edwards Ed25519 key
-    49,
-    # ECDSA SECP256k1 key
-    50,
-
-    # Reserved for future address format extensions.
-    *64..255
-  ]
-
-  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)
-      decoded = Base58.base58_to_binary(address, :bitcoin)
-      is_pubkey = decoded.size == 35
-
-      size = decoded.size - (is_pubkey ? 2 : 1)
-
-      prefix = decoded[0, 1].unpack1('C*')
-
-      raise 'Invalid address type' unless TYPES.include?(addr_type)
-
-      hash_bytes = make_hash(decoded[0, size])
-      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].unpack1('H*')
-    end
-
-    def encode(pubkey, addr_type = 42)
-      pubkey = pubkey[2..-1] if pubkey =~ /^0x/i
-      key = [pubkey].pack('H*')
+module ScaleRb
+  class Address
+    SS58_PREFIX = 'SS58PRE'
+
+    TYPES = [
+      # Polkadot Live (SS58, AccountId)
+      0, 1,
+      # Polkadot Canary (SS58, AccountId)
+      2, 3,
+      # Kulupu (SS58, Reserved)
+      16, 17,
+      # Darwinia Live
+      18,
+      # Dothereum (SS58, AccountId)
+      20, 21,
+      # Generic Substrate wildcard (SS58, AccountId)
+      42, 43,
+
+      # Schnorr/Ristretto 25519 ("S/R 25519") key
+      48,
+      # Edwards Ed25519 key
+      49,
+      # ECDSA SECP256k1 key
+      50,
+
+      # Reserved for future address format extensions.
+      *64..255
+    ]
+
+    class << self
+      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)
+
+        prefix = decoded[0, 1].unpack1('C*')
+
+        raise 'Invalid address type' unless TYPES.include?(addr_type)
+
+        hash_bytes = make_hash(decoded[0, size])
+        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].unpack1('H*')
+      end
 
-      pubkey_bytes = key.bytes
+      def encode(pubkey, addr_type = 42)
+        pubkey = pubkey[2..-1] if pubkey =~ /^0x/i
+        key = [pubkey].pack('H*')
 
-      checksum_length = case pubkey_bytes.length
-                        when 32, 33
-                          2
-                        when 1, 2, 4, 8
-                          1
-                        else
-                          raise 'Invalid pubkey length'
-                        end
+        pubkey_bytes = key.bytes
 
-      ss58_format_bytes = if addr_type < 64
-                            [addr_type].pack('C*')
+        checksum_length = case pubkey_bytes.length
+                          when 32, 33
+                            2
+                          when 1, 2, 4, 8
+                            1
                           else
-                            [
-                              ((ss58_format & 0b0000_0000_1111_1100) >> 2) | 0b0100_0000,
-                              (ss58_format >> 8) | ((ss58_format & 0b0000_0000_0000_0011) << 6)
-                            ].pack('C*')
+                            raise 'Invalid pubkey length'
                           end
 
-      input_bytes = ss58_format_bytes.bytes + pubkey_bytes
-      checksum = Blake2b.hex(SS58_PREFIX.bytes + input_bytes, 64).to_bytes
+        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
 
-      Base58.binary_to_base58((input_bytes + checksum[0...checksum_length]).pack('C*'), :bitcoin)
-    end
+        input_bytes = ss58_format_bytes.bytes + pubkey_bytes
+        checksum = Blake2b.hex(SS58_PREFIX.bytes + input_bytes, 64)._to_bytes
 
-    def make_hash(body)
-      Blake2b.hex("#{SS58_PREFIX}#{body}".bytes, 64)
-    end
+        Base58.binary_to_base58((input_bytes + checksum[0...checksum_length]).pack('C*'), :bitcoin)
+      end
 
-    def is_ss58_address?(address)
-      begin
-        decode(address)
-      rescue StandardError
-        return false
+      def make_hash(body)
+        Blake2b.hex("#{SS58_PREFIX}#{body}".bytes, 64)
+      end
+
+      def is_ss58_address?(address)
+        begin
+          decode(address)
+        rescue StandardError
+          return false
+        end
+        true
       end
-      true
     end
   end
 end
-

data/lib/client/abstract_ws_client.rb

@@ -1,100 +1,104 @@
 # frozen_string_literal: true
 
-class AbstractWsClient
-  extend RpcRequestBuilder
-  attr_accessor :metadata, :registry
-
-  def initialize
-    @id = 0
-    @metadata = nil
-    @registry = nil
-    @callbacks = {}
-    @subscription_callbacks = {}
-  end
+require_relative './rpc_request_builder'
+
+module ScaleRb
+  class AbstractWsClient
+    extend RpcRequestBuilder
+    attr_accessor :metadata, :registry
+
+    def initialize
+      @id = 0
+      @metadata = nil
+      @registry = nil
+      @callbacks = {}
+      @subscription_callbacks = {}
+    end
 
-  def send_json_rpc(_body)
-    raise 'WsClient is a abstract base class for websocket client, please use its sub-class'
-  end
+    def send_json_rpc(_body)
+      raise 'WsClient is a abstract base class for websocket client, please use its sub-class'
+    end
 
-  # changes: [
-  #   [
-  #     "0x26aa394eea5630e07c48ae0c9558cef780d41e5e16056765bc8461851072c9d7", # storage key
-  #     "0x0400000000000000d887690900000000020000" # change
-  #   ]
-  # ]
-  def process(resp)
-    # handle id
-    @callbacks[resp['id']]&.call(resp['id'], resp) if resp['id']
-
-    # handle storage subscription
-    return unless resp['params'] && resp['params']['subscription']
-    return unless @metadata && @registry
-
-    subscription = resp['params']['subscription']
-    changes = resp['params']['result']['changes']
-    block = resp['params']['result']['block']
-    p "block: #{block}"
-
-    return unless @subscription_callbacks[subscription]
-
-    pallet_name, item_name, subscription_callback = @subscription_callbacks[subscription]
-    storage_item = Metadata.get_storage_item(pallet_name, item_name, @metadata)
-    storages = decode_storages(changes.map(&:last), storage_item, registry)
-    subscription_callback.call(storages)
-  end
+    # changes: [
+    #   [
+    #     "0x26aa394eea5630e07c48ae0c9558cef780d41e5e16056765bc8461851072c9d7", # storage key
+    #     "0x0400000000000000d887690900000000020000" # change
+    #   ]
+    # ]
+    def process(resp)
+      # handle id
+      @callbacks[resp['id']]&.call(resp['id'], resp) if resp['id']
+
+      # handle storage subscription
+      return unless resp['params'] && resp['params']['subscription']
+      return unless @metadata && @registry
+
+      subscription = resp['params']['subscription']
+      changes = resp['params']['result']['changes']
+      block = resp['params']['result']['block']
+      p "block: #{block}"
+
+      return unless @subscription_callbacks[subscription]
+
+      pallet_name, item_name, subscription_callback = @subscription_callbacks[subscription]
+      storage_item = Metadata.get_storage_item(pallet_name, item_name, @metadata)
+      storages = decode_storages(changes.map(&:last), storage_item, registry)
+      subscription_callback.call(storages)
+    end
 
-  def get_metadata(callback = nil)
-    if callback.nil?
-      callback = lambda do |id, resp|
-        return unless resp['id'] && resp['result']
-        return if resp['id'] != id
+    def get_metadata(callback = nil)
+      if callback.nil?
+        callback = lambda do |id, resp|
+          return unless resp['id'] && resp['result']
+          return if resp['id'] != id
 
-        metadata_hex = resp['result']
-        metadata = Metadata.decode_metadata(metadata_hex.strip.to_bytes)
-        return unless metadata
+          metadata_hex = resp['result']
+          metadata = Metadata.decode_metadata(metadata_hex.strip._to_bytes)
+          return unless metadata
 
-        @metadata = metadata
-        @registry = Metadata.build_registry(@metadata)
+          @metadata = metadata
+          @registry = Metadata.build_registry(@metadata)
+        end
       end
-    end
 
-    id = bind_id_to(callback)
-    body = state_getMetadata(id)
-    send_json_rpc(body)
-  end
+      id = bind_id_to(callback)
+      body = state_getMetadata(id)
+      send_json_rpc(body)
+    end
 
-  def subscribe_storage(pallet_name, item_name, subscription_callback, key = nil, registry = nil)
-    callback = create_callback_for_subscribe_storage(pallet_name, item_name, subscription_callback)
-    id = bind_id_to(callback)
-    body = derived_state_subscribe_storage(id, pallet_name, item_name, key, registry)
-    send_json_rpc(body)
-  end
+    def subscribe_storage(pallet_name, item_name, subscription_callback, key = nil, registry = nil)
+      callback = create_callback_for_subscribe_storage(pallet_name, item_name, subscription_callback)
+      id = bind_id_to(callback)
+      body = derived_state_subscribe_storage(id, pallet_name, item_name, key, registry)
+      send_json_rpc(body)
+    end
 
-  private
+    private
 
-  def bind_id_to(callback)
-    @callbacks[@id] = callback
-    old = @id
-    @id += 1
-    old
-  end
+    def bind_id_to(callback)
+      @callbacks[@id] = callback
+      old = @id
+      @id += 1
+      old
+    end
 
-  def decode_storages(datas, storage_item, registry)
-    datas.map do |data|
-      StorageHelper.decode_storage2(data, storage_item, registry)
+    def decode_storages(datas, storage_item, registry)
+      datas.map do |data|
+        StorageHelper.decode_storage2(data, storage_item, registry)
+      end
     end
-  end
 
-  def create_callback_for_subscribe_storage(pallet_name, item_name, subscription_callback)
-    lambda do |id, resp|
-      return unless resp['id'] && resp['result']
-      return if resp['id'] != id
+    def create_callback_for_subscribe_storage(pallet_name, item_name, subscription_callback)
+      lambda do |id, resp|
+        return unless resp['id'] && resp['result']
+        return if resp['id'] != id
 
-      @subscription_callbacks[resp['result']] = [
-        pallet_name,
-        item_name,
-        subscription_callback
-      ]
+        @subscription_callbacks[resp['result']] = [
+          pallet_name,
+          item_name,
+          subscription_callback
+        ]
+      end
     end
   end
 end

data/lib/client/http_client.rb

@@ -3,7 +3,9 @@
 require 'uri'
 require 'net/http'
 require 'json'
+require_relative './rpc_request_builder'
 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
@@ -60,176 +62,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)
-        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 part, but only provide part value
-            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
-
-      # 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

@@ -4,14 +4,16 @@ 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: File.join(Dir.pwd, 'metadata'))
-        # if at
-        #   require_block_hash_correct(url, at)
-        # else
-        #   at = ScaleRb::HttpClient.chain_getFinalizedHead(url)
-        # end
+      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)
 
@@ -27,7 +29,7 @@ module ScaleRb
         metadata = ScaleRb::HttpClient.get_metadata(url, at)
 
         # cache it
-        puts "caching metadata `#{spec_name}_#{spec_version}.json`"
+        ScaleRb.logger.debug "caching metadata `#{spec_name}_#{spec_version}.json`"
         save_metadata_to_file(
           spec_name: spec_name,
           spec_version: spec_version,
@@ -54,7 +56,7 @@ module ScaleRb
         file_path = File.join(dir, "#{spec_name}_#{spec_version}.json")
         return unless File.exist?(file_path)
 
-        puts "found metadata `#{spec_name}_#{spec_version}.json` in cache"
+        ScaleRb.logger.debug "found metadata `#{spec_name}_#{spec_version}.json` in cache"
         JSON.parse(File.read(file_path))
       end