scale_rb 0.1.4 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 04c1447c216cac863ad108d269030a8f3d180d1666c2bba347efad2fa7939335
-  data.tar.gz: bc3b74a6e4ed311491e0369d2b73ae3ac5ab98d430df311257385503db6b70d7
+  metadata.gz: f83289d7a27bca72fe9e21e43f2b06ff29e191e47b9e1397cb96ea1adf6ee6c0
+  data.tar.gz: a1e77aaffcbc32aa795cb9cd57303f71a3fc1477c42e2540034d9060dc88a415
 SHA512:
-  metadata.gz: fac868163255299dcba6094edbe98daed394ede7130262bebf449befc21cdb921e52f1b0a455ae61d46547fa30d28af6927705ed99ae8b7035025d095527f9d4
-  data.tar.gz: 4f9394ab7bb01d73d96e160c4b0c76dae593dd7331e9a276a090e9a7d03060085763c378f5ab0bba5daf64d5bc62b0f4ae0e054d406905c549f8b667d7db7e43
+  metadata.gz: 26a88e5148bd175700d992542ea490dfd97b298b24dd8a6955fa24e276c12a8018b914c9c2f321b59cce4d8be24ceda7674814a83495a6079bebef43f8407d7a
+  data.tar.gz: 74e818ab1e4d56caac4b78de0e15545b53e86361a5557fa72eae7e8310dec0b09a101590551e5b6d5b218d41c690e6eaea6221a84a93a14c904620724390aaf0

data/.gitignore

@@ -6,6 +6,7 @@
 /pkg/
 /spec/reports/
 /tmp/
+/.idea/
 
 # rspec failure tracking
 .rspec_status

data/Gemfile.lock

@@ -1,14 +1,14 @@
 PATH
   remote: .
   specs:
-    scale_rb (0.1.4)
-      blake2b_rs (~> 0.1.2)
+    scale_rb (0.1.5)
+      blake2b_rs (~> 0.1.4)
       xxhash
 
 GEM
   remote: https://rubygems.org/
   specs:
-    blake2b_rs (0.1.3)
+    blake2b_rs (0.1.4)
       ffi (~> 1.0)
       thermite (~> 0)
     diff-lcs (1.5.0)

data/README.md

@@ -2,6 +2,9 @@
 
 *WARNING: UNDER DEVELOPMENT*
 
+* Only support metadata v14.
+* Http & WebSocket client helper. No Client in this repo.
+
 ## Installation
 
 Add this line to your application's Gemfile:

data/exe/metadata

@@ -6,7 +6,7 @@ require 'json'
 require 'optparse'
 
 def print_metadata(url, at = nil)
-  puts JSON.pretty_generate(Substrate::Client.get_metadata(url, at))
+  puts JSON.pretty_generate(HttpClient.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 = Substrate::RPC.chain_getBlockHash url, block_number
+      block_hash = HttpClient.chain_getBlockHash url, block_number
     end
   else
-    block_hash = Substrate::RPC.chain_getBlockHash url
+    block_hash = HttpClient.chain_getBlockHash url
   end
 
   print_metadata url, block_hash

data/lib/client/abstract_ws_client.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+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
+
+  # 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
+
+        metadata_hex = resp['result']
+        metadata = Metadata.decode_metadata(metadata_hex.strip.to_bytes)
+        return unless metadata
+
+        @metadata = metadata
+        @registry = Metadata.build_registry(@metadata)
+      end
+    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
+
+  private
+
+  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)
+    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
+
+      @subscription_callbacks[resp['result']] = [
+        pallet_name,
+        item_name,
+        subscription_callback
+      ]
+    end
+  end
+end

data/lib/{substrate/client.rb → client/http_client.rb}

@@ -1,15 +1,49 @@
 # frozen_string_literal: true
 
-module Substrate
-  module Client
+require 'uri'
+require 'net/http'
+require 'json'
+
+module ScaleRb
+  module HttpClient
+    extend RpcRequestBuilder
+
     class << self
+      def request(url, 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)
+        # puts res unless res.is_a?(Net::HTTPSuccess)
+
+        result = JSON.parse(res.body)
+        raise result['error'] if result['error']
+
+        result['result']
+      end
+
+      def json_rpc_call(url, method, *params)
+        body = build_json_rpc_body(method, params, Time.now.to_i)
+        request(url, body)
+      end
+
+      def respond_to_missing?(*_args)
+        true
+      end
+
+      def method_missing(method, *args)
+        json_rpc_call(args[0], method, *args[1..])
+      end
+
       def get_metadata(url, at = nil)
-        hex = Substrate::RPC.state_getMetadata(url, at)
+        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 = Substrate::RPC.state_queryStorageAt(url, storage_keys, at)
+        result = state_queryStorageAt(url, storage_keys, at)
         result.map do |item|
           item['changes'].map do |change|
             storage_key = change[0]
@@ -21,7 +55,7 @@ module Substrate
       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)
+        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
@@ -43,14 +77,6 @@ module Substrate
         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: '' }
@@ -78,7 +104,7 @@ module Substrate
       #   },
       #   ..
       #
-      def get_storage2(url, pallet_name, item_name, key, value, registry, at = nil)
+      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.nil? && key[:value].nil?
           partial_storage_key = StorageHelper.encode_storage_key(pallet_name, item_name).to_hex
@@ -91,20 +117,13 @@ module Substrate
             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
-          )
+          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_storage3(url, pallet_name, item_name, value_of_key, metadata, at = nil)
+      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)
@@ -116,6 +135,7 @@ module Substrate
 
         plain = type._get(:plain)
         map = type._get(:map)
+
         key, value =
           if plain
             [
@@ -130,8 +150,8 @@ module Substrate
           else
             raise 'NoSuchStorageType'
           end
-        get_storage2(url, pallet_name, item_name, key, value, registry, at)
+        get_storage(url, pallet_name, item_name, key, value, registry, at)
       end
     end
   end
-end
+end

data/lib/client/rpc_request_builder.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+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
+
+  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
+
+  ###################################
+  # 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_eth_call(rpc_id, to, data, at = nil)
+    eth_call(
+      rpc_id,
+      [
+        {
+          'from' => nil, 'to' => to, 'data' => data
+        },
+        at
+      ]
+    )
+  end
+end

data/lib/metadata/metadata.rb

@@ -15,10 +15,10 @@ module Metadata
     end
 
     def get_storage_item(pallet_name, item_name, metadata)
-      raise ScaleRb::NotImplemented, metadata._get(:metadata).keys.first unless metadata._get(:metadata)._key?(:v14)
+      version = metadata._get(:metadata).keys.first
+      raise ScaleRb::NotImplemented, metadata._get(:metadata).keys.first unless %w[v9 v10 v11 v12 v13 v14].include?(version.to_s)
 
-      metadata_v14 = metadata._get(:metadata)._get(:v14)
-      MetadataV14.get_storage_item(pallet_name, item_name, metadata_v14)
+      Metadata.const_get("Metadata#{version.upcase}").get_storage_item(pallet_name, item_name, metadata)
     end
   end
 

data/lib/monkey_patching.rb

@@ -108,6 +108,8 @@ class Hash
       self[key] || self[key.to_sym]
     elsif key.instance_of?(Symbol)
       self[key] || self[key.to_s]
+    else
+      self[key]
     end
   end
 end

data/lib/portable_codec.rb

@@ -81,37 +81,41 @@ module PortableCodec
     def decode_composite(composite_type, bytes, registry)
       fields = composite_type._get(:fields)
 
-      type_name_list = fields.map { |f| f._get(:name) }
-      type_id_list = fields.map { |f| f._get(:type) }
-
-      type_value_list, remaining_bytes = _decode_types(type_id_list, bytes, registry)
-      [
-        if type_name_list.all?(&:nil?)
-          type_value_list
-        else
-          [type_name_list.map(&:to_sym), type_value_list].transpose.to_h
-        end,
-        remaining_bytes
-      ]
+      # reduce composite level when composite only has one field without name
+      if fields.length == 1 && fields.first._get(:name).nil?
+        decode(fields.first._get(:type), bytes, registry)
+      else
+        type_name_list = fields.map { |f| f._get(:name) }
+        type_id_list = fields.map { |f| f._get(:type) }
+
+        type_value_list, remaining_bytes = _decode_types(type_id_list, bytes, registry)
+        [
+          if type_name_list.all?(&:nil?)
+            type_value_list
+          else
+            [type_name_list.map(&:to_sym), type_value_list].transpose.to_h
+          end,
+          remaining_bytes
+        ]
+      end
     end
 
     def decode_variant(variant_type, bytes, registry)
       variants = variant_type._get(:variants)
 
       index = bytes[0]
-      if index > (variants.length - 1)
-        raise VariantIndexOutOfRange,
-              "type: #{variant_type}, index: #{index}, bytes: #{bytes}"
-      end
+      item = variants.find { |v| v._get(:index) == index } # item is an composite
 
-      item_variant = variants.find { |v| v._get(:index) == index }
-      item_name = item_variant._get(:name)
-      item, remaining_bytes = decode_composite(item_variant, bytes[1..], registry)
+      raise VariantIndexOutOfRange, "type: #{variant_type}, index: #{index}, bytes: #{bytes}" if item.nil?
 
-      [
-        item.empty? ? item_name : { item_name.to_sym => item },
-        remaining_bytes
-      ]
+      item_name = item._get(:name)
+      item_fields = item._get(:fields)
+      if item_fields.empty?
+        [item_name, bytes[1..]]
+      else
+        item_value, remaining_bytes = decode_composite(item, bytes[1..], registry)
+        [{ item_name.to_sym => item_value }, remaining_bytes]
+      end
     end
 
     def _decode_types(ids, bytes, registry = {})
@@ -181,18 +185,23 @@ module PortableCodec
     #   or
     #   [value1, value2, ...]
     def encode_composite(composite_type, value, registry)
-      values =
-        if value.instance_of?(Hash)
-          value.values
-        elsif value.instance_of?(Array)
-          value
-        else
-          raise CompositeInvalidValue, "value: #{value}, only hash and array"
-        end
-
       fields = composite_type._get(:fields)
-      type_id_list = fields.map { |f| f._get(:type) }
-      _encode_types(type_id_list, values, registry)
+      # reduce composite level when composite only has one field without name
+      if fields.length == 1 && fields.first._get(:name).nil?
+        encode(fields.first._get(:type), value, registry)
+      else
+        values =
+          if value.instance_of?(Hash)
+            value.values
+          elsif value.instance_of?(Array)
+            value
+          else
+            raise CompositeInvalidValue, "value: #{value}, only hash and array"
+          end
+
+        type_id_list = fields.map { |f| f._get(:type) }
+        _encode_types(type_id_list, values, registry)
+      end
     end
 
     # value:
@@ -213,11 +222,11 @@ module PortableCodec
           raise VariantInvalidValue, "type: #{variant_type}, value: #{value}"
         end
 
-      variant = variants.find { |var| var._get(:name) == name }
-      raise VariantItemNotFound, "type: #{variant_type}, name: #{name}" if variant.nil?
-      raise VariantInvalidValue, "type: #{variant_type}, v: #{v}" if variant._get(:fields).length != v.length
+      item = variants.find { |var| var._get(:name) == name }
+      raise VariantItemNotFound, "type: #{variant_type}, name: #{name}" if item.nil?
+      raise VariantInvalidValue, "type: #{variant_type}, v: #{v}" if item._get(:fields).length != v.length
 
-      ScaleRb.encode_uint('u8', variant._get(:index)) + encode_composite(variant, v, registry)
+      ScaleRb.encode_uint('u8', item._get(:index)) + encode_composite(item, v, registry)
     end
 
     def _encode_types(ids, values, registry)

data/lib/scale_rb/version.rb

@@ -1,3 +1,3 @@
 module ScaleRb
-  VERSION = '0.1.4'
+  VERSION = '0.1.5'
 end

data/lib/scale_rb.rb

@@ -21,8 +21,9 @@ require 'hasher'
 require 'storage_helper'
 
 # client
-require 'substrate/rpc'
-require 'substrate/client'
+require 'client/rpc_request_builder'
+require 'client/http_client'
+require 'client/abstract_ws_client'
 
 # get registry from config
 require 'registry'

data/lib/storage_helper.rb

@@ -2,37 +2,56 @@
 
 module StorageHelper
   class << self
-    # params:
-    #   pallet_name: module name
-    #   method_name: storage name
-    #   params: {
-    #     values: values,
-    #     type_ids: type_ids,
-    #     hashers: hashers,
-    #   }
-    #   registry: portable_types_registry
-    def encode_storage_key(pallet_name, method_name, params = nil, registry = nil)
-      pallet_method_key = Hasher.twox128(pallet_name) + Hasher.twox128(method_name)
+    # key: {
+    #   value: ,
+    #   type: ,
+    #   hashers: []
+    # }
+    def encode_storage_key(pallet_name, item_name, key = nil, registry = nil)
+      storage_key = Hasher.twox128(pallet_name) + Hasher.twox128(item_name)
 
-      if params.nil?
-        pallet_method_key
-      else
-        values = params[:values]
-        type_ids = params[:type_ids]
-        hashers = params[:hashers]
+      if key && registry
+
+        types, values =
+          if key[:hashers].length == 1
+            [
+              [key[:type]],
+              [key[:value]]
+            ]
+          else
+            [
+              registry[key[:type]]._get(:def)._get(:tuple),
+              key[:value]
+            ]
+          end
 
-        pallet_method_key + PortableCodec._encode_types_with_hashers(type_ids, values, registry, hashers)
+        storage_key + PortableCodec._encode_types_with_hashers(types, values, registry, key[:hashers])
+      else
+        storage_key
       end
     end
 
-    def build_params(param_values, storage_key_type_id, hashers, registry)
-      type_ids = registry._get(storage_key_type_id)._get(:def)._get(:tuple)
-      type_ids = [storage_key_type_id] if type_ids.nil?
-      {
-        values: param_values,
-        type_ids: type_ids,
-        hashers: hashers
-      }
+    # data: hex string
+    # type: portable type id
+    # optional: boolean
+    # fallback: hex string
+    def decode_storage(data, type, optional, fallback, registry)
+      data ||= (optional ? nil : fallback)
+      PortableCodec.decode(type, data.to_bytes, registry)[0]
+    end
+
+    # storage_item: the storage item from metadata
+    def decode_storage2(data, storage_item, registry)
+      modifier = storage_item._get(:modifier) # Default | Optional
+      fallback = storage_item._get(:fallback)
+      type = storage_item._get(:type)._get(:plain) || storage_item._get(:type)._get(:map)._get(:value)
+      decode_storage(data, type, modifier == 'Optional', fallback, registry)
+    end
+
+    def decode_storage3(data, pallet_name, item_name, metadata)
+      registry = Metadata.build_registry(metadata)
+      storage_item = Metadata.get_storage_item(pallet_name, item_name, metadata)
+      decode_storage2(data, storage_item, registry)
     end
   end
 end

data/scale_rb.gemspec

@@ -26,6 +26,6 @@ Gem::Specification.new do |spec|
   spec.require_paths = ['lib']
 
   # for hashers
-  spec.add_dependency 'blake2b_rs', '~> 0.1.2'
+  spec.add_dependency 'blake2b_rs', '~> 0.1.4'
   spec.add_dependency 'xxhash'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: scale_rb
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.5
 platform: ruby
 authors:
 - Aki Wu
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-10-13 00:00:00.000000000 Z
+date: 2023-03-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: blake2b_rs
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.2
+        version: 0.1.4
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.2
+        version: 0.1.4
 - !ruby/object:Gem::Dependency
   name: xxhash
   requirement: !ruby/object:Gem::Requirement
@@ -59,6 +59,9 @@ files:
 - bin/console
 - bin/setup
 - exe/metadata
+- lib/client/abstract_ws_client.rb
+- lib/client/http_client.rb
+- lib/client/rpc_request_builder.rb
 - lib/codec.rb
 - lib/hasher.rb
 - lib/metadata/metadata.rb
@@ -74,8 +77,6 @@ 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:
@@ -98,7 +99,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
+rubygems_version: 3.3.7
 signing_key:
 specification_version: 4
 summary: New Ruby SCALE Codec Library

data/lib/substrate/rpc.rb

@@ -1,70 +0,0 @@
-# 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