substrate_client.rb 0.1.7 → 0.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: af04674d5e75dbafa82eade829b5798fe87e015a51a8edb63d7845cdd38c27b9
-  data.tar.gz: 8afa612ea099169396f4ef3155c5158ba188b09ff602b5d515fcf6deadfe5739
+  metadata.gz: bb233970cdc1b51057d436d0ffc2ae411b99ce3c2e5c51ba3dfb5dcdae0fc960
+  data.tar.gz: 35750c213d2fbf7ae223cdd7b9f7a8bc40c7c7b8fab6a09603a0604db6533562
 SHA512:
-  metadata.gz: f5c5379451ece56ac1a868092446f66929c83eafb36dace7007b2f479616c3bb2c7a9aff2f77fd1ef25b0bdf5ebb0a431b17308d892ecc4ad3cad54a03700a2e
-  data.tar.gz: e179bd7fb5a421f1de150463d09a04ad369a15eb1f1027c5c21d9fdc837dda5ebed1671cac093e2a584b9c356ad3112881b990d0763394d533ddb7d3e22c7f00
+  metadata.gz: 5731212fc4ad5791bb607f132e660b89f7ff652937029e986040aeee85335939d5a5edf9dd9a21a91f346c2b88711657586747a01727f35eae8318b9b944a62f
+  data.tar.gz: 69514b6b9b3eb085f7fefc672dff0b3a85cdfb64babfad28f6ab788f98ee950e2a2e9fcf2e89ab448b7e8c7137da20ba6ec0e68d375ece1b9c41e5f77d3d6964

data/Gemfile.lock

@@ -1,16 +1,16 @@
 PATH
   remote: .
   specs:
-    substrate_client.rb (0.1.7)
+    substrate_client.rb (0.1.8)
       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.11)
+      substrate_common.rb (~> 0.1.9)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    activesupport (5.2.4.3)
+    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.1)
+    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.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
@@ -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,205 +22,116 @@ Or install it yourself as:
 
 ### Supported rpc methods
 
-#### rpc method list
-
 ```ruby
 require "substrate_client"
 
 client = SubstrateClient.new("wss://kusama-rpc.polkadot.io/")
-client.method_list do |methods|
-  p methods
-end
+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.
-
-
-
-#### rpc methods
-
-But, in order to show the parameters more clearly, some important or frequently used methods are hard-coded:
-
-- 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(&callback)
-
-  Retrieves the header
-
-  
-
-- chain_get_header(block_hash = nil, &callback)
-
-  Retrieves the header for a specific block
-
-  
-
-- chain_get_block(block_hash = nil, &callback)
-
-  Get header and body of a relay chain block
-
-  
-
-- chain_get_block_hash(block_id, &callback)
-
-  Get the block hash for a specific block
-
-  
-
-- chain_get_runtime_version(block_hash = nil, &callback)
-
-  Get the runtime version for a specific block
-
-  
-
-- state_get_metadata(block_hash = nil, &callback)
-
-  Returns the runtime metadata by block
-
-  
-
-- state_get_storage(storage_key, block_hash = nil, &callback)
-
-  Retrieves the storage for a key
-
-  
-
-- system_name(&callback)
-
-  
-
-- system_version(&callback)
-
-  
-
-- 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_all_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.
-
-- chain_unsubscribe_new_heads(subscription)
-
-  Unsubscribe the best header subscription.
-
-
-
-
-- chain_subscribe_finalized_heads(&callback)
-
-  Retrieves the best finalized header via subscription. This will return data continuously until you unsubscribe the subscription.
-
-- chain_unsubscribe_finalized_heads(subscription)
-
-  Unsubscribe the best finalized header subscription.
-
-  
-  
-- 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.
 
-  ```ruby
-  subscription = client.state_subscribe_storage ["0x26aa394eea5630e07c48ae0c9558cef780d41e5e16056765bc8461851072c9d7"] do |data| 
-  	p data 
-  end
-  ```
+The rpc methods can be dynamically called by its name, so you can call it like:
 
-- state_unsubscribe_storage(subscription)
+```ruby
+client.chain_getBlockHash(1024)
+```
 
-  Unsubscribe storage changes.
-
-  
-### Cutom methods based on rpc methods
+### 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, &callback)
-
-- get_metadata(block_hash, &callback)
+- `get_block_number(block_hash)`
 
-- get_block(block_hash=nil, &callback)
+- `get_metadata(block_hash)`
 
-- get_block_events(block_hash, &callback)
+- `get_block(block_hash=nil)`
 
-- subscribe_block_events(&callback, &callback)
+- `get_block_events(block_hash)`
 
-- get_storage(module_name, storage_name, params = nil, block_hash = nil, &callback)
+- `get_storage(module_name, storage_name, params = nil, block_hash = nil)`
 
   ```ruby
-  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
+  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, &callback)
+  
+- `compose_call(module_name, call_name, params, block_hash=nil)`
 
   ```ruby
-  compose_call "Balances", "Transfer", { dest: "0x586cb27c291c813ce74e86a60dad270609abf2fc8bee107e44a80ac00225c409", value: 1_000_000_000_000 }, nil do |hex|
-    p hex
-  end
+  client.compose_call "Balances", "Transfer", { dest: "0x586cb27c291c813ce74e86a60dad270609abf2fc8bee107e44a80ac00225c409", value: 1_000_000_000_000 }, nil
   ```
 
-
-
-## 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)
-...
-```
-
 ## Docker
 
 1. update to latest image
@@ -253,22 +164,13 @@ p client.chain_get_header(block_hash = nil)
    /usr/src/app # ./bin/console
    [1] pry(main)> client = SubstrateClient.new("wss://kusama-rpc.polkadot.io/")
    => #<SubstrateClient:0x000055a78f124f58 ...
-   [2] pry(main)> client.method_list do |methods| p methods end
+   [2] pry(main)> client.methods
    => ...
-   [3] pry(main)> subscription = client.chain_subscribe_new_heads do |data| p data end
-   ...
-   ```
-
-5. Or, SubstrateClientSync:
-
-   ```shell
-   /usr/src/app # ./bin/console
-   [1] pry(main)> client = SubstrateClientSync.new("wss://kusama-rpc.polkadot.io/", spec_name: "kusama")
-   => #<SubstrateClientSync:0x000055a78edfd6e0 @request_id=1, @spec_name="kusama", @url="wss://kusama-rpc.polkadot.io/">
-   [2] pry(main)> client.chain_get_head
+   [3] pry(main)> client.chain_getHead
    => "0xb3c3a220d4639b7c62f179f534b3a66336a115ebc18f13db053f0c57437c45fc"
    ```
 
+
 ## 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,10 +3,10 @@
 require "substrate_client"
 require "json"
 
-url = ARGV[0] || "wss://kusama-rpc.polkadot.io/"
-client = SubstrateClientSync.new(url)
+url = ARGV[0] || "wss://kusama-rpc.polkadot.io"
+client = SubstrateClient.new(url)
 
-block_hash = ARGV[1] || client.chain_get_finalised_head
+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

@@ -1,7 +1,7 @@
 
 class SubstrateClient::Helper
   class << self
-    def generate_storage_hash_from_metadata(metadata, module_name, storage_name, params = nil)
+    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 }
@@ -18,7 +18,8 @@ class SubstrateClient::Helper
         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
+        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
 
@@ -31,7 +32,7 @@ class SubstrateClient::Helper
         raise NotImplementedError
       end
 
-      storage_hash = generate_storage_hash(
+      storage_key = generate_storage_key(
         module_name,
         storage_name,
         params,
@@ -39,12 +40,12 @@ class SubstrateClient::Helper
         hasher2,
         metadata.value.value[:metadata][:version]
       )
-      [storage_hash, return_type]
+      [storage_key, return_type]
     end
 
-    def generate_storage_hash(module_name, storage_name, params = nil, hasher = nil, hasher2 = nil, metadata_version = nil)
+    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_hash = Crypto.twox128(module_name) + Crypto.twox128(storage_name)
+        storage_key = Crypto.twox128(module_name) + Crypto.twox128(storage_name)
 
         params&.each_with_index do |param, index|
           if index == 0
@@ -57,22 +58,22 @@ class SubstrateClient::Helper
 
           param_key = param.hex_to_bytes
           param_hasher = "Twox128" if param_hasher.nil?
-          storage_hash += Crypto.send param_hasher.underscore, param_key
+          storage_key += Crypto.send param_hasher.underscore, param_key
         end
 
-        "0x#{storage_hash}"
+        "0x#{storage_key}"
       else
         # TODO: add test
-        storage_hash = module_name + " " + storage_name
+        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_hash += params_key.hex_to_bytes.bytes_to_utf8 
+          storage_key += params_key.hex_to_bytes.bytes_to_utf8 
         end
 
-        "0x#{Crypto.send( hasher.underscore, storage_hash )}"
+        "0x#{Crypto.send( hasher.underscore, storage_key )}"
       end
     end
 
@@ -114,16 +115,5 @@ class SubstrateClient::Helper
       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

@@ -5,40 +5,42 @@ require "scale.rb"
 require "json"
 require "active_support"
 require "active_support/core_ext/string"
-require "websocket"
 require "helper"
-require "timeout_queue"
-require "substrate_client_sync"
+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
-  class << self
-    attr_accessor :logger
-  end
-  SubstrateClient.logger = Logger.new(STDOUT)
-  SubstrateClient.logger.level = Logger::INFO
 
   attr_accessor :spec_name, :spec_version, :metadata
-  attr_accessor :ws
 
-  def initialize(url, spec_name: nil, onopen: nil)
+  def initialize(url, spec_name: nil)
     @url = url
     @request_id = 1
     @spec_name = spec_name
-    @onopen = onopen
-    Scale::TypeRegistry.instance.load(spec_name)
-
-    init_ws
-
-    at_exit { self.close }
-  end
-
-  def close
-    @ws.close
+    Scale::TypeRegistry.instance.load(spec_name: spec_name)
   end
 
-  def request(method, params, callback: nil, subscription_callback: nil)
+  def request(method, params)
     payload = {
       "jsonrpc" => "2.0",
       "method" => method,
@@ -46,274 +48,98 @@ class SubstrateClient
       "id" => @request_id
     }
 
-    while @callbacks.nil?
-      sleep(1)
+    data = ws_request(@url, payload)
+    if data["error"]
+      raise RpcError, data["error"]
+    else
+      data["result"]
     end
-
-    @callbacks[@request_id] = proc do |data| 
-      if not subscription_callback.nil? && data["result"]
-        @subscription_callbacks[data["result"]] = subscription_callback
-      end
-
-      callback.call data if callback
-    end
-    @ws.send(payload.to_json)
-    @request_id += 1
   end
 
-  def init_runtime(block_hash=nil, &callback)
+  def init_runtime(block_hash=nil)
     # 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
+    runtime_version = self.state_getRuntimeVersion(block_hash)
+    @spec_version = runtime_version["specVersion"]
+    Scale::TypeRegistry.instance.spec_version = @spec_version
 
-  def do_init_runtime(block_hash, &callback)
+    # set current metadata
+    @metadata = self.get_metadata(block_hash)
+    Scale::TypeRegistry.instance.metadata = @metadata.value
+    true
   end
 
-  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"] unless callback.nil?
-      end
-    }
-  end
-
-  def rpc_method(method_name)
-    Helper.real_method_name(method_name.to_s)
+  def invoke(method, *params)
+    # params.reject! { |param| param.nil? }
+    request(method, params)
   end
 
   # ################################################
   # origin rpc methods
   # ################################################
-  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(&callback)
-    invoke rpc_method(__method__), [], callback
-  end
-
-  def chain_get_head(&callback)
-    invoke rpc_method(__method__), [], callback
-  end
-
-  def chain_get_finalised_head(&callback)
-    invoke rpc_method(__method__), [], callback
-  end
-
-  def chain_get_header(block_hash = nil, &callback)
-    invoke rpc_method(__method__), [ block_hash ], callback
-  end
-
-  def chain_get_block(block_hash = nil, &callback)
-    invoke rpc_method(__method__), [ block_hash ], callback
-  end
-
-  def chain_get_block_hash(block_id, &callback)
-    invoke rpc_method(__method__), [ block_id ], callback
-  end
-
-  def chain_get_runtime_version(block_hash = nil, &callback)
-    invoke rpc_method(__method__), [ block_hash ], callback
-  end
-
-  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, &callback)
-    invoke rpc_method(__method__), [ storage_key, block_hash ], callback
-  end
-
-  def system_name(&callback)
-    invoke rpc_method(__method__), [], callback
-  end
-
-  def system_version(&callback)
-    invoke rpc_method(__method__), [], callback
-  end
-
-  def chain_subscribe_all_heads(&callback)
-    request rpc_method(__method__), [], subscription_callback: callback
-  end
-
-  def chain_unsubscribe_all_heads(subscription)
-    invoke rpc_method(__method__), [ subscription ], nil
-  end
-
-  def chain_subscribe_new_heads(&callback)
-    request rpc_method(__method__), [], subscription_callback: callback
-  end
-
-  def chain_unsubscribe_new_heads(subscription)
-    invoke rpc_method(__method__), [ subscription ], nil 
-  end
-
-  def chain_subscribe_finalized_heads(&callback)
-    request rpc_method(__method__), [], subscription_callback: callback
-  end
-
-  def chain_unsubscribe_finalized_heads(subscription)
-    invoke rpc_method(__method__), [ subscription ], nil
-  end
-
-  def state_subscribe_runtime_version(&callback)
-    request rpc_method(__method__), [], subscription_callback: callback
-  end
-
-  def state_unsubscribe_runtime_version(subscription)
-    invoke rpc_method(__method__), [ subscription ], nil
-  end
-
-  def state_subscribe_storage(keys, &callback)
-    request rpc_method(__method__), [keys], subscription_callback: callback
-  end
-
-  def state_unsubscribe_storage(subscription)
-    invoke rpc_method(__method__), [ subscription ], nil 
+  def method_missing(method, *args)
+    invoke method, *args
   end
 
   # ################################################
   # custom methods based on origin rpc methods
   # ################################################
-  def method_list(&callback)
-    self.rpc_methods do |result|
-      callback.call result["methods"].map(&:underscore)
-    end
-  end
-
-  def get_block_number(block_hash, &callback)
-    self.chain_get_header(block_hash) do |header|
-      callback.call header["number"].to_i(16)
-    end
+  def methods
+    invoke("rpc_methods")["methods"]
   end
 
-  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
+  def get_block_number(block_hash)
+    header = self.chain_getHeader(block_hash)
+    header["number"].to_i(16)
   end
 
-  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
+  def get_metadata(block_hash=nil)
+    hex = self.state_getMetadata(block_hash)
+    Scale::Types::Metadata.decode(Scale::Bytes.new(hex))
   end
 
-  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
+  def get_block(block_hash=nil)
+    self.init_runtime(block_hash)
+    block = self.chain_getBlock(block_hash)
+    SubstrateClient::Helper.decode_block(block)
   end
 
-  def subscribe_block_events(&callback)
-    self.chain_subscribe_finalized_heads do |data|
+  def get_block_events(block_hash=nil)
+    self.init_runtime(block_hash)
 
-      block_number = data["params"]["result"]["number"].to_i(16) - 1
-      block_hash = data["params"]["result"]["parentHash"]
+    storage_key =  "0x26aa394eea5630e07c48ae0c9558cef780d41e5e16056765bc8461851072c9d7"
+    events_data = state_getStorage storage_key, block_hash
 
-      EM.defer(
-
-        proc {
-          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
-        },
+    scale_bytes = Scale::Bytes.new(events_data)
+    Scale::Types.get("Vec<EventRecord>").decode(scale_bytes).to_human
+  end
 
-        proc { |result| 
-        },
+  # 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)
 
-        proc { |e|
-          SubstrateClient.logger.error e
-        }
+    storage_key, return_type = SubstrateClient::Helper.generate_storage_key_from_metadata(@metadata, module_name, storage_name, params)
 
-      )
-    end
+    result = self.state_getStorage(storage_key, block_hash)
+    return unless result
+    Scale::Types.get(return_type).decode(Scale::Bytes.new(result))
   end
 
-  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
-      end
-    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
 
-  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
+  # 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
 
-  private
-  def init_ws
-    @ws = Websocket.new(@url,
-
-      onopen: proc do |event|
-        @callbacks = {}
-        @subscription_callbacks = {}
-        @onopen.call event if not @onopen.nil?
-      end,
-
-      onmessage: proc do |event| 
-        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
-            SubstrateClient.logger.error ex.message
-            SubstrateClient.logger.error 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.7"
+  VERSION = "0.1.8"
 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.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,71 +1,71 @@
 --- !ruby/object:Gem::Specification
 name: substrate_client.rb
 version: !ruby/object:Gem::Version
-  version: 0.1.7
+  version: 0.1.8
 platform: ruby
 authors:
 - Wu Minzhe
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-06-11 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.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.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
@@ -146,9 +146,6 @@ files:
 - 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
 homepage: https://github.com/itering/substrate_client.rb
 licenses:

data/lib/substrate_client_sync.rb

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

data/lib/timeout_queue.rb

@@ -1,34 +0,0 @@
-# https://vaneyckt.io/posts/ruby_concurrency_building_a_timeout_queue/
-class TimeoutQueue
-  def initialize
-    @elems = []
-    @mutex = Mutex.new
-    @cond_var = ConditionVariable.new
-  end
-
-  def <<(elem)
-    @mutex.synchronize do
-      @elems << elem
-      @cond_var.signal
-    end
-  end
-
-  def pop(blocking = true, timeout = nil)
-    @mutex.synchronize do
-      if blocking
-        if timeout.nil?
-          while @elems.empty?
-            @cond_var.wait(@mutex)
-          end
-        else
-          timeout_time = Time.now.to_f + timeout
-          while @elems.empty? && (remaining_time = timeout_time - Time.now.to_f) > 0
-            @cond_var.wait(@mutex, remaining_time)
-          end
-        end
-      end
-      raise ThreadError, 'queue empty' if @elems.empty?
-      @elems.shift
-    end
-  end
-end

data/lib/websocket.rb

@@ -1,79 +0,0 @@
-require "faye/websocket"
-require "eventmachine"
-
-class SubstrateClient::Websocket
-  HEARTBEAT_INTERVAL = 3
-  RECONNECT_INTERVAL = 3
-
-  def initialize(url, onopen: nil, onmessage: nil)
-    @url = url
-    @onopen = onopen || proc { p [:open] }
-    @onmessage = onmessage || proc { |event| p [:message, event.data] }
-
-    @thread = Thread.new do
-      EM.run do
-        start_connection
-      end
-      SubstrateClient.logger.info "Event loop stopped"
-    end
-    @heartbeat_thread = start_heartbeat
-  end
-
-  def start_connection
-    SubstrateClient.logger.info "Start to connect"
-    @close = false
-    @missed_heartbeats = 0
-    @ping_id = 0
-    @ws = Faye::WebSocket::Client.new(@url)
-    @ws.on :open do |event|
-      @do_heartbeat = true
-      @onopen.call event
-    end
-
-    @ws.on :message do |event|
-      @onmessage.call event
-    end
-
-    @ws.on :close do |event|
-      # p [:close, event.code, event.reason]
-      if @close == false
-        @do_heartbeat = false
-        sleep RECONNECT_INTERVAL
-        start_connection
-      end
-    end
-
-  end
-
-  def start_heartbeat
-    Thread.new do
-      loop do
-        send_heartbeat if @do_heartbeat
-        sleep HEARTBEAT_INTERVAL
-      end
-    end
-  end
-
-  def send_heartbeat
-    if @missed_heartbeats < 2
-      # puts "ping_#{@ping_id}"
-      @ws.ping @ping_id.to_s do
-        # puts "pong"
-        @missed_heartbeats -= 1
-      end
-      @missed_heartbeats += 1
-      @ping_id += 1
-    end
-  end
-
-  def send(message)
-    @ws.send message
-  end
-
-  def close
-    @close = true
-    Thread.kill @heartbeat_thread
-    Thread.kill @thread
-    @ws = nil
-  end
-end