substrate_client.rb 0.1.3 → 0.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5248291da5b3db7dcdcdf913842fceef276c31481346f6da8141960e7d81afdb
-  data.tar.gz: ffafc99e20d6321c4ab9c6231a3bf706ade3cbb17ba0c043c4401fbf45769c76
+  metadata.gz: bb233970cdc1b51057d436d0ffc2ae411b99ce3c2e5c51ba3dfb5dcdae0fc960
+  data.tar.gz: 35750c213d2fbf7ae223cdd7b9f7a8bc40c7c7b8fab6a09603a0604db6533562
 SHA512:
-  metadata.gz: bb06f911fe64f6e7e6425bfb4921427b5b49aabab86dfa57c4b2d48aeb2a2e057bfb33256762d316be30ff87f11d21a3cd89efd25c7d78985cc7cdf001038fb6
-  data.tar.gz: e3199b2b0b72423984d7d2baa6160d5c17565b3fd5563375e59661a246c7ba1b80c7ffc82b963cc836e4486f0a48c6f1d070d7ebc48a9803a630b8c04f4f4a7b
+  metadata.gz: 5731212fc4ad5791bb607f132e660b89f7ff652937029e986040aeee85335939d5a5edf9dd9a21a91f346c2b88711657586747a01727f35eae8318b9b944a62f
+  data.tar.gz: 69514b6b9b3eb085f7fefc672dff0b3a85cdfb64babfad28f6ab788f98ee950e2a2e9fcf2e89ab448b7e8c7137da20ba6ec0e68d375ece1b9c41e5f77d3d6964

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,17 +1,16 @@
 PATH
   remote: .
   specs:
-    substrate_client.rb (0.1.3)
+    substrate_client.rb (0.1.8)
       activesupport (~> 5.2.4)
-      eventmachine (~> 1.2.7)
-      faye-websocket (~> 0.10.9)
-      scale.rb (~> 0.2.2)
-      substrate_common.rb (~> 0.1.8)
+      kontena-websocket-client (~> 0.1.1)
+      scale.rb (~> 0.2.11)
+      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)
@@ -19,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)
@@ -47,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.2)
+    scale.rb (0.2.11)
       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
@@ -60,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

@@ -20,23 +20,156 @@ Or install it yourself as:
 
 ## Usage
 
-### Api list
+### Supported rpc methods
 
 ```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 you can call it like:
+
+```ruby
+client.chain_getBlockHash(1024)
 ```
-The rpc api methods is dynamically generated, so the methods returned by this method can be called.
 
-## TODO
+### 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
+
+- `get_block_number(block_hash)`
+
+- `get_metadata(block_hash)`
+
+- `get_block(block_hash=nil)`
+
+- `get_block_events(block_hash)`
+
+- `get_storage(module_name, storage_name, params = nil, block_hash = nil)`
+
+  ```ruby
+  client.get_storage("Balances", "TotalIssuance", nil, nil)
+  client.get_storage("System", "Account", ["0xd43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d"], nil)
+  client.get_storage("ImOnline", "AuthoredBlocks", [2818, "0x749ddc93a65dfec3af27cc7478212cb7d4b0c0357fef35a0163966ab5333b757"], nil) 
+  ```
+  
+- `compose_call(module_name, call_name, params, block_hash=nil)`
+
+  ```ruby
+  client.compose_call "Balances", "Transfer", { dest: "0x586cb27c291c813ce74e86a60dad270609abf2fc8bee107e44a80ac00225c409", value: 1_000_000_000_000 }, nil
+  ```
+
+## Docker
+
+1. update to latest image
+
+   `docker pull itering/substrate_client:latest`
+
+2. Run image:
+
+   `docker run -it itering/substrate_client:latest`
+
+   This  will enter the container with a linux shell opened. 
+
+   ```shell
+   /usr/src/app # 
+   ```
+
+3. Type `rspec` to run all tests
+
+   ```shell
+   /usr/src/app # rspec
+   ...................
+   
+   Finished in 0.00883 seconds (files took 0.09656 seconds to load)
+   5 examples, 0 failures
+   ```
+
+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"
+   ```
 
-- [x] ws wss request support
-- [ ] http request support
-- [x] generate storage key
-- [x] call any api supported by substrate node with ruby's method missing function
-- [ ] metadata caching
 
 ## Development
 

data/exe/metadata

@@ -3,10 +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)
-puts JSON.pretty_generate(client.metadata.value.value)
+
+block_hash = ARGV[1] || client.chain_getFinalisedHead
+
+metadata = client.get_metadata(block_hash)
+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,52 +1,45 @@
 require "substrate_client/version"
 
-require "substrate_common"
-require "scale"
-
-require "faye/websocket"
-require "eventmachine"
+require "logger"
+require "scale.rb"
 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)
 
-  EM.run do
-    ws = Faye::WebSocket::Client.new(url)
-
-    ws.on :open do |event|
-      # p [:open]
-      ws.send(payload.to_json)
-    end
-
-    ws.on :message do |event|
-      # p [:message, event.data]
-      if event.data.include?("jsonrpc")
-        result = JSON.parse event.data
-        ws.close(3001, "data received")
-        EM.stop
-      end
-    end
-
-    ws.on :close do |event|
-      # p [:close, event.code, event.reason]
-      ws = nil
+    client.read do |message|
+      result = JSON.parse message
+      client.close(1000)
     end
   end
 
-  result
+  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
 
-  def initialize(url)
+  def initialize(url, spec_name: nil)
     @url = url
     @request_id = 1
+    @spec_name = spec_name
+    Scale::TypeRegistry.instance.load(spec_name: spec_name)
   end
 
-  # TODO: error
   def request(method, params)
     payload = {
       "jsonrpc" => "2.0",
@@ -54,145 +47,99 @@ class SubstrateClient
       "params" => params,
       "id" => @request_id
     }
-    @request_id += 1
-    ws_request(@url, payload)
+
+    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_getRuntimeVersion(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
 
-  # ############################
-  # native rpc methods support
-  # ############################
+  # ################################################
+  # origin rpc methods
+  # ################################################
   def method_missing(method, *args)
-    data = request(SubstrateClient.real_method_name(method), args)
-    data["result"]
+    invoke method, *args
   end
 
   # ################################################
-  # custom methods wrapped from native rpc methods
+  # custom methods based on origin rpc methods
   # ################################################
-  def method_list
-    methods = self.rpc_methods["methods"].map(&:underscore)
-    methods << "method_list"
-    methods << "get_storage_at"
+  def methods
+    invoke("rpc_methods")["methods"]
   end
 
-  def init(block_hash = nil)
-    block_runtime_version = self.state_get_runtime_version(block_hash)
-    @spec_name = block_runtime_version["specName"]
-    @spec_version = block_runtime_version["specVersion"]
+  def get_block_number(block_hash)
+    header = self.chain_getHeader(block_hash)
+    header["number"].to_i(16)
+  end
 
-    Scale::TypeRegistry.instance.load(spec_name, spec_version)
-    @metadata = self.get_metadata(block_hash)
-    true
+  def get_metadata(block_hash=nil)
+    hex = self.state_getMetadata(block_hash)
+    Scale::Types::Metadata.decode(Scale::Bytes.new(hex))
   end
 
-  def get_metadata(block_hash)
-    hex = self.state_get_metadata(block_hash)
-    metadata = Scale::Types::Metadata.decode(Scale::Bytes.new(hex))
-    metadata.value.value[:metadata]
+  def get_block(block_hash=nil)
+    self.init_runtime(block_hash)
+    block = self.chain_getBlock(block_hash)
+    SubstrateClient::Helper.decode_block(block)
   end
 
-  # client.init(0x014e4248dd04a8c0342b603a66df0691361ac58e69595e248219afa7af87bdc7)
-  # Plain: client.get_storage_at("Balances", "TotalIssuance")
-  # Map: client.get_storage_at("System", "Account", ["0x30599dba50b5f3ba0b36f856a761eb3c0aee61e830d4beb448ef94b6ad92be39"])
-  # DoubleMap: client.get_storage_at("ImOnline", "AuthoredBlocks", [2818, "0x749ddc93a65dfec3af27cc7478212cb7d4b0c0357fef35a0163966ab5333b757"])
-  def get_storage_at(module_name, storage_function_name, params = nil)
-
-    # TODO: uninit raise a exception
-    # find the storage item from metadata
-    metadata_modules = 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_function_name }
-    raise "Storage item '#{storage_function_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
+  def get_block_events(block_hash=nil)
+    self.init_runtime(block_hash)
+
+    storage_key =  "0x26aa394eea5630e07c48ae0c9558cef780d41e5e16056765bc8461851072c9d7"
+    events_data = state_getStorage storage_key, block_hash
 
-    storage_hash = SubstrateClient.generate_storage_hash(
-      module_name,
-      storage_function_name,
-      params,
-      hasher,
-      hasher2,
-      metadata[:version]
-    )
+    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)
 
-    # puts storage_hash
+    storage_key, return_type = SubstrateClient::Helper.generate_storage_key_from_metadata(@metadata, module_name, storage_name, params)
 
-    result = self.state_get_storage_at(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)).value
-  rescue => ex
-    puts ex.message
-    puts ex.backtrace
+    Scale::Types.get(return_type).decode(Scale::Bytes.new(result))
   end
 
-  class << self
-    def generate_storage_hash(storage_module_name, storage_function_name, params = nil, hasher = nil, hasher2 = nil, metadata_version = nil)
-      if metadata_version and metadata_version >= 9
-        storage_hash = Crypto.twox128(storage_module_name) + Crypto.twox128(storage_function_name)
-
-        if params
-          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
-        end
-
-        "0x#{storage_hash}"
-      else
-        # TODO: add test
-        storage_hash = storage_module_name + " " + storage_function_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
 
+  # 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 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.3"
+  VERSION = "0.1.8"
 end

data/substrate_client.gemspec

@@ -36,11 +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 "substrate_common.rb", "~> 0.1.8"
-  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.2"
+  spec.add_dependency "scale.rb", "~> 0.2.11"
+  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,85 +1,71 @@
 --- !ruby/object:Gem::Specification
 name: substrate_client.rb
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.8
 platform: ruby
 authors:
 - Wu Minzhe
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-04-08 00:00:00.000000000 Z
+date: 2020-11-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: substrate_common.rb
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.1.8
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.1.8
-- !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.11
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.2.7
+        version: 0.2.11
 - !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.2
+        version: 0.1.9
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.2.2
+        version: 0.1.9
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -141,7 +127,6 @@ email:
 - wuminzhe@gmail.com
 executables:
 - metadata
-- substrate_client
 extensions: []
 extra_rdoc_files: []
 files:
@@ -149,6 +134,7 @@ files:
 - ".rspec"
 - ".travis.yml"
 - CODE_OF_CONDUCT.md
+- Dockerfile
 - Gemfile
 - Gemfile.lock
 - LICENSE.txt
@@ -157,7 +143,7 @@ files:
 - bin/console
 - bin/setup
 - exe/metadata
-- exe/substrate_client
+- lib/helper.rb
 - lib/substrate_client.rb
 - lib/substrate_client/version.rb
 - substrate_client.gemspec

data/exe/substrate_client

@@ -1,18 +0,0 @@
-#!/usr/bin/env ruby
-
-require "substrate_client"
-require "json"
-
-client = SubstrateClient.new("wss://cc3-5.kusama.network/")
-# puts client.system_name
-# puts client.system_chain
-# puts client.system_version
-# puts client.system_peers
-# puts client.state_getStorage "0x0b76934f4cc08dee01012d059e1b83ee5e0621c4869aa60c02be9adcc98a0d1d"
-# puts client.state_getChildKeys "0x","0x",1,"0x"
-# puts client.runtime_getState "System", "Events",[],"0xe0303fbe2bc8482e06fb649f934c41349d12a25bd618c92e3331a3347e434f7b"
-# puts client.rpc_methods
-
-client.init
-metadata = client.metadata
-puts JSON.pretty_generate(metadata)