substrate_client.rb 0.1.4 → 0.1.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5f0802284ca7abb1fd02f502506a00ba67ef2c0d436a1bede7012fc7746196c9
-  data.tar.gz: 2b76f455d30a57c0b36eceecc5cf19e720126e9f071e3899b054a151bb1b122c
+  metadata.gz: c9993008c06625166a02238e5efddd9fe0c840f4c00e7a3dd053d58a9e7ec5a8
+  data.tar.gz: f360d71d6ba20d8ec5ed56d00ba8651a6a5371d88399c2a7113f1315a4b4f2ce
 SHA512:
-  metadata.gz: 392f72952f9822de5dff8b6c5df89b7eab52e7bdf38c988f0ea4448c8f6439f74dd06e415dd1fc33c627ed4c74e494c8838c452d3975e1f92c89a8b86e4e68a9
-  data.tar.gz: eda7bacb9cb728d254c3582ef99696689fe03d387b14ad38ad4196b1c4a2ed10eb3f806a8c01c1da9c9143ffe00a15e1597b534c2df9ac1876d62fd63a1be230
+  metadata.gz: 3a2158b190ebf549901de66c5b590a0780177149427efb77439db24b6756f2b2890de5ab91010448338e8a8da48ce8be6f917428f35e52cd1e578af637746da8
+  data.tar.gz: 3c46a63f1173b4ae417c76fd5325a612b4f22e299483cf6adac447914a8e1a556dc96c4559af29eadfb308645a1950d659d67aa82a07af7587f833a128cd495a

data/Dockerfile

@@ -0,0 +1,17 @@
+FROM ruby:2.6-alpine3.11
+
+ENV BUILD_PACKAGES curl-dev build-base
+
+RUN apk update && \
+    apk upgrade && \
+    apk add git curl $BUILD_PACKAGES
+
+WORKDIR /usr/src/app
+
+COPY . .
+
+RUN gem install bundler:1.17.3 && \
+    bundle install && \
+    rake install:local
+
+CMD ["sh"]

data/Gemfile.lock

@@ -1,16 +1,16 @@
 PATH
   remote: .
   specs:
-    substrate_client.rb (0.1.4)
+    substrate_client.rb (0.1.9)
       activesupport (~> 5.2.4)
-      eventmachine (~> 1.2.7)
-      faye-websocket (~> 0.10.9)
-      scale.rb (~> 0.2.5)
+      kontena-websocket-client (~> 0.1.1)
+      scale.rb (~> 0.2.12)
+      substrate_common.rb (~> 0.1.9)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    activesupport (5.2.4.2)
+    activesupport (5.2.4.4)
       concurrent-ruby (~> 1.0, >= 1.0.2)
       i18n (>= 0.7, < 2)
       minitest (~> 5.1)
@@ -18,17 +18,15 @@ GEM
     base58 (0.2.3)
     blake2b (0.10.0)
     coderay (1.1.2)
-    concurrent-ruby (1.1.6)
+    concurrent-ruby (1.1.7)
     diff-lcs (1.3)
-    eventmachine (1.2.7)
-    faye-websocket (0.10.9)
-      eventmachine (>= 0.12.0)
-      websocket-driver (>= 0.5.1)
-    i18n (1.8.2)
+    i18n (1.8.5)
       concurrent-ruby (~> 1.0)
-    json (2.3.0)
+    json (2.3.1)
+    kontena-websocket-client (0.1.1)
+      websocket-driver (~> 0.6.5)
     method_source (0.9.2)
-    minitest (5.14.0)
+    minitest (5.14.2)
     pry (0.12.2)
       coderay (~> 1.1.0)
       method_source (~> 0.9.0)
@@ -46,12 +44,12 @@ GEM
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.9.0)
     rspec-support (3.9.2)
-    scale.rb (0.2.5)
+    scale.rb (0.2.12)
       activesupport (>= 4.0.0)
       json (~> 2.3.0)
-      substrate_common.rb (~> 0.1.8)
+      substrate_common.rb (~> 0.1.9)
       thor (~> 0.19.0)
-    substrate_common.rb (0.1.8)
+    substrate_common.rb (0.1.9)
       base58
       blake2b
       xxhash
@@ -59,9 +57,9 @@ GEM
     thread_safe (0.3.6)
     tzinfo (1.2.7)
       thread_safe (~> 0.1)
-    websocket-driver (0.7.1)
+    websocket-driver (0.6.5)
       websocket-extensions (>= 0.1.0)
-    websocket-extensions (0.1.4)
+    websocket-extensions (0.1.5)
     xxhash (0.4.0)
 
 PLATFORMS

data/README.md

@@ -22,184 +22,153 @@ Or install it yourself as:
 
 ### Supported rpc methods
 
-#### rpc method list
-
 ```ruby
 require "substrate_client"
 
 client = SubstrateClient.new("wss://kusama-rpc.polkadot.io/")
-puts client.method_list
+client.methods
+```
+returns like:
+```shell
+[
+	"account_nextIndex",
+  "author_hasKey",
+  ...
+	"chain_getBlock",
+	"chain_getBlockHash",
+	...
+]
 ```
-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
-
-But, in order to show the parameters more clearly, some important or frequently used methods are hard-coded:
-
-- chain_get_finalised_head
-
-  Get hash of the last finalized block in the canon chain
-
-  
-
-- chain_get_head
-
-- chain_get_header(block_hash = nil)
-
-  Retrieves the header for a specific block
-
-  
-
-- chain_get_block(block_hash = nil)
-
-  Get header and body of a relay chain block
-
-  
-
-- chain_get_block_hash(block_id)
-
-  Get the block hash for a specific block
-
-  
-
-- chain_get_runtime_version(block_hash = nil)
-
-  Get the runtime version for a specific block
-
-  
-
-- state_get_metadata(block_hash = nil)
-
-  Returns the runtime metadata by block
-
-  
-
-- state_get_storage(storage_key, block_hash = nil)
-
-  Retrieves the storage for a key
-
-  
-
-- system_name
-
-- system_version
-
-  
-
-- chain_subscribe_all_heads(&callback)
-
-  Retrieves the newest 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_all_heads(subscription)
-
-  Unsubscribe newest header subscription.
-
-  ```ruby
-  client.chain_unsubscribe_all_heads(subscription)
-  ```
-
-  
-
-- chain_subscribe_new_heads(&callback)
-
-  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.
+The rpc methods can be dynamically called by its name, so you can call it like:
 
-  ```ruby
-  client.chain_unsubscribe_new_heads(subscription)
-  ```
+```ruby
+client.chain_getBlockHash(1024)
+```
 
+### Origin rpc methods
+
+- `account_nextIndex`
+* `author_hasKey`
+* `author_hasSessionKeys`
+* `author_insertKey`
+* `author_pendingExtrinsics`
+* `author_removeExtrinsic`
+* `author_rotateKeys`
+* `author_submitExtrinsic`
+* `babe_epochAuthorship`
+* `chain_getBlock(block_hash = nil)`
+* `chain_getBlockHash(block_id)`
+* `chain_getFinalisedHead`
+* `chain_getFinalizedHead`
+* `chain_getHead`
+* `chain_getHeader(block_hash = nil)`
+* `chain_getRuntimeVersion(block_hash = nil)`
+* `childstate_getKeys`
+* `childstate_getStorage`
+* `childstate_getStorageHash`
+* `childstate_getStorageSize`
+* `grandpa_roundState`
+* `offchain_localStorageGet`
+* `offchain_localStorageSet`
+* `payment_queryInfo`
+* `state_call`
+* `state_callAt`
+* `state_getKeys`
+* `state_getKeysPaged`
+* `state_getKeysPagedAt`
+* `state_getMetadata(block_hash = nil)`
+* `state_getPairs`
+* `state_getReadProof`
+* `state_getRuntimeVersion`
+* `state_getStorage(storage_key, block_hash = nil)`
+* `state_getStorageAt`
+* `state_getStorageHash`
+* `state_getStorageHashAt`
+* `state_getStorageSize`
+* `state_getStorageSizeAt`
+* `state_queryStorage`
+* `state_queryStorageAt`
+* `system_accountNextIndex`
+* `system_addReservedPeer`
+* `system_chain`
+* `system_chainType`
+* `system_dryRun`
+* `system_dryRunAt`
+* `system_health`
+* `system_localListenAddresses`
+* `system_localPeerId`
+* `system_name`
+* `system_networkState`
+* `system_nodeRoles`
+* `system_peers`
+* `system_properties`
+* `system_removeReservedPeer`
+- `system_version`
+
+### Wrap methods
 
+These methods will encode the parameters and decode the returned data
 
-- chain_subscribe_finalized_heads(&callback)
+- `get_block_number(block_hash)`
 
-  Retrieves the best finalized header via subscription. This will return data continuously until you unsubscribe the subscription.
+- `get_metadata(block_hash)`
 
-  ```ruby
-  subscription = client.chain_subscribe_finalized_heads do |data|
-    p data
-  end
-  ```
+- `get_block(block_hash=nil)`
 
-- chain_unsubscribe_finalized_heads(subscription)
+- `get_block_events(block_hash)`
 
-  Unsubscribe the best finalized header subscription.
+- `get_storage(module_name, storage_name, params = nil, block_hash = nil)`
 
   ```ruby
-  client.chain_unsubscribe_finalized_heads(subscription)
+  client.get_storage("Balances", "TotalIssuance", nil, nil)
+  client.get_storage("System", "Account", ["0xd43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d"], nil)
+  client.get_storage("ImOnline", "AuthoredBlocks", [2818, "0x749ddc93a65dfec3af27cc7478212cb7d4b0c0357fef35a0163966ab5333b757"], nil) 
   ```
-
-  
-
-- state_subscribe_runtime_version(&callback)
-
-  Retrieves the runtime version via subscription. 
-
-- state_unsubscribe_runtime_version(subscription)
-
-  Unsubscribe the runtime version subscription.
-
   
-
-- state_subscribe_storage(keys, &callback)
-
-  Subscribes to storage changes for the provided keys until unsubscribe.
+- `compose_call(module_name, call_name, params, block_hash=nil)`
 
   ```ruby
-  subscription = client.state_subscribe_storage ["0x26aa394eea5630e07c48ae0c9558cef780d41e5e16056765bc8461851072c9d7"] do |data| 
-  	p data 
-  end
+  client.compose_call "Balances", "Transfer", { dest: "0x586cb27c291c813ce74e86a60dad270609abf2fc8bee107e44a80ac00225c409", value: 1_000_000_000_000 }, nil
   ```
 
-- state_unsubscribe_storage(subscription)
-
-  Unsubscribe storage changes.
-
-  
-### Cutom methods based on rpc methods
-
-These methods will encode the parameters and decode the returned data
+## Docker
 
-- get_block_number(block_hash)
+1. update to latest image
 
-- get_metadata(block_hash)
+   `docker pull itering/substrate_client:latest`
 
-- get_block(block_hash=nil)
+2. Run image:
 
-- get_block_events(block_hash)
+   `docker run -it itering/substrate_client:latest`
 
-- subscribe_block_events(&callback)
+   This  will enter the container with a linux shell opened. 
 
-- get_storage(module_name, storage_name, params = nil, block_hash = nil)
+   ```shell
+   /usr/src/app # 
+   ```
 
-  ```ruby
-  client.get_storage("Sudo", "Key")
-  client.get_storage("Balances", "TotalIssuance")
-  client.get_storage("System", "Account", ["0xd43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d"])
-  client.get_storage("ImOnline", "AuthoredBlocks", [2818, "0x749ddc93a65dfec3af27cc7478212cb7d4b0c0357fef35a0163966ab5333b757"])
-  ```
+3. Type `rspec` to run all tests
 
-- compose_call(module_name, call_name, params, block_hash=nil)
+   ```shell
+   /usr/src/app # rspec
+   ...................
+   
+   Finished in 0.00883 seconds (files took 0.09656 seconds to load)
+   5 examples, 0 failures
+   ```
 
-  ```ruby
-  compose_call "Balances", "Transfer", { dest: "0x586cb27c291c813ce74e86a60dad270609abf2fc8bee107e44a80ac00225c409", value: 1_000_000_000_000 }
-  ```
+4. Or, type `./bin/console` to enter the ruby interactive environment and run any decode or encode code
 
+   ```shell
+   /usr/src/app # ./bin/console
+   [1] pry(main)> client = SubstrateClient.new("wss://kusama-rpc.polkadot.io/")
+   => #<SubstrateClient:0x000055a78f124f58 ...
+   [2] pry(main)> client.methods
+   => ...
+   [3] pry(main)> client.chain_getHead
+   => "0xb3c3a220d4639b7c62f179f534b3a66336a115ebc18f13db053f0c57437c45fc"
+   ```
 
 
 ## Development

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 = SubstrateClient.new(url)
-client.init(block_hash)
+
+block_hash = ARGV[1] || client.chain_getFinalisedHead
+
 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,119 @@
+
+class SubstrateClient::Helper
+  class << self
+    def generate_storage_key_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"
+        type = Scale::Types.get(map[:key])
+        params[0] = type.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_key = generate_storage_key(
+        module_name,
+        storage_name,
+        params,
+        hasher,
+        hasher2,
+        metadata.value.value[:metadata][:version]
+      )
+      [storage_key, return_type]
+    end
+
+    def generate_storage_key(module_name, storage_name, params = nil, hasher = nil, hasher2 = nil, metadata_version = nil)
+      if metadata_version and metadata_version >= 9
+        storage_key = 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_key += Crypto.send param_hasher.underscore, param_key
+        end
+
+        "0x#{storage_key}"
+      else
+        # TODO: add test
+        storage_key = module_name + " " + storage_name
+
+        unless params.nil?
+          params = [params] if params.class != ::Array
+          params_key = params.join("")
+          hasher = "Twox128" if hasher.nil?
+          storage_key += params_key.hex_to_bytes.bytes_to_utf8 
+        end
+
+        "0x#{Crypto.send( hasher.underscore, storage_key )}"
+      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
+
+  end
+end

data/lib/substrate_client.rb

@@ -1,30 +1,46 @@
 require "substrate_client/version"
 
+require "logger"
 require "scale.rb"
-require "faye/websocket"
-require "eventmachine"
 require "json"
 require "active_support"
 require "active_support/core_ext/string"
+require "helper"
+require 'kontena-websocket-client'
+
+def ws_request(url, payload)
+  result = nil
+  Kontena::Websocket::Client.connect(url, {}) do |client|
+    client.send(payload.to_json)
+
+    client.read do |message|
+      result = JSON.parse message
+      client.close(1000)
+    end
+  end
+
+  return result
+rescue Kontena::Websocket::CloseError => e
+  raise SubstrateClient::WebsocketError, e.reason
+rescue Kontena::Websocket::Error => e
+  raise SubstrateClient::WebsocketError, e.reason
+end
 
 class SubstrateClient
+  class WebsocketError < StandardError; end
   class RpcError < StandardError; end
+  class RpcTimeout < StandardError; end
 
   attr_accessor :spec_name, :spec_version, :metadata
-  attr_reader :ws
 
-  def initialize(url: , spec_name: nil)
+  def initialize(url, spec_name: nil)
     @url = url
     @request_id = 1
     @spec_name = spec_name
-    Scale::TypeRegistry.instance.load(spec_name)
-
-    init_ws
+    Scale::TypeRegistry.instance.load(spec_name: spec_name)
   end
 
-  def request(method, params, subscription_callback=nil)
-    queue = Queue.new
-
+  def request(method, params)
     payload = {
       "jsonrpc" => "2.0",
       "method" => method,
@@ -32,15 +48,7 @@ class SubstrateClient
       "id" => @request_id
     }
 
-    @callbacks[@request_id] = proc { |data| queue << data }
-    @ws.send(payload.to_json)
-    @request_id += 1
-    data = queue.pop
-
-    if not subscription_callback.nil? && data["result"]
-      @subscription_callbacks[data["result"]] = subscription_callback
-    end
-
+    data = ws_request(@url, payload)
     if data["error"]
       raise RpcError, data["error"]
     else
@@ -48,17 +56,9 @@ class SubstrateClient
     end
   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
-      end
-    end
-
+  def init_runtime(block_hash=nil)
     # set current runtime spec version
-    runtime_version = self.state_get_runtime_version(block_hash)
+    runtime_version = self.state_getRuntimeVersion(block_hash)
     @spec_version = runtime_version["specVersion"]
     Scale::TypeRegistry.instance.spec_version = @spec_version
 
@@ -73,349 +73,73 @@ class SubstrateClient
     request(method, params)
   end
 
-  def rpc_method(method_name)
-    SubstrateClient.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
-  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
-
-  def chain_subscribe_all_heads(&callback)
-    request rpc_method(__method__), [], callback
-  end
-
-  def chain_unsubscribe_all_heads(subscription)
-    invoke rpc_method(__method__), subscription
-  end
-
-  def chain_subscribe_new_heads(&callback)
-    request rpc_method(__method__), [], callback
-  end
-
-  def chain_unsubscribe_new_heads(subscription)
-    invoke rpc_method(__method__), subscription
-  end
-
-  def chain_subscribe_finalized_heads(&callback)
-    request rpc_method(__method__), [], callback
-  end
-
-  def chain_unsubscribe_finalized_heads(subscription)
-    invoke rpc_method(__method__), subscription
-  end
-
-  def state_subscribe_runtime_version(&callback)
-    request rpc_method(__method__), [], callback
-  end
-
-  def state_unsubscribe_runtime_version(subscription)
-    invoke rpc_method(__method__), subscription
-  end
-
-  def state_subscribe_storage(keys, &callback)
-    request rpc_method(__method__), [keys], callback
-  end
-
-  def state_unsubscribe_storage(subscription)
-    invoke rpc_method(__method__), subscription
+    invoke method, *args
   end
 
   # ################################################
   # custom methods based on origin rpc methods
   # ################################################
-  def method_list
-    self.rpc_methods["methods"].map(&:underscore)
+  def methods
+    invoke("rpc_methods")["methods"]
   end
 
   def get_block_number(block_hash)
-    header = self.chain_get_header(block_hash)
+    header = self.chain_getHeader(block_hash)
     header["number"].to_i(16)
   end
 
-  def get_metadata(block_hash)
-    hex = self.state_get_metadata(block_hash)
+  def get_metadata(block_hash=nil)
+    hex = self.state_getMetadata(block_hash)
     Scale::Types::Metadata.decode(Scale::Bytes.new(hex))
   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
-    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
+    self.init_runtime(block_hash)
+    block = self.chain_getBlock(block_hash)
+    SubstrateClient::Helper.decode_block(block)
   end
 
-  def get_block_events(block_hash)
-    self.init_runtime(block_hash: block_hash)
+  def get_block_events(block_hash=nil)
+    self.init_runtime(block_hash)
 
     storage_key =  "0x26aa394eea5630e07c48ae0c9558cef780d41e5e16056765bc8461851072c9d7"
-    events_data = state_get_storage storage_key, block_hash
+    events_data = state_getStorage storage_key, block_hash
 
     scale_bytes = Scale::Bytes.new(events_data)
     Scale::Types.get("Vec<EventRecord>").decode(scale_bytes).to_human
   end
 
-  def subscribe_block_events(&callback)
-    self.chain_subscribe_finalised_heads do |data|
-
-      block_number = data["params"]["result"]["number"].to_i(16) - 1
-      block_hash = data["params"]["result"]["parentHash"]
-
-      EM.defer(
-
-        proc {
-          events = get_block_events block_hash
-          { block_number: block_number, events: events }
-        },
-
-        proc { |result| 
-          begin
-            callback.call result
-          rescue => ex
-            puts ex.message
-            puts ex.backtrace.join("\n")
-          end
-        },
-
-        proc { |e|
-          puts e
-        }
-
-      )
-    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)
+    self.init_runtime(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
+    storage_key, return_type = SubstrateClient::Helper.generate_storage_key_from_metadata(@metadata, module_name, storage_name, params)
 
-    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]
-    )
-
-    result = self.state_get_storage(storage_hash, block_hash)
+    result = self.state_getStorage(storage_key, 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 
-        end
-
-        "0x#{Crypto.send( hasher.underscore, storage_hash )}"
-      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
-    end
-
+  def generate_storage_key(module_name, storage_name, params = nil, block_hash = nil)
+    self.init_runtime(block_hash)
+    SubstrateClient::Helper.generate_storage_key_from_metadata(@metadata, module_name, storage_name, params)
   end
 
-  private
-  def init_ws
-    queue = Queue.new
-
-    Thread.new do
-      EM.run do
-        start_connection
-        queue << "ok"
-      end
-    end
-
-    if queue.pop
-      Thread.new do
-        loop do
-          if @ws && @ws.ready_state == 3
-            puts "try to reconnect"
-            start_connection
-          end
-
-          sleep(3)
-        end
-      end
-    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
 
-  def start_connection
-    @callbacks = {}
-    @subscription_callbacks = {}
-
-    @ws = Faye::WebSocket::Client.new(@url)
-    @ws.on :message do |event|
-      # p [:message, event.data]
-      if event.data.include?("jsonrpc")
-        begin
-          data = JSON.parse event.data
-
-          if data["params"]
-            if @subscription_callbacks[data["params"]["subscription"]]
-              @subscription_callbacks[data["params"]["subscription"]].call data
-            end
-          else
-            @callbacks[data["id"]].call data
-            @callbacks.delete(data["id"])
-          end
-
-        rescue => ex
-          puts ex.message
-          puts ex.backtrace.join("\n")
-        end
-      end
-    end
+  def generate_storage_hash_from_data(storage_hex_data)
+    "0x" + Crypto.blake2_256(Scale::Bytes.new(storage_hex_data).bytes)
   end
 
 end

data/lib/substrate_client/version.rb

@@ -1,3 +1,3 @@
 class SubstrateClient
-  VERSION = "0.1.4"
+  VERSION = "0.1.9"
 end

data/substrate_client.gemspec

@@ -36,10 +36,10 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "faye-websocket", "~> 0.10.9"
-  spec.add_dependency "eventmachine", "~> 1.2.7"
   spec.add_dependency "activesupport", "~> 5.2.4"
-  spec.add_dependency "scale.rb", "~> 0.2.5"
+  spec.add_dependency "scale.rb", "~> 0.2.12"
+  spec.add_dependency "kontena-websocket-client", "~> 0.1.1"
+  spec.add_dependency "substrate_common.rb", "~> 0.1.9"
 
   spec.add_development_dependency "bundler", "~> 1.17"
   spec.add_development_dependency "rake", ">= 12.3.3"

metadata

@@ -1,71 +1,71 @@
 --- !ruby/object:Gem::Specification
 name: substrate_client.rb
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.9
 platform: ruby
 authors:
 - Wu Minzhe
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-05-14 00:00:00.000000000 Z
+date: 2020-11-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: faye-websocket
+  name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.10.9
+        version: 5.2.4
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.10.9
+        version: 5.2.4
 - !ruby/object:Gem::Dependency
-  name: eventmachine
+  name: scale.rb
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.2.7
+        version: 0.2.12
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.2.7
+        version: 0.2.12
 - !ruby/object:Gem::Dependency
-  name: activesupport
+  name: kontena-websocket-client
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 5.2.4
+        version: 0.1.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 5.2.4
+        version: 0.1.1
 - !ruby/object:Gem::Dependency
-  name: scale.rb
+  name: substrate_common.rb
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.2.5
+        version: 0.1.9
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.2.5
+        version: 0.1.9
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -134,6 +134,7 @@ files:
 - ".rspec"
 - ".travis.yml"
 - CODE_OF_CONDUCT.md
+- Dockerfile
 - Gemfile
 - Gemfile.lock
 - LICENSE.txt
@@ -142,6 +143,7 @@ files:
 - bin/console
 - bin/setup
 - exe/metadata
+- lib/helper.rb
 - lib/substrate_client.rb
 - lib/substrate_client/version.rb
 - substrate_client.gemspec