substrate_client.rb 0.1.2 → 0.1.7

data/lib/substrate_client/version.rb

@@ -1,3 +1,3 @@
 class SubstrateClient
-  VERSION = "0.1.2"
+  VERSION = "0.1.7"
 end

data/lib/substrate_client_sync.rb

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

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

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

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.1"
+  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.2
+  version: 0.1.7
 platform: ruby
 authors:
 - Wu Minzhe
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-04-08 00:00:00.000000000 Z
+date: 2020-06-11 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.1
+        version: 0.2.5
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.2.1
+        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:
@@ -149,6 +134,7 @@ files:
 - ".rspec"
 - ".travis.yml"
 - CODE_OF_CONDUCT.md
+- Dockerfile
 - Gemfile
 - Gemfile.lock
 - LICENSE.txt
@@ -157,9 +143,12 @@ files:
 - bin/console
 - bin/setup
 - exe/metadata
-- exe/substrate_client
+- 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/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)