substrate_client.rb 0.1.5 → 0.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6ffef7ed87e2488047c796e8a77cc3e0789f532891a69283f6339b9dc55e899d
-  data.tar.gz: '08806295aaf4ced6714042496be2a54408fc4c1ba8d5bebbfe352b431407ec02'
+  metadata.gz: 7a1478123f2f6a7365eab00d5bf908d93902c2b058d058207b9ed12531dc6f7a
+  data.tar.gz: d2df429bec159846b09646e91daa6f1050c2e1d206ed3f2c6347ad4240da8095
 SHA512:
-  metadata.gz: ede3bdec9f513b5586f8d9404c2f55e8ab70d53cb70e8f87920da8ecaab5f605542bf1f5fef4137d267088f11591abf1b1624530f9e97f01d779c60015c876ff
-  data.tar.gz: 967fa99d7887a30bade8a3914cfed8496a0a821f9ffc101405608b941fb406418fcacbd95be499ed6cd28960b0eadc9b1c98e733828783814e58f5ea44b18336
+  metadata.gz: 882b6345105fa751c1c42f3b5ffcc86872ba47e261a6598a1c094bc5332f7632b8238829c7d8ca261244ba4c3b0e797b82f937878a3172c2f104cfe1ba545721
+  data.tar.gz: 271d1ebb55ac8686eb9d047eb6b38f00b08f465fed392ec5d79f56b492b8bf303647913ef53b25b1c167f119b37b439cea6eb0fb1bd5b6aa62eb3e59f363de2f

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    substrate_client.rb (0.1.5)
+    substrate_client.rb (0.1.6)
       activesupport (~> 5.2.4)
       eventmachine (~> 1.2.7)
       faye-websocket (~> 0.10.9)

data/README.md

@@ -28,61 +28,77 @@ Or install it yourself as:
 require "substrate_client"
 
 client = SubstrateClient.new("wss://kusama-rpc.polkadot.io/")
-puts client.method_list
+client.method_list do |methods|
+  p methods
+end
 ```
 The rpc methods can be dynamically called by its name, so the methods returned by this method can all be used.
 
-#### hard-coded rpc method
+
+
+#### rpc methods
 
 But, in order to show the parameters more clearly, some important or frequently used methods are hard-coded:
 
-- chain_get_finalised_head
+- chain_get_finalised_head(&callback)
 
   Get hash of the last finalized block in the canon chain
 
+  ```ruby
+  client.chain_get_finalised_head do |head|
+    p head 
+  end
+  ```
+
   
 
-- chain_get_head
+- chain_get_head(&callback)
+
+  Retrieves the header
 
-- chain_get_header(block_hash = nil)
+  
+
+- chain_get_header(block_hash = nil, &callback)
 
   Retrieves the header for a specific block
 
   
 
-- chain_get_block(block_hash = nil)
+- chain_get_block(block_hash = nil, &callback)
 
   Get header and body of a relay chain block
 
   
 
-- chain_get_block_hash(block_id)
+- chain_get_block_hash(block_id, &callback)
 
   Get the block hash for a specific block
 
   
 
-- chain_get_runtime_version(block_hash = nil)
+- chain_get_runtime_version(block_hash = nil, &callback)
 
   Get the runtime version for a specific block
 
   
 
-- state_get_metadata(block_hash = nil)
+- state_get_metadata(block_hash = nil, &callback)
 
   Returns the runtime metadata by block
 
   
 
-- state_get_storage(storage_key, block_hash = nil)
+- state_get_storage(storage_key, block_hash = nil, &callback)
 
   Retrieves the storage for a key
 
   
 
-- system_name
+- system_name(&callback)
+
+  
 
-- system_version
+- system_version(&callback)
 
   
 
@@ -110,19 +126,10 @@ But, in order to show the parameters more clearly, some important or frequently
 
   Retrieves the best header via subscription. This will return data continuously until you unsubscribe the subscription.
 
-  ```ruby
-  subscription = client.chain_subscribe_new_heads do |data|
-    p data
-  end
-  ```
-
 - chain_unsubscribe_new_heads(subscription)
 
   Unsubscribe the best header subscription.
 
-  ```ruby
-  client.chain_unsubscribe_new_heads(subscription)
-  ```
 
 
 
@@ -130,22 +137,12 @@ But, in order to show the parameters more clearly, some important or frequently
 
   Retrieves the best finalized header via subscription. This will return data continuously until you unsubscribe the subscription.
 
-  ```ruby
-  subscription = client.chain_subscribe_finalized_heads do |data|
-    p data
-  end
-  ```
-
 - chain_unsubscribe_finalized_heads(subscription)
 
   Unsubscribe the best finalized header subscription.
 
-  ```ruby
-  client.chain_unsubscribe_finalized_heads(subscription)
-  ```
-
   
-
+  
 - state_subscribe_runtime_version(&callback)
 
   Retrieves the runtime version via subscription. 
@@ -175,33 +172,57 @@ But, in order to show the parameters more clearly, some important or frequently
 
 These methods will encode the parameters and decode the returned data
 
-- get_block_number(block_hash)
+- get_block_number(block_hash, &callback)
 
-- get_metadata(block_hash)
+- get_metadata(block_hash, &callback)
 
-- get_block(block_hash=nil)
+- get_block(block_hash=nil, &callback)
 
-- get_block_events(block_hash)
+- get_block_events(block_hash, &callback)
 
-- subscribe_block_events(&callback)
+- subscribe_block_events(&callback, &callback)
 
-- get_storage(module_name, storage_name, params = nil, block_hash = nil)
+- get_storage(module_name, storage_name, params = nil, block_hash = nil, &callback)
 
   ```ruby
-  client.get_storage("Sudo", "Key")
-  client.get_storage("Balances", "TotalIssuance")
-  client.get_storage("System", "Account", ["0xd43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d"])
-  client.get_storage("ImOnline", "AuthoredBlocks", [2818, "0x749ddc93a65dfec3af27cc7478212cb7d4b0c0357fef35a0163966ab5333b757"])
+  client.get_storage("Balances", "TotalIssuance", nil, nil) do |storage|
+    p storage
+  end
+  
+  client.get_storage("System", "Account", ["0xd43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d"], nil) do |storage|
+    p storage
+  end
+  
+  client.get_storage("ImOnline", "AuthoredBlocks", [2818, "0x749ddc93a65dfec3af27cc7478212cb7d4b0c0357fef35a0163966ab5333b757"], nil) do |storage|
+    p storage
+  end
   ```
 
-- compose_call(module_name, call_name, params, block_hash=nil)
+- compose_call(module_name, call_name, params, block_hash=nil, &callback)
 
   ```ruby
-  compose_call "Balances", "Transfer", { dest: "0x586cb27c291c813ce74e86a60dad270609abf2fc8bee107e44a80ac00225c409", value: 1_000_000_000_000 }
+  compose_call "Balances", "Transfer", { dest: "0x586cb27c291c813ce74e86a60dad270609abf2fc8bee107e44a80ac00225c409", value: 1_000_000_000_000 }, nil do |hex|
+    p hex
+  end
   ```
 
 
 
+## Synchronized client
+
+There is also a synchronized version of the client, which is disconnected every time the data is retrieved. It is very convenient in some situations. But this version cannot use the subscription interface.
+
+```ruby
+client = SubstrateClientSync.new "wss://kusama-rpc.polkadot.io/"
+p client.method_list
+p client.chain_get_head
+p client.chain_get_finalised_head
+p client.chain_get_header(block_hash = nil)
+...
+```
+
+
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/exe/metadata

@@ -3,11 +3,10 @@
 require "substrate_client"
 require "json"
 
-# metadata url block_hash
-url = ARGV[0] || "wss://cc3-5.kusama.network/"
-block_hash = ARGV[1]
+url = ARGV[0] || "wss://kusama-rpc.polkadot.io/"
+client = SubstrateClientSync.new(url)
+
+block_hash = ARGV[1] || client.chain_get_finalised_head
 
-client = SubstrateClient.new(url)
-client.init(block_hash)
 metadata = client.get_metadata(block_hash)
-puts JSON.pretty_generate(metadata.value)
+puts JSON.pretty_generate(metadata.value.to_human)

data/lib/helper.rb

@@ -0,0 +1,129 @@
+
+class SubstrateClient::Helper
+  class << self
+    def generate_storage_hash_from_metadata(metadata, module_name, storage_name, params = nil)
+      # find the storage item from metadata
+      metadata_modules = metadata.value.value[:metadata][:modules]
+      metadata_module = metadata_modules.detect { |mm| mm[:name] == module_name }
+      raise "Module '#{module_name}' not exist" unless metadata_module
+      storage_item = metadata_module[:storage][:items].detect { |item| item[:name] == storage_name }
+      raise "Storage item '#{storage_name}' not exist. \n#{metadata_module.inspect}" unless storage_item
+
+      if storage_item[:type][:Plain]
+        return_type = storage_item[:type][:Plain]
+      elsif map = storage_item[:type][:Map]
+        raise "Storage call of type \"Map\" requires 1 parameter" if params.nil? || params.length != 1
+
+        hasher = map[:hasher]
+        return_type = map[:value]
+        # TODO: decode to account id if param is address
+        # params[0] = decode(params[0]) if map[:key] == "AccountId"
+        params[0] = Scale::Types.get(map[:key]).new(params[0]).encode
+      elsif map = storage_item[:type][:DoubleMap]
+        raise "Storage call of type \"DoubleMapType\" requires 2 parameters" if params.nil? || params.length != 2
+
+        hasher = map[:hasher]
+        hasher2 = map[:key2Hasher]
+        return_type = map[:value]
+        params[0] = Scale::Types.get(map[:key1]).new(params[0]).encode
+        params[1] = Scale::Types.get(map[:key2]).new(params[1]).encode
+      else
+        raise NotImplementedError
+      end
+
+      storage_hash = generate_storage_hash(
+        module_name,
+        storage_name,
+        params,
+        hasher,
+        hasher2,
+        metadata.value.value[:metadata][:version]
+      )
+      [storage_hash, return_type]
+    end
+
+    def generate_storage_hash(module_name, storage_name, params = nil, hasher = nil, hasher2 = nil, metadata_version = nil)
+      if metadata_version and metadata_version >= 9
+        storage_hash = Crypto.twox128(module_name) + Crypto.twox128(storage_name)
+
+        params&.each_with_index do |param, index|
+          if index == 0
+            param_hasher = hasher
+          elsif index == 1
+            param_hasher = hasher2
+          else
+            raise "Unexpected third parameter for storage call"
+          end
+
+          param_key = param.hex_to_bytes
+          param_hasher = "Twox128" if param_hasher.nil?
+          storage_hash += Crypto.send param_hasher.underscore, param_key
+        end
+
+        "0x#{storage_hash}"
+      else
+        # TODO: add test
+        storage_hash = module_name + " " + storage_name
+
+        unless params.nil?
+          params = [params] if params.class != ::Array
+          params_key = params.join("")
+          hasher = "Twox128" if hasher.nil?
+          storage_hash += params_key.hex_to_bytes.bytes_to_utf8 
+        end
+
+        "0x#{Crypto.send( hasher.underscore, storage_hash )}"
+      end
+    end
+
+    def compose_call_from_metadata(metadata, module_name, call_name, params)
+      call = metadata.get_module_call(module_name, call_name)
+
+      value = {
+        call_index: call[:lookup],
+        module_name: module_name,
+        call_name: call_name,
+        params: []
+      }
+
+      params.keys.each_with_index do |call_param_name, i|
+        param_value = params[call_param_name]
+        value[:params] << {
+          name: call_param_name.to_s,
+          type: call[:args][i][:type],
+          value: param_value
+        }
+      end
+
+      Scale::Types::Extrinsic.new(value).encode
+    end
+
+    def decode_block(block)
+      block["block"]["header"]["number"] = block["block"]["header"]["number"].to_i(16)
+
+      block["block"]["extrinsics"].each_with_index do |hex, i|
+        scale_bytes = Scale::Bytes.new(hex)
+        block["block"]["extrinsics"][i] = Scale::Types::Extrinsic.decode(scale_bytes).to_human
+      end
+
+      block['block']['header']["digest"]["logs"].each_with_index do |hex, i|
+        scale_bytes = Scale::Bytes.new(hex)
+        block['block']['header']["digest"]["logs"][i] = Scale::Types::LogDigest.decode(scale_bytes).to_human
+      end
+
+      block
+    end
+
+    # chain_unsubscribe_runtime_version
+    # => 
+    # chain_unsubscribeRuntimeVersion
+    def real_method_name(method_name)
+      segments = method_name.to_s.split("_")
+      if segments.length == 1
+        segments[0]
+      else
+        segments[0] + "_" + segments[1] + segments[2..].map(&:capitalize).join
+      end
+    end
+  end
+end

data/lib/substrate_client.rb

@@ -6,7 +6,9 @@ require "json"
 require "active_support"
 require "active_support/core_ext/string"
 require "websocket"
+require "helper"
 require "timeout_queue"
+require "substrate_client_sync"
 
 class SubstrateClient
   class RpcError < StandardError; end
@@ -28,15 +30,15 @@ class SubstrateClient
     Scale::TypeRegistry.instance.load(spec_name)
 
     init_ws
+
+    at_exit { self.close }
   end
 
   def close
     @ws.close
   end
 
-  def request(method, params, subscription_callback=nil)
-    queue = TimeoutQueue.new
-
+  def request(method, params, callback: nil, subscription_callback: nil)
     payload = {
       "jsonrpc" => "2.0",
       "method" => method,
@@ -44,193 +46,188 @@ class SubstrateClient
       "id" => @request_id
     }
 
-    @callbacks[@request_id] = proc { |data| queue << data }
-    @ws.send(payload.to_json)
-    @request_id += 1
-    data = queue.pop(true, 5)
-
-    if not subscription_callback.nil? && data["result"]
-      @subscription_callbacks[data["result"]] = subscription_callback
-    end
+    @callbacks[@request_id] = proc do |data| 
+      if not subscription_callback.nil? && data["result"]
+        @subscription_callbacks[data["result"]] = subscription_callback
+      end
 
-    if data["error"]
-      raise RpcError, data["error"]
-    else
-      data["result"]
+      callback.call data if callback
     end
-  rescue ThreadError => ex
-    raise RpcTimeout
+    @ws.send(payload.to_json)
+    @request_id += 1
   end
 
-  def init_runtime(block_hash: nil, block_id: nil)
-    if block_hash.nil? 
-      if not block_id.nil?
-        block_hash = self.chain_get_block_hash(block_id)
-      else
-        block_hash = self.chain_get_head
+  def init_runtime(block_hash=nil, &callback)
+    # set current runtime spec version
+    self.state_get_runtime_version(block_hash) do |runtime_version|
+      @spec_version = runtime_version["specVersion"]
+      Scale::TypeRegistry.instance.spec_version = @spec_version
+
+      # set current metadata
+      self.get_metadata(block_hash) do |metadata|
+        @metadata = metadata
+        Scale::TypeRegistry.instance.metadata = @metadata.value
+        callback.call
       end
     end
+  end
 
-    # set current runtime spec version
-    runtime_version = self.state_get_runtime_version(block_hash)
-    @spec_version = runtime_version["specVersion"]
-    Scale::TypeRegistry.instance.spec_version = @spec_version
-
-    # set current metadata
-    @metadata = self.get_metadata(block_hash)
-    Scale::TypeRegistry.instance.metadata = @metadata.value
-    true
+  def do_init_runtime(block_hash, &callback)
   end
 
-  def invoke(method, *params)
-    # params.reject! { |param| param.nil? }
-    request(method, params)
+  def invoke(method, params, callback)
+    request method, params, callback: proc { |data|
+      if data["error"]
+        Thread.main.raise RpcError, data["error"]
+      else
+        callback.call data["result"]
+      end
+    }
   end
 
   def rpc_method(method_name)
-    SubstrateClient.real_method_name(method_name.to_s)
+    Helper.real_method_name(method_name.to_s)
   end
 
   # ################################################
   # origin rpc methods
   # ################################################
-  def method_missing(method, *args)
-    rpc_method = SubstrateClient.real_method_name(method)
-    invoke rpc_method, *args
+  def method_missing(method, args, &callback)
+    rpc_method = Helper.real_method_name(method)
+    invoke rpc_method, args, callback
+  end
+
+  def state_get_runtime_version(block_hash=nil, &callback)
+    invoke rpc_method(__method__), [ block_hash ], callback
   end
 
-  def rpc_methods 
-    invoke rpc_method(__method__)
+  def rpc_methods(&callback)
+    invoke rpc_method(__method__), [], callback
   end
 
-  def chain_get_head
-    invoke rpc_method(__method__)
+  def chain_get_head(&callback)
+    invoke rpc_method(__method__), [], callback
   end
 
   def chain_get_finalised_head
-    invoke rpc_method(__method__)
+    invoke rpc_method(__method__), [], callback
   end
 
-  def chain_get_header(block_hash = nil)
-    invoke rpc_method(__method__), block_hash
+  def chain_get_header(block_hash = nil, &callback)
+    invoke rpc_method(__method__), [ block_hash ], callback
   end
 
-  def chain_get_block(block_hash = nil)
-    invoke rpc_method(__method__), block_hash
+  def chain_get_block(block_hash = nil, &callback)
+    invoke rpc_method(__method__), [ block_hash ], callback
   end
 
-  def chain_get_block_hash(block_id)
-    invoke rpc_method(__method__), block_id
+  def chain_get_block_hash(block_id, &callback)
+    invoke rpc_method(__method__), [ block_id ], callback
   end
 
-  def chain_get_runtime_version(block_hash = nil)
-    invoke rpc_method(__method__), block_hash
+  def chain_get_runtime_version(block_hash = nil, &callback)
+    invoke rpc_method(__method__), [ block_hash ], callback
   end
 
-  def state_get_metadata(block_hash = nil)
-    invoke rpc_method(__method__), block_hash
+  def state_get_metadata(block_hash = nil, &callback)
+    invoke rpc_method(__method__), [ block_hash ], callback
   end
 
-  def state_get_storage(storage_key, block_hash = nil)
-    invoke rpc_method(__method__), storage_key, block_hash
+  def state_get_storage(storage_key, block_hash = nil, &callback)
+    invoke rpc_method(__method__), [ storage_key, block_hash ], callback
   end
 
-  def system_name
-    invoke rpc_method(__method__)
+  def system_name(&callback)
+    invoke rpc_method(__method__), [], callback
   end
 
-  def system_version
-    invoke rpc_method(__method__)
+  def system_version(&callback)
+    invoke rpc_method(__method__), [], callback
   end
 
   def chain_subscribe_all_heads(&callback)
-    request rpc_method(__method__), [], callback
+    request rpc_method(__method__), [], subscription_callback: callback
   end
 
-  def chain_unsubscribe_all_heads(subscription)
-    invoke rpc_method(__method__), subscription
+  def chain_unsubscribe_all_heads(subscription, &callback)
+    invoke rpc_method(__method__), [ subscription ], callback
   end
 
   def chain_subscribe_new_heads(&callback)
-    request rpc_method(__method__), [], callback
+    request rpc_method(__method__), [], subscription_callback: callback
   end
 
-  def chain_unsubscribe_new_heads(subscription)
-    invoke rpc_method(__method__), subscription
+  def chain_unsubscribe_new_heads(subscription, &callback)
+    invoke rpc_method(__method__), [ subscription ], callback
   end
 
   def chain_subscribe_finalized_heads(&callback)
-    request rpc_method(__method__), [], callback
+    request rpc_method(__method__), [], subscription_callback: callback
   end
 
-  def chain_unsubscribe_finalized_heads(subscription)
-    invoke rpc_method(__method__), subscription
+  def chain_unsubscribe_finalized_heads(subscription, &callback)
+    invoke rpc_method(__method__), [ subscription ], callback
   end
 
   def state_subscribe_runtime_version(&callback)
-    request rpc_method(__method__), [], callback
+    request rpc_method(__method__), [], subscription_callback: callback
   end
 
-  def state_unsubscribe_runtime_version(subscription)
-    invoke rpc_method(__method__), subscription
+  def state_unsubscribe_runtime_version(subscription, &callback)
+    invoke rpc_method(__method__), [ subscription ], callback
   end
 
   def state_subscribe_storage(keys, &callback)
-    request rpc_method(__method__), [keys], callback
+    request rpc_method(__method__), [keys], subscription_callback: callback
   end
 
-  def state_unsubscribe_storage(subscription)
-    invoke rpc_method(__method__), subscription
+  def state_unsubscribe_storage(subscription, &callback)
+    invoke rpc_method(__method__), [ subscription ], callback
   end
 
   # ################################################
   # custom methods based on origin rpc methods
   # ################################################
-  def method_list
-    self.rpc_methods["methods"].map(&:underscore)
-  end
-
-  def get_block_number(block_hash)
-    header = self.chain_get_header(block_hash)
-    header["number"].to_i(16)
+  def method_list(&callback)
+    self.rpc_methods do |result|
+      callback.call result["methods"].map(&:underscore)
+    end
   end
 
-  def get_metadata(block_hash)
-    hex = self.state_get_metadata(block_hash)
-    Scale::Types::Metadata.decode(Scale::Bytes.new(hex))
+  def get_block_number(block_hash, &callback)
+    self.chain_get_header(block_hash) do |header|
+      callback.call header["number"].to_i(16)
+    end
   end
 
-  def get_block(block_hash=nil)
-    self.init_runtime(block_hash: block_hash)
-    block = self.chain_get_block(block_hash)
-
-    block["block"]["header"]["number"] = block["block"]["header"]["number"].to_i(16)
-
-    block["block"]["extrinsics"].each_with_index do |hex, i|
-      scale_bytes = Scale::Bytes.new(hex)
-      block["block"]["extrinsics"][i] = Scale::Types::Extrinsic.decode(scale_bytes).to_human
+  def get_metadata(block_hash=nil, &callback)
+    self.state_get_metadata(block_hash) do |hex|
+      callback.call Scale::Types::Metadata.decode(Scale::Bytes.new(hex))
     end
+  end
 
-    block['block']['header']["digest"]["logs"].each_with_index do |hex, i|
-      scale_bytes = Scale::Bytes.new(hex)
-      block['block']['header']["digest"]["logs"][i] = Scale::Types::LogDigest.decode(scale_bytes).to_human
+  def get_block(block_hash=nil, &callback)
+    self.init_runtime block_hash do
+      self.chain_get_block(block_hash) do |block|
+        block = Helper.decode_block block
+        callback.call block
+      end
     end
-
-    block
   end
 
-  def get_block_events(block_hash)
-    self.init_runtime(block_hash: block_hash)
-
-    storage_key =  "0x26aa394eea5630e07c48ae0c9558cef780d41e5e16056765bc8461851072c9d7"
-    events_data = state_get_storage storage_key, block_hash
-
-    scale_bytes = Scale::Bytes.new(events_data)
-    Scale::Types.get("Vec<EventRecord>").decode(scale_bytes).to_human
+  def get_block_events(block_hash=nil, &callback)
+    self.init_runtime(block_hash) do
+      storage_key =  "0x26aa394eea5630e07c48ae0c9558cef780d41e5e16056765bc8461851072c9d7"
+      self.state_get_storage storage_key, block_hash do |events_data|
+        scale_bytes = Scale::Bytes.new(events_data)
+        events = Scale::Types.get("Vec<EventRecord>").decode(scale_bytes).to_human
+        callback.call events
+      end
+    end
   end
 
   def subscribe_block_events(&callback)
-    self.chain_subscribe_finalised_heads do |data|
+    self.chain_subscribe_finalized_heads do |data|
 
       block_number = data["params"]["result"]["number"].to_i(16) - 1
       block_hash = data["params"]["result"]["parentHash"]
@@ -238,17 +235,18 @@ class SubstrateClient
       EM.defer(
 
         proc {
-          events = get_block_events block_hash
-          { block_number: block_number, events: events }
+          self.get_block_events block_hash do |events|
+            begin
+              result = { block_number: block_number, events: events }
+              callback.call result
+            rescue => ex
+              SubstrateClient.logger.error ex.message
+              SubstrateClient.logger.error ex.backtrace.join("\n")
+            end
+          end
         },
 
         proc { |result| 
-          begin
-            callback.call result
-          rescue => ex
-            SubstrateClient.logger.error ex.message
-            SubstrateClient.logger.error ex.backtrace.join("\n")
-          end
         },
 
         proc { |e|
@@ -259,130 +257,25 @@ class SubstrateClient
     end
   end
 
-  # Plain: client.get_storage("Sudo", "Key")
-  # Plain: client.get_storage("Balances", "TotalIssuance")
-  # Map: client.get_storage("System", "Account", ["0xd43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d"])
-  # DoubleMap: client.get_storage("ImOnline", "AuthoredBlocks", [2818, "0x749ddc93a65dfec3af27cc7478212cb7d4b0c0357fef35a0163966ab5333b757"])
-  def get_storage(module_name, storage_name, params = nil, block_hash = nil)
-    self.init_runtime(block_hash: block_hash)
-
-    # find the storage item from metadata
-    metadata_modules = metadata.value.value[:metadata][:modules]
-    metadata_module = metadata_modules.detect { |mm| mm[:name] == module_name }
-    raise "Module '#{module_name}' not exist" unless metadata_module
-    storage_item = metadata_module[:storage][:items].detect { |item| item[:name] == storage_name }
-    raise "Storage item '#{storage_name}' not exist. \n#{metadata_module.inspect}" unless storage_item
-
-    if storage_item[:type][:Plain]
-      return_type = storage_item[:type][:Plain]
-    elsif map = storage_item[:type][:Map]
-      raise "Storage call of type \"Map\" requires 1 parameter" if params.nil? || params.length != 1
-
-      hasher = map[:hasher]
-      return_type = map[:value]
-      # TODO: decode to account id if param is address
-      # params[0] = decode(params[0]) if map[:key] == "AccountId"
-      params[0] = Scale::Types.get(map[:key]).new(params[0]).encode
-    elsif map = storage_item[:type][:DoubleMap]
-      raise "Storage call of type \"DoubleMapType\" requires 2 parameters" if params.nil? || params.length != 2
-
-      hasher = map[:hasher]
-      hasher2 = map[:key2Hasher]
-      return_type = map[:value]
-      params[0] = Scale::Types.get(map[:key1]).new(params[0]).encode
-      params[1] = Scale::Types.get(map[:key2]).new(params[1]).encode
-    else
-      raise NotImplementedError
-    end
-
-    storage_hash = SubstrateClient.generate_storage_hash(
-      module_name,
-      storage_name,
-      params,
-      hasher,
-      hasher2,
-      metadata.value.value[:metadata][:version]
-    )
-  
-    p module_name
-    p storage_name
-    p params
-    p hasher
-    p hasher2
-    p metadata.value.value[:metadata][:version]
-    result = self.state_get_storage(storage_hash, block_hash)
-    return unless result
-    Scale::Types.get(return_type).decode(Scale::Bytes.new(result))
-  end
-
-  # compose_call "Balances", "Transfer", { dest: "0x586cb27c291c813ce74e86a60dad270609abf2fc8bee107e44a80ac00225c409", value: 1_000_000_000_000 }
-  def compose_call(module_name, call_name, params, block_hash=nil)
-    self.init_runtime(block_hash: block_hash)
-
-    call = metadata.get_module_call(module_name, call_name)
-
-    value = {
-      call_index: call[:lookup],
-      module_name: module_name,
-      call_name: call_name,
-      params: []
-    }
-
-    params.keys.each_with_index do |call_param_name, i|
-      param_value = params[call_param_name]
-      value[:params] << {
-        name: call_param_name.to_s,
-        type: call[:args][i][:type],
-        value: param_value
-      }
-    end
-
-    Scale::Types::Extrinsic.new(value).encode
-  end
-
-  class << self
-    def generate_storage_hash(module_name, storage_name, params = nil, hasher = nil, hasher2 = nil, metadata_version = nil)
-      if metadata_version and metadata_version >= 9
-        storage_hash = Crypto.twox128(module_name) + Crypto.twox128(storage_name)
-
-        params&.each_with_index do |param, index|
-          if index == 0
-            param_hasher = hasher
-          elsif index == 1
-            param_hasher = hasher2
-          else
-            raise "Unexpected third parameter for storage call"
-          end
-
-          param_key = param.hex_to_bytes
-          param_hasher = "Twox128" if param_hasher.nil?
-          storage_hash += Crypto.send param_hasher.underscore, param_key
-        end
-
-        "0x#{storage_hash}"
-      else
-        # TODO: add test
-        storage_hash = module_name + " " + storage_name
-
-        unless params.nil?
-          params = [params] if params.class != ::Array
-          params_key = params.join("")
-          hasher = "Twox128" if hasher.nil?
-          storage_hash += params_key.hex_to_bytes.bytes_to_utf8 
+  def get_storage(module_name, storage_name, params = nil, block_hash = nil, &callback)
+    self.init_runtime(block_hash) do
+      storage_hash, return_type = Helper.generate_storage_hash_from_metadata(@metadata, module_name, storage_name, params)
+      self.state_get_storage(storage_hash, block_hash) do |result|
+        if result
+          storage = Scale::Types.get(return_type).decode(Scale::Bytes.new(result))
+          callback.call storage
+        else
+          callback.call nil
         end
-
-        "0x#{Crypto.send( hasher.underscore, storage_hash )}"
       end
     end
+  end
 
-    # chain_unsubscribe_runtime_version
-    # => 
-    # chain_unsubscribeRuntimeVersion
-    def real_method_name(method_name)
-      segments = method_name.to_s.split("_")
-      segments[0] + "_" + segments[1] + segments[2..].map(&:capitalize).join
+  def compose_call(module_name, call_name, params, block_hash=nil, &callback)
+    self.init_runtime(block_hash) do
+      hex = Helper.compose_call_from_metadata(@metadata, module_name, call_name, params)
+      callback.call hex
     end
-
   end
 
   private

data/lib/substrate_client/version.rb

@@ -1,3 +1,3 @@
 class SubstrateClient
-  VERSION = "0.1.5"
+  VERSION = "0.1.6"
 end

data/lib/substrate_client_sync.rb

@@ -0,0 +1,190 @@
+def ws_request(url, payload)
+  queue = TimeoutQueue.new
+
+  thread = Thread.new do
+    EM.run do
+      ws = Faye::WebSocket::Client.new(url)
+
+      ws.on :open do |event|
+        ws.send(payload.to_json)
+      end
+
+      ws.on :message do |event|
+        if event.data.include?("jsonrpc")
+          queue << JSON.parse(event.data)
+          ws.close(3001, "data received")
+          Thread.kill thread
+        end
+      end
+
+      ws.on :close do |event|
+        ws = nil
+      end
+    end
+  end
+
+  queue.pop true, 10
+rescue ThreadError => ex
+  raise SubstrateClientSync::RpcTimeout
+end
+
+class SubstrateClientSync
+  class RpcError < StandardError; end
+  class RpcTimeout < StandardError; end
+
+  attr_accessor :spec_name, :spec_version, :metadata
+
+  def initialize(url, spec_name: nil)
+    @url = url
+    @request_id = 1
+    @spec_name = spec_name
+    Scale::TypeRegistry.instance.load(spec_name)
+  end
+
+  def request(method, params)
+    payload = {
+      "jsonrpc" => "2.0",
+      "method" => method,
+      "params" => params,
+      "id" => @request_id
+    }
+
+    data = ws_request(@url, payload)
+    if data["error"]
+      raise RpcError, data["error"]
+    else
+      data["result"]
+    end
+  end
+
+  def init_runtime(block_hash=nil)
+    # set current runtime spec version
+    runtime_version = self.state_get_runtime_version(block_hash)
+    @spec_version = runtime_version["specVersion"]
+    Scale::TypeRegistry.instance.spec_version = @spec_version
+
+    # set current metadata
+    @metadata = self.get_metadata(block_hash)
+    Scale::TypeRegistry.instance.metadata = @metadata.value
+    true
+  end
+
+  def invoke(method, *params)
+    # params.reject! { |param| param.nil? }
+    request(method, params)
+  end
+
+  def rpc_method(method_name)
+    SubstrateClient::Helper.real_method_name(method_name.to_s)
+  end
+
+  # ################################################
+  # origin rpc methods
+  # ################################################
+  def method_missing(method, *args)
+    rpc_method = SubstrateClient::Helper.real_method_name(method)
+    invoke rpc_method, *args
+  end
+
+  def state_get_runtime_version(block_hash=nil)
+    invoke rpc_method(__method__), block_hash
+  end
+
+  def rpc_methods 
+    invoke rpc_method(__method__)
+  end
+
+  def chain_get_head
+    invoke rpc_method(__method__)
+  end
+
+  def chain_get_finalised_head
+    invoke rpc_method(__method__)
+  end
+
+  def chain_get_header(block_hash = nil)
+    invoke rpc_method(__method__), block_hash
+  end
+
+  def chain_get_block(block_hash = nil)
+    invoke rpc_method(__method__), block_hash
+  end
+
+  def chain_get_block_hash(block_id)
+    invoke rpc_method(__method__), block_id
+  end
+
+  def chain_get_runtime_version(block_hash = nil)
+    invoke rpc_method(__method__), block_hash
+  end
+
+  def state_get_metadata(block_hash = nil)
+    invoke rpc_method(__method__), block_hash
+  end
+
+  def state_get_storage(storage_key, block_hash = nil)
+    invoke rpc_method(__method__), storage_key, block_hash
+  end
+
+  def system_name
+    invoke rpc_method(__method__)
+  end
+
+  def system_version
+    invoke rpc_method(__method__)
+  end
+
+  # ################################################
+  # custom methods based on origin rpc methods
+  # ################################################
+  def method_list
+    self.rpc_methods["methods"].map(&:underscore)
+  end
+
+  def get_block_number(block_hash)
+    header = self.chain_get_header(block_hash)
+    header["number"].to_i(16)
+  end
+
+  def get_metadata(block_hash=nil)
+    hex = self.state_get_metadata(block_hash)
+    Scale::Types::Metadata.decode(Scale::Bytes.new(hex))
+  end
+
+  def get_block(block_hash=nil)
+    self.init_runtime(block_hash)
+    block = self.chain_get_block(block_hash)
+    SubstrateClient::Helper.decode_block(block)
+  end
+
+  def get_block_events(block_hash=nil)
+    self.init_runtime(block_hash)
+
+    storage_key =  "0x26aa394eea5630e07c48ae0c9558cef780d41e5e16056765bc8461851072c9d7"
+    events_data = state_get_storage storage_key, block_hash
+
+    scale_bytes = Scale::Bytes.new(events_data)
+    Scale::Types.get("Vec<EventRecord>").decode(scale_bytes).to_human
+  end
+
+  # Plain: client.get_storage("Sudo", "Key")
+  # Plain: client.get_storage("Balances", "TotalIssuance")
+  # Map: client.get_storage("System", "Account", ["0xd43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d"])
+  # DoubleMap: client.get_storage("ImOnline", "AuthoredBlocks", [2818, "0x749ddc93a65dfec3af27cc7478212cb7d4b0c0357fef35a0163966ab5333b757"])
+  def get_storage(module_name, storage_name, params = nil, block_hash = nil)
+    self.init_runtime(block_hash)
+
+    storage_hash, return_type = SubstrateClient::Helper.generate_storage_hash_from_metadata(@metadata, module_name, storage_name, params)
+
+    result = self.state_get_storage(storage_hash, block_hash)
+    return unless result
+    Scale::Types.get(return_type).decode(Scale::Bytes.new(result))
+  end
+
+  # compose_call "Balances", "Transfer", { dest: "0x586cb27c291c813ce74e86a60dad270609abf2fc8bee107e44a80ac00225c409", value: 1_000_000_000_000 }
+  def compose_call(module_name, call_name, params, block_hash=nil)
+    self.init_runtime(block_hash)
+    SubstrateClient::Helper.compose_call_from_metadata(@metadata, module_name, call_name, params)
+  end
+
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: substrate_client.rb
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.1.6
 platform: ruby
 authors:
 - Wu Minzhe
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-05-19 00:00:00.000000000 Z
+date: 2020-05-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faye-websocket
@@ -142,8 +142,10 @@ files:
 - bin/console
 - bin/setup
 - exe/metadata
+- lib/helper.rb
 - lib/substrate_client.rb
 - lib/substrate_client/version.rb
+- lib/substrate_client_sync.rb
 - lib/timeout_queue.rb
 - lib/websocket.rb
 - substrate_client.gemspec