substrate_client.rb 0.1.3 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5248291da5b3db7dcdcdf913842fceef276c31481346f6da8141960e7d81afdb
-  data.tar.gz: ffafc99e20d6321c4ab9c6231a3bf706ade3cbb17ba0c043c4401fbf45769c76
+  metadata.gz: 5f0802284ca7abb1fd02f502506a00ba67ef2c0d436a1bede7012fc7746196c9
+  data.tar.gz: 2b76f455d30a57c0b36eceecc5cf19e720126e9f071e3899b054a151bb1b122c
 SHA512:
-  metadata.gz: bb06f911fe64f6e7e6425bfb4921427b5b49aabab86dfa57c4b2d48aeb2a2e057bfb33256762d316be30ff87f11d21a3cd89efd25c7d78985cc7cdf001038fb6
-  data.tar.gz: e3199b2b0b72423984d7d2baa6160d5c17565b3fd5563375e59661a246c7ba1b80c7ffc82b963cc836e4486f0a48c6f1d070d7ebc48a9803a630b8c04f4f4a7b
+  metadata.gz: 392f72952f9822de5dff8b6c5df89b7eab52e7bdf38c988f0ea4448c8f6439f74dd06e415dd1fc33c627ed4c74e494c8838c452d3975e1f92c89a8b86e4e68a9
+  data.tar.gz: eda7bacb9cb728d254c3582ef99696689fe03d387b14ad38ad4196b1c4a2ed10eb3f806a8c01c1da9c9143ffe00a15e1597b534c2df9ac1876d62fd63a1be230

data/Gemfile.lock

@@ -1,12 +1,11 @@
 PATH
   remote: .
   specs:
-    substrate_client.rb (0.1.3)
+    substrate_client.rb (0.1.4)
       activesupport (~> 5.2.4)
       eventmachine (~> 1.2.7)
       faye-websocket (~> 0.10.9)
-      scale.rb (~> 0.2.2)
-      substrate_common.rb (~> 0.1.8)
+      scale.rb (~> 0.2.5)
 
 GEM
   remote: https://rubygems.org/
@@ -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.2)
+    scale.rb (0.2.5)
       activesupport (>= 4.0.0)
       json (~> 2.3.0)
       substrate_common.rb (~> 0.1.8)

data/README.md

@@ -20,7 +20,9 @@ Or install it yourself as:
 
 ## Usage
 
-### Api list
+### Supported rpc methods
+
+#### rpc method list
 
 ```ruby
 require "substrate_client"
@@ -28,15 +30,177 @@ require "substrate_client"
 client = SubstrateClient.new("wss://kusama-rpc.polkadot.io/")
 puts client.method_list
 ```
-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.
+
+#### 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.
+
+  ```ruby
+  client.chain_unsubscribe_new_heads(subscription)
+  ```
+
+
+
+- chain_subscribe_finalized_heads(&callback)
+
+  Retrieves the best finalized header via subscription. This will return data continuously until you unsubscribe the subscription.
+
+  ```ruby
+  subscription = client.chain_subscribe_finalized_heads do |data|
+    p data
+  end
+  ```
+
+- chain_unsubscribe_finalized_heads(subscription)
+
+  Unsubscribe the best finalized header subscription.
+
+  ```ruby
+  client.chain_unsubscribe_finalized_heads(subscription)
+  ```
+
+  
+
+- state_subscribe_runtime_version(&callback)
+
+  Retrieves the runtime version via subscription. 
+
+- 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)
+
+- get_metadata(block_hash)
+
+- get_block(block_hash=nil)
+
+- get_block_events(block_hash)
+
+- subscribe_block_events(&callback)
+
+- get_storage(module_name, storage_name, params = nil, block_hash = nil)
+
+  ```ruby
+  client.get_storage("Sudo", "Key")
+  client.get_storage("Balances", "TotalIssuance")
+  client.get_storage("System", "Account", ["0xd43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d"])
+  client.get_storage("ImOnline", "AuthoredBlocks", [2818, "0x749ddc93a65dfec3af27cc7478212cb7d4b0c0357fef35a0163966ab5333b757"])
+  ```
+
+- compose_call(module_name, call_name, params, block_hash=nil)
+
+  ```ruby
+  compose_call "Balances", "Transfer", { dest: "0x586cb27c291c813ce74e86a60dad270609abf2fc8bee107e44a80ac00225c409", value: 1_000_000_000_000 }
+  ```
 
-## TODO
 
-- [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

@@ -9,4 +9,5 @@ block_hash = ARGV[1]
 
 client = SubstrateClient.new(url)
 client.init(block_hash)
-puts JSON.pretty_generate(client.metadata.value.value)
+metadata = client.get_metadata(block_hash)
+puts JSON.pretty_generate(metadata.value)

data/lib/substrate_client.rb

@@ -1,109 +1,263 @@
 require "substrate_client/version"
 
-require "substrate_common"
-require "scale"
-
+require "scale.rb"
 require "faye/websocket"
 require "eventmachine"
 require "json"
 require "active_support"
 require "active_support/core_ext/string"
 
-def ws_request(url, payload)
-  result = nil
-
-  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
-    end
-  end
-
-  result
-end
-
 class SubstrateClient
+  class RpcError < StandardError; end
+
   attr_accessor :spec_name, :spec_version, :metadata
+  attr_reader :ws
 
-  def initialize(url)
+  def initialize(url: , spec_name: nil)
     @url = url
     @request_id = 1
+    @spec_name = spec_name
+    Scale::TypeRegistry.instance.load(spec_name)
+
+    init_ws
   end
 
-  # TODO: error
-  def request(method, params)
+  def request(method, params, subscription_callback=nil)
+    queue = Queue.new
+
     payload = {
       "jsonrpc" => "2.0",
       "method" => method,
       "params" => params,
       "id" => @request_id
     }
+
+    @callbacks[@request_id] = proc { |data| queue << data }
+    @ws.send(payload.to_json)
     @request_id += 1
-    ws_request(@url, payload)
+    data = queue.pop
+
+    if not subscription_callback.nil? && data["result"]
+      @subscription_callbacks[data["result"]] = subscription_callback
+    end
+
+    if data["error"]
+      raise RpcError, data["error"]
+    else
+      data["result"]
+    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
+
+    # 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
 
-  # ############################
-  # native rpc methods support
-  # ############################
+  def rpc_method(method_name)
+    SubstrateClient.real_method_name(method_name.to_s)
+  end
+
+  # ################################################
+  # origin rpc methods
+  # ################################################
   def method_missing(method, *args)
-    data = request(SubstrateClient.real_method_name(method), args)
-    data["result"]
+    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
   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"
+    self.rpc_methods["methods"].map(&:underscore)
   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"]
-
-    Scale::TypeRegistry.instance.load(spec_name, spec_version)
-    @metadata = self.get_metadata(block_hash)
-    true
+  def get_block_number(block_hash)
+    header = self.chain_get_header(block_hash)
+    header["number"].to_i(16)
   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]
+    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
+  end
+
+  def get_block_events(block_hash)
+    self.init_runtime(block_hash: block_hash)
+
+    storage_key =  "0x26aa394eea5630e07c48ae0c9558cef780d41e5e16056765bc8461851072c9d7"
+    events_data = state_get_storage storage_key, block_hash
+
+    scale_bytes = Scale::Bytes.new(events_data)
+    Scale::Types.get("Vec<EventRecord>").decode(scale_bytes).to_human
+  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
 
-  # 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)
+  # 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)
 
-    # TODO: uninit raise a exception
     # find the storage item from metadata
-    metadata_modules = metadata[:modules]
+    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_function_name }
-    raise "Storage item '#{storage_function_name}' not exist. \n#{metadata_module.inspect}" unless storage_item
+    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]
@@ -129,48 +283,66 @@ class SubstrateClient
 
     storage_hash = SubstrateClient.generate_storage_hash(
       module_name,
-      storage_function_name,
+      storage_name,
       params,
       hasher,
       hasher2,
-      metadata[:version]
+      metadata.value.value[:metadata][:version]
     )
 
-    # puts storage_hash
-
-    result = self.state_get_storage_at(storage_hash, block_hash)
+    result = self.state_get_storage(storage_hash, 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
+
+  # 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(storage_module_name, storage_function_name, params = nil, hasher = nil, hasher2 = nil, metadata_version = nil)
+    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(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
+        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 = storage_module_name + " " + storage_function_name
+        storage_hash = module_name + " " + storage_name
 
         unless params.nil?
           params = [params] if params.class != ::Array
@@ -193,6 +365,57 @@ class SubstrateClient
 
   end
 
+  private
+  def init_ws
+    queue = Queue.new
 
-end
+    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
+  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
+  end
+
+end

data/lib/substrate_client/version.rb

@@ -1,3 +1,3 @@
 class SubstrateClient
-  VERSION = "0.1.3"
+  VERSION = "0.1.4"
 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.5"
 
   spec.add_development_dependency "bundler", "~> 1.17"
   spec.add_development_dependency "rake", ">= 12.3.3"

metadata

@@ -1,29 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: substrate_client.rb
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.4
 platform: ruby
 authors:
 - Wu Minzhe
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-04-08 00:00:00.000000000 Z
+date: 2020-05-14 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
   requirement: !ruby/object:Gem::Requirement
@@ -72,14 +58,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.2.2
+        version: 0.2.5
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.2.2
+        version: 0.2.5
 - !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:
@@ -157,7 +142,6 @@ files:
 - bin/console
 - bin/setup
 - exe/metadata
-- exe/substrate_client
 - 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)