substrate_client.rb 0.1.2 → 0.1.7

data/lib/substrate_client.rb

@@ -1,198 +1,319 @@
 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 "websocket"
+require "helper"
+require "timeout_queue"
+require "substrate_client_sync"
 
-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
+class SubstrateClient
+  class RpcError < StandardError; end
+  class RpcTimeout < StandardError; end
+  class << self
+    attr_accessor :logger
   end
+  SubstrateClient.logger = Logger.new(STDOUT)
+  SubstrateClient.logger.level = Logger::INFO
 
-  result
-end
-
-class SubstrateClient
   attr_accessor :spec_name, :spec_version, :metadata
+  attr_accessor :ws
 
-  def initialize(url)
+  def initialize(url, spec_name: nil, onopen: 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
 
-  # TODO: error
-  def request(method, params)
+  def close
+    @ws.close
+  end
+
+  def request(method, params, callback: nil, subscription_callback: nil)
     payload = {
       "jsonrpc" => "2.0",
       "method" => method,
       "params" => params,
       "id" => @request_id
     }
+
+    while @callbacks.nil?
+      sleep(1)
+    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
-    ws_request(@url, payload)
   end
 
-  # ############################
-  # native rpc methods support
-  # ############################
-  def method_missing(method, *args)
-    data = request(SubstrateClient.real_method_name(method), args)
-    data["result"]
+  def init_runtime(block_hash=nil, &callback)
+    # 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
+
+  def do_init_runtime(block_hash, &callback)
+  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)
   end
 
   # ################################################
-  # custom methods wrapped from native rpc methods
+  # origin rpc methods
   # ################################################
-  def method_list
-    methods = self.rpc_methods["methods"].map(&:underscore)
-    methods << "method_list"
-    methods << "get_storage_at"
-  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
-  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]
-  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
+  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 
+  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
 
-    storage_hash = SubstrateClient.generate_storage_hash(
-      module_name,
-      storage_function_name,
-      params,
-      hasher,
-      hasher2,
-      metadata[:version]
-    )
+  def get_block_number(block_hash, &callback)
+    self.chain_get_header(block_hash) do |header|
+      callback.call header["number"].to_i(16)
+    end
+  end
 
-    # puts storage_hash
+  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
+  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
+  end
 
-    result = self.state_get_storage_at(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
+  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
   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
+  def subscribe_block_events(&callback)
+    self.chain_subscribe_finalized_heads do |data|
+
+      block_number = data["params"]["result"]["number"].to_i(16) - 1
+      block_hash = data["params"]["result"]["parentHash"]
 
-            param_key = param.hex_to_bytes
-            param_hasher = "Twox128" if param_hasher.nil?
-            storage_hash += Crypto.send param_hasher.underscore, param_key
+      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
-        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
+        proc { |result| 
+        },
 
-        "0x#{Crypto.send( hasher.underscore, storage_hash )}"
-      end
+        proc { |e|
+          SubstrateClient.logger.error e
+        }
+
+      )
     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
+  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
+  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
   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
 
-end
+          rescue => ex
+            SubstrateClient.logger.error ex.message
+            SubstrateClient.logger.error ex.backtrace.join("\n")
+          end
+        end
+      end
 
+    )
+  end
+
+end