substrate_client.rb 0.1.2 → 0.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a1cec3e9d753a9d61bace4bcdcde8aba48148fe3b278453c2402272752043739
-  data.tar.gz: ec5b2e682cb056ac2d172798b4a32de06755ae22dcc06aec8c691141f684d128
+  metadata.gz: af04674d5e75dbafa82eade829b5798fe87e015a51a8edb63d7845cdd38c27b9
+  data.tar.gz: 8afa612ea099169396f4ef3155c5158ba188b09ff602b5d515fcf6deadfe5739
 SHA512:
-  metadata.gz: e5476a44ef876d98d9ebbcbcaa46fcb3072b86667b0d4bc90a808bd1415fafd2b85cea74792366ca599ae521660898d19de21ad2856324c2b185707c638dbd26
-  data.tar.gz: bda69cc1f2f0bf6f9f12535550c266f295e502bb55c281c54d9f85296df5b7bc57b330ce24d1ad480cba342ab3916480b1ce72d8b734ebaaee23bcab5a466fec
+  metadata.gz: f5c5379451ece56ac1a868092446f66929c83eafb36dace7007b2f479616c3bb2c7a9aff2f77fd1ef25b0bdf5ebb0a431b17308d892ecc4ad3cad54a03700a2e
+  data.tar.gz: e179bd7fb5a421f1de150463d09a04ad369a15eb1f1027c5c21d9fdc837dda5ebed1671cac093e2a584b9c356ad3112881b990d0763394d533ddb7d3e22c7f00

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.2)
+    substrate_client.rb (0.1.7)
       activesupport (~> 5.2.4)
       eventmachine (~> 1.2.7)
       faye-websocket (~> 0.10.9)
-      scale.rb (~> 0.2.1)
-      substrate_common.rb (~> 0.1.8)
+      scale.rb (~> 0.2.5)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    activesupport (5.2.4.2)
+    activesupport (5.2.4.3)
       concurrent-ruby (~> 1.0, >= 1.0.2)
       i18n (>= 0.7, < 2)
       minitest (~> 5.1)
@@ -29,7 +28,7 @@ GEM
       concurrent-ruby (~> 1.0)
     json (2.3.0)
     method_source (0.9.2)
-    minitest (5.14.0)
+    minitest (5.14.1)
     pry (0.12.2)
       coderay (~> 1.1.0)
       method_source (~> 0.9.0)
@@ -47,7 +46,7 @@ GEM
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.9.0)
     rspec-support (3.9.2)
-    scale.rb (0.2.1)
+    scale.rb (0.2.5)
       activesupport (>= 4.0.0)
       json (~> 2.3.0)
       substrate_common.rb (~> 0.1.8)

data/README.md

@@ -20,23 +20,254 @@ Or install it yourself as:
 
 ## Usage
 
-### Api list
+### Supported rpc methods
+
+#### rpc method list
 
 ```ruby
 require "substrate_client"
 
 client = SubstrateClient.new("wss://kusama-rpc.polkadot.io/")
-puts client.method_list
+client.method_list do |methods|
+  p methods
+end
 ```
-The rpc api methods is dynamically generated, so the methods returned by this method can be called.
+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
+  ```
+
+- state_unsubscribe_storage(subscription)
+
+  Unsubscribe storage changes.
+
+  
+### Cutom methods based on rpc 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(block_hash=nil, &callback)
+
+- get_block_events(block_hash, &callback)
+
+- subscribe_block_events(&callback, &callback)
+
+- get_storage(module_name, storage_name, params = nil, block_hash = nil, &callback)
+
+  ```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
+  ```
+
+- compose_call(module_name, call_name, params, block_hash=nil, &callback)
+
+  ```ruby
+  compose_call "Balances", "Transfer", { dest: "0x586cb27c291c813ce74e86a60dad270609abf2fc8bee107e44a80ac00225c409", value: 1_000_000_000_000 }, nil do |hex|
+    p hex
+  end
+  ```
+
+
+
+## Synchronized client
+
+There is also a synchronized version of the client, which is disconnected every time the data is retrieved. It is very convenient in some situations. But this version cannot use the subscription interface.
+
+```ruby
+client = SubstrateClientSync.new "wss://kusama-rpc.polkadot.io/"
+p client.method_list
+p client.chain_get_head
+p client.chain_get_finalised_head
+p client.chain_get_header(block_hash = nil)
+...
+```
+
+## 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.method_list do |methods| p methods end
+   => ...
+   [3] pry(main)> subscription = client.chain_subscribe_new_heads do |data| p data end
+   ...
+   ```
 
-## TODO
+5. Or, SubstrateClientSync:
 
-- [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
+   ```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
+   => "0xb3c3a220d4639b7c62f179f534b3a66336a115ebc18f13db053f0c57437c45fc"
+   ```
 
 ## 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 = SubstrateClientSync.new(url)
 
-client = SubstrateClient.new(url)
-client.init(block_hash)
-puts JSON.pretty_generate(client.metadata.value.value)
+block_hash = ARGV[1] || client.chain_get_finalised_head
+
+metadata = client.get_metadata(block_hash)
+puts JSON.pretty_generate(metadata.value.to_human)

data/lib/helper.rb

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