scale_rb 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9857ea16c7327b90a598f40ce8afe919ee3db3a1fada67ba9e1a5ee768c50fdf
-  data.tar.gz: 7bd319b972c1c4aa13f4f24c6af525294bcbd8b6361423db66ac6038e44ad990
+  metadata.gz: 79d55aeb610c1a4a11410703445983aa6b02cbf8ee21653a38d425b06c41e3dc
+  data.tar.gz: 8e7832aa2495fed7226797bd21bc23db257754c8d5160cba57f7830879fe592f
 SHA512:
-  metadata.gz: db6452725e87b88cd0bdffe419588c8b9b8cfe892bdac01df226e9008bf02e45d56c9c25447a932d8ddf43bdfecf6ade0095710c9e056ee14ef2813f7b500b75
-  data.tar.gz: 2c6d01fd6726cc7ff5ed7c303b5e3c7ffe48347267a7b6989a6cda032741c47cfe339fa4c51871166b78f794a999cf8b0e6104cf44d013912bf5dbac0599cb45
+  metadata.gz: 879a524038c25c42b98724a95c9db2658ba41a952386fa4132eb56ceff4d3403aa3fc519c4add1d29fc1ad6e413bdb5f1bc8ab4585a836327bc233dc7750ab43
+  data.tar.gz: 4529731208f640854a9b9b3676ffdd3727b9344833ab026cd593f5d10e17ea0428bd651bc01aa774cb80fd68350249ba68be4b99eea54db6fe597b6f3732723a

data/.gitignore

@@ -10,3 +10,4 @@
 
 # rspec failure tracking
 .rspec_status
+/metadata

data/Gemfile.lock

@@ -1,7 +1,10 @@
 PATH
   remote: .
   specs:
-    scale_rb (0.2.0)
+    scale_rb (0.3.0)
+      async
+      async-http (~> 0.69.0)
+      async-websocket (~> 0.26.2)
       base58
       blake2b_rs (~> 0.1.4)
       xxhash
@@ -9,13 +12,57 @@ PATH
 GEM
   remote: https://rubygems.org/
   specs:
+    async (2.14.0)
+      console (~> 1.25, >= 1.25.2)
+      fiber-annotation
+      io-event (~> 1.6, >= 1.6.5)
+    async-http (0.69.0)
+      async (>= 2.10.2)
+      async-pool (~> 0.7)
+      io-endpoint (~> 0.11)
+      io-stream (~> 0.4)
+      protocol-http (~> 0.26)
+      protocol-http1 (~> 0.19)
+      protocol-http2 (~> 0.18)
+      traces (>= 0.10)
+    async-pool (0.7.0)
+      async (>= 1.25)
+    async-websocket (0.26.2)
+      async-http (~> 0.54)
+      protocol-rack (~> 0.5)
+      protocol-websocket (~> 0.14)
     base58 (0.2.3)
     blake2b_rs (0.1.4)
       ffi (~> 1.0)
       thermite (~> 0)
+    console (1.25.2)
+      fiber-annotation
+      fiber-local (~> 1.1)
+      json
     diff-lcs (1.5.0)
-    ffi (1.16.3)
+    ffi (1.17.0)
+    fiber-annotation (0.2.0)
+    fiber-local (1.1.0)
+      fiber-storage
+    fiber-storage (0.1.2)
+    io-endpoint (0.11.0)
+    io-event (1.6.5)
+    io-stream (0.4.0)
+    json (2.7.2)
     minitar (0.9)
+    protocol-hpack (1.4.3)
+    protocol-http (0.27.0)
+    protocol-http1 (0.19.1)
+      protocol-http (~> 0.22)
+    protocol-http2 (0.18.0)
+      protocol-hpack (~> 1.4)
+      protocol-http (~> 0.18)
+    protocol-rack (0.6.0)
+      protocol-http (~> 0.23)
+      rack (>= 1.0)
+    protocol-websocket (0.15.0)
+      protocol-http (~> 0.2)
+    rack (3.1.7)
     rake (12.3.3)
     rspec (3.11.0)
       rspec-core (~> 3.11.0)
@@ -35,6 +82,7 @@ GEM
       rake (>= 10)
       tomlrb (~> 1.2)
     tomlrb (1.3.0)
+    traces (0.11.1)
     xxhash (0.5.0)
 
 PLATFORMS

data/README.md

@@ -1,7 +1,5 @@
 # ScaleRb
 
-*WARNING: UNDER DEVELOPMENT*
-
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -18,9 +16,14 @@ Or install it yourself as:
 
     $ gem install scale_rb
 
-## Usage
+## Run examples
 
-TODO: Write usage instructions here
+```bash
+git clone https://github.com/wuminzhe/scale_rb.git
+cd scale_rb
+bundle install
+bundle exec ruby examples/http_client_1.rb
+```
 
 ## Development
 

data/examples/http_client_1.rb

@@ -0,0 +1,9 @@
+
+require 'scale_rb'
+
+ScaleRb.logger.level = Logger::DEBUG
+
+client = ScaleRb::HttpClient.new('https://polkadot-rpc.dwellir.com')
+block_hash = client.chain_getBlockHash(21585684)
+runtime_version = client.state_getRuntimeVersion(block_hash)
+puts runtime_version

data/examples/http_client_2.rb

@@ -0,0 +1,9 @@
+require 'scale_rb'
+
+ScaleRb.logger.level = Logger::DEBUG
+
+client = ScaleRb::HttpClient.new('https://polkadot-rpc.dwellir.com')
+block_number = 21585684
+block_hash = client.chain_getBlockHash(block_number)
+storage = client.get_storage(block_hash, 'System', 'Events')
+puts "block #{block_number}(#{block_hash}) has #{storage.length} events"

data/examples/ws_client_1.rb

@@ -0,0 +1,14 @@
+require 'scale_rb'
+
+ScaleRb.logger.level = Logger::DEBUG
+
+# the commented code below is the same as the code above
+ScaleRb::WsClient.start('wss://polkadot-rpc.dwellir.com') do |client|
+  block_hash = client.chain_getBlockHash(21585684)
+  # block_hash = client.request('chain_getBlockHash', [21585684])
+
+  runtime_version = client.state_getRuntimeVersion(block_hash)
+  # runtime_version = client.request('state_getRuntimeVersion', [block_hash])
+
+  puts runtime_version
+end

data/examples/ws_client_2.rb

@@ -0,0 +1,9 @@
+require 'scale_rb'
+
+ScaleRb.logger.level = Logger::DEBUG
+
+ScaleRb::WsClient.start('wss://polkadot-rpc.dwellir.com') do |client|
+  client.chain_subscribeNewHead do |head|
+    puts "Received new head at height: #{head['number'].to_i(16)}"
+  end
+end

data/examples/ws_client_3.rb

@@ -0,0 +1,21 @@
+require 'scale_rb'
+
+ScaleRb.logger.level = Logger::DEBUG
+
+ScaleRb::WsClient.start('wss://polkadot-rpc.dwellir.com') do |client|
+  count = 0
+
+  subscription_id = client.chain_subscribeNewHead do |head|
+    count = count + 1
+
+    if count < 5
+      block_number = head['number'].to_i(16)
+      block_hash = client.chain_getBlockHash(block_number)
+      puts "Received new head at height: #{block_number}, block hash: #{block_hash}"
+    else
+      client.chain_unsubscribeNewHead(subscription_id)
+    end
+  end
+
+  puts "Subscribed to new heads with subscription id: #{subscription_id}"
+end

data/examples/ws_client_4.rb

@@ -0,0 +1,13 @@
+require 'scale_rb'
+
+# ScaleRb.logger.level = Logger::DEBUG
+
+ScaleRb::WsClient.start('wss://polkadot-rpc.dwellir.com') do |client|
+  client.chain_subscribeFinalizedHeads do |head|
+    block_number = head['number'].to_i(16)
+    block_hash = client.chain_getBlockHash(block_number)
+
+    storage = client.get_storage(block_hash, 'System', 'Events')
+    puts "block #{block_number}(#{block_hash}) has #{storage.length} events"
+  end
+end

data/lib/client/client_ext.rb

@@ -0,0 +1,214 @@
+module ScaleRb
+  module ClientExt
+    def get_metadata(block_hash)
+      dir = ENV['SCALE_RB_METADATA_DIR'] || File.join(Dir.pwd, 'metadata')
+
+      get_metadata_by_block_hash(dir, block_hash)
+    end
+
+    # get storage at block_hash
+    def get_storage(block_hash, pallet_name, storage_name, key_part1: nil, key_part2: nil)
+      metadata = get_metadata(block_hash)
+
+      # storeage item
+      pallet_name = to_pascal pallet_name
+      storage_name = to_pascal storage_name
+
+      # storage param
+      key = [key_part1, key_part2].compact
+      ScaleRb.logger.debug "#{pallet_name}.#{storage_name}(#{key.join(', ')})"
+      key = key.map { |part_of_key| c(part_of_key) }
+      ScaleRb.logger.debug "converted key: #{key}"
+
+      get_storage2(
+        block_hash, # at
+        pallet_name,
+        storage_name,
+        key,
+        metadata
+      )
+    end
+
+    private
+
+    def get_metadata_by_block_hash(cache_dir, block_hash)
+      # Get metadata from cache if it exists
+      runtime_version = state_getRuntimeVersion(block_hash)
+      spec_name = runtime_version['specName']
+      spec_version = runtime_version['specVersion']
+      metadata = cached_metadata(spec_name, spec_version, cache_dir)
+      return metadata if metadata
+
+      # Get metadata from node
+      metadata_hex = state_getMetadata(block_hash)
+      metadata = ScaleRb::Metadata.decode_metadata(metadata_hex.strip._to_bytes)
+
+      # cache it
+      save_metadata_to_file(spec_name, spec_version, metadata, cache_dir)
+
+      return metadata
+    end
+
+    def cached_metadata(spec_name, spec_version, dir)
+      file_path = File.join(dir, "#{spec_name}-#{spec_version}.json")
+      return unless File.exist?(file_path)
+
+      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 query_storage_at(block_hash, storage_keys, type_id, default, registry)
+      result = state_queryStorageAt(storage_keys, block_hash)
+      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(block_hash, partial_storage_key, start_key = nil)
+      storage_keys = state_getKeysPaged(partial_storage_key, 1000, start_key, block_hash)
+      if storage_keys.length == 1000
+        storage_keys + get_storage_keys_by_partial_key(block_hash, partial_storage_key, storage_keys.last)
+      else
+        storage_keys
+      end
+    end
+
+    def get_storages_by_partial_key(block_hash, partial_storage_key, type_id_of_value, default, registry)
+      storage_keys = get_storage_keys_by_partial_key(block_hash, partial_storage_key, partial_storage_key)
+      storage_keys.each_slice(250).map do |slice|
+        query_storage_at(
+          slice,
+          type_id_of_value,
+          default,
+          registry,
+          block_hash
+        )
+      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_storage1(block_hash, pallet_name, item_name, key, value, registry)
+      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(
+            block_hash,
+            partial_storage_key,
+            value[:type],
+            value[:modifier] == 'Default' ? value[:fallback] : nil,
+            registry
+          )
+        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(
+            block_hash,
+            partial_storage_key,
+            value[:type],
+            value[:modifier] == 'Default' ? value[:fallback] : nil,
+            registry
+          )
+        end
+      else
+        storage_key = StorageHelper.encode_storage_key(pallet_name, item_name, key, registry)._to_hex
+        data = state_getStorage(storage_key, block_hash)
+        StorageHelper.decode_storage(data, value[:type], value[:modifier] == 'Optional', value[:fallback], registry)
+      end
+    end
+
+    def get_storage2(block_hash, pallet_name, item_name, value_of_key, metadata)
+      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_storage1(block_hash, pallet_name, item_name, key, value, registry)
+    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

data/lib/client/http_client.rb

@@ -3,65 +3,55 @@
 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
-  module HttpClient
-    extend RpcRequestBuilder
+require_relative 'client_ext'
 
-    class << self
-      def request(url, body)
-        ScaleRb.logger.debug "url: #{url}"
-        ScaleRb.logger.debug "body: #{body}"
-        uri = URI(url)
-        req = Net::HTTP::Post.new(uri, 'Content-Type' => 'application/json')
-        req.body = body
-        http = Net::HTTP.new(uri.host, uri.port)
-        http.use_ssl = true if uri.instance_of? URI::HTTPS
-        res = http.request(req)
+module ScaleRb
+  class HttpClient
+    include ClientExt
+    attr_accessor :supported_methods
 
-        raise res.class.name unless res.is_a?(Net::HTTPSuccess)
+    def initialize(url)
+      # check if the url is started with http or https
+      url_regex = %r{^https?://}
+      raise 'url format is not correct' unless url.match?(url_regex)
 
-        result = JSON.parse(res.body)
-        ScaleRb.logger.debug result
-        raise result['error']['message'] if result['error']
+      @uri = URI.parse(url)
+      @supported_methods = request('rpc_methods', [])['methods']
+    end
 
-        result['result']
-      rescue StandardError => e
-        ScaleRb.logger.error e.message
-        ScaleRb.logger.error 'retry...'
-        sleep 2
-        request(url, body)
+    def request(method, params = [])
+      # don't check for rpc_methods, because there is no @supported_methods when initializing
+      if method != 'rpc_methods' && !@supported_methods.include?(method)
+        raise "Method `#{method}` is not supported. It should be in [#{@supported_methods.join(', ')}]."
       end
 
-      def json_rpc_call(url, method, *params)
-        body = build_json_rpc_body(method, params, Time.now.to_i)
-        request(url, body)
-      end
+      http = Net::HTTP.new(@uri.host, @uri.port)
+      http.use_ssl = @uri.scheme == 'https'
 
-      def respond_to_missing?(*_args)
-        true
-      end
+      request = Net::HTTP::Post.new(@uri, 'Content-Type' => 'application/json')
+      request.body = { jsonrpc: '2.0', method: method, params: params, id: Time.now.to_i }.to_json
+      ScaleRb.logger.debug "Request: #{request.body}"
 
-      def method_missing(method, *args)
-        ScaleRb.logger.debug "#{method}(#{args.join(', ')})"
-        # check if the first argument is a url
-        url_regex = %r{^https?://}
-        raise 'url format is not correct' unless args[0].match?(url_regex)
+      # https://docs.ruby-lang.org/en/master/Net/HTTPResponse.html
+      response = http.request(request)
+      raise response unless response.is_a?(Net::HTTPOK)
 
-        url = args[0]
-        raise NoMethodError, "undefined rpc method `#{method}'" unless rpc_methods(url).include?(method.to_s)
+      body = JSON.parse(response.body)
+      ScaleRb.logger.debug "Response: #{body}"
+      raise body['error'] if body['error']
 
-        json_rpc_call(url, method, *args[1..])
-      end
+      body['result']
+    end
 
-      def rpc_methods(url)
-        result = json_rpc_call(url, 'rpc_methods', [])
-        result['methods']
-      end
+    def respond_to_missing?(*_args)
+      true
+    end
+
+    def method_missing(method, *args)
+      ScaleRb.logger.debug "#{method}(#{args.join(', ')})"
+
+      request(method.to_s, args)
     end
   end
-end
+end