nano_rpc 0.14.0 → 0.15.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5424fe4a2dbca86499f38bfb5f6edc927b1b0a491e4ccb441944f7d3ce6c06c4
-  data.tar.gz: '08345ae8d7e10c487999192e88deeea27f171926b0a9aaa86ef641ccd37ef1cb'
+  metadata.gz: 384dfb2767f15ba663867d79e98d771de4743b29650acf636f8dbb05ca13712b
+  data.tar.gz: b98fb36169c35288da75d2da4902f79d275ae9a88197ba746281baa9bfa7c6ad
 SHA512:
-  metadata.gz: 4b01154aaded6d5f27d846f0b3147b162a26c2a6d918fd7074de848164cf32be1cc4f9ba6987784420fdf385e6feb0cbe44c09143992a09e85035191d2379739
-  data.tar.gz: 044a5c806cf7d2661856f09068e46a9f77ccabc9e8e86700de085d1260bf603d5eece7d4d5016abafb337c6ca05a994431d0952fd50eaf2d8f13002f08953cc2
+  metadata.gz: d39b16abbafe3347448eca3341dcc98918149e6df0724078c2e45fdb444f4a352620b50ec2de0d8f4f40a6fa70448a5e520c6299599024fc9908ff90aede288b
+  data.tar.gz: 166a68643c927e662cf33372882e3978135e3ab17a9e5a276eb52e3340754f7e9414cda652b507988c6a66a6d4853737e7a5ffceb332ccdd3fb9015e254d9ba7

data/README.md

@@ -30,55 +30,7 @@ Or install it yourself as:
 
 ## Usage
 
-There are two ways to use this gem.  You can make direct RPC calls using Ruby hashes or you can use proxy objects for terser code.
-
-### Raw RPC Calls
-
-The NanoRpc::Node object exposes raw Remote Procedure Call methods according to the [Nano RPC Docs](https://github.com/clemahieu/raiblocks/wiki/RPC-protocol).
-
-Every method requires an `action`, which is passed as the first argument to `call`.  Depending on the action, there may be additional required or optional parameters that are passed as an options hash.
-
-First setup the node connection:
-
-```ruby
-# Connect to the default node (localhost:7076)
-node = NanoRpc.node
-
-# or connect to a custom node
-node = NanoRpc::Node.new(host: 'mynanonode', port: 1234)
-```
-
-If you're using [Nanode](https://www.nanode.co/) or similar service that requires `Authorization` key in HTTP header, you can specify it using `auth`.
-
-```ruby
-node = NanoRpc::Node.new(auth: 'someauthkey')
-```
-
-You can also specify custom headers as a hash. These will be sent with every RPC request.
-
-```ruby
-node = NanoRpc::Node.new(headers: { 'Authorization' => 'someauthkey' })
-```
-
-Once the node is setup, make a `call`, passing the action and data:
-
-```ruby
-node.call(:account_balance, account: 'xrb_1234')
-# => {"balance"=>100, "pending"=>0}
-```
-
-Response data are provided as [Hashie](https://github.com/intridea/hashie) objects with integer coercion, indifferent access, and method access.
-
-```ruby
-data = node.call(:account_balance, account: 'xrb_1234')
-# => {"balance"=>100, "pending"=>0}
-data.balance
-# => 100
-data[:balance]
-# => 100
-data['balance']
-# => 100
-```
+There are two ways to use this gem.  You can use proxy objects that expose helper methods or you make direct RPC calls using Ruby hashes.
 
 ### Proxy Objects / Helper Methods
 
@@ -127,6 +79,58 @@ To convert from Nano to raw and back, use `#to_raw` and `#to_nano`, available on
 
 For a comprehensive guide, see the [Wiki](https://github.com/jcraigk/ruby_nano_rpc/wiki).
 
+### Direct RPC Calls
+
+The NanoRpc::Node object exposes raw Remote Procedure Call methods according to the [Nano RPC Docs](https://github.com/clemahieu/raiblocks/wiki/RPC-protocol).
+
+Every method requires an `action`, which is passed as the first argument to `call`.  Depending on the action, there may be additional required or optional parameters that are passed as an options hash.
+
+First setup the node connection:
+
+```ruby
+# Connect to the default node (localhost:7076)
+node = NanoRpc.node
+
+# or connect to a custom node
+node = NanoRpc::Node.new(host: 'mynanonode', port: 1234)
+```
+
+If you're using [Nanode](https://www.nanode.co/) or similar service that requires `Authorization` key in HTTP header, you can specify it using `auth`:
+
+```ruby
+node = NanoRpc::Node.new(auth: 'someauthkey')
+```
+
+You can also specify custom headers as a hash and they will be sent with every RPC request:
+
+```ruby
+node = NanoRpc::Node.new(headers: { 'Authorization' => 'someauthkey' })
+```
+
+The default timeout for each request is 20 seconds but you can specify a custom value:
+
+```ruby
+node = NanoRpc::Node.new(timeout: 10)
+```
+
+Once the node is setup, use the `call` method, passing in action and params:
+
+```ruby
+node.call(:account_balance, account: 'xrb_1234')
+# => {"balance"=>100, "pending"=>0}
+```
+
+Response data are provided as [Hashie](https://github.com/intridea/hashie) objects with integer coercion, indifferent access, and method access.
+
+```ruby
+data.balance
+# => 100
+data[:balance]
+# => 100
+data['balance']
+# => 100
+```
+
 ## Credits
 
 Logo created by Andrei Luca ([Twitter](https://twitter.com/lucandrei_))

data/lib/nano_rpc/node.rb

@@ -6,159 +6,194 @@ module NanoRpc
   def self.node
     @node ||= Node.new
   end
+end
 
-  class Node
-    include NanoRpc::Proxy
-    include NanoRpc::NodeHelper
-
-    attr_reader :host, :port, :auth, :headers, :node
-
-    def initialize(host: 'localhost', port: 7076, auth: nil, headers: nil)
-      @host = host
-      @port = port
-      @auth = auth
-      @headers = headers
-      @node = self
+class NanoRpc::Node
+  include NanoRpc::Proxy
+  include NanoRpc::NodeHelper
+
+  attr_reader :host, :port, :auth, :headers, :node, :timeout
+
+  DEFAULT_TIMEOUT = 60
+
+  def initialize(
+    host: 'localhost',
+    port: 7076,
+    auth: nil,
+    headers: nil,
+    timeout: DEFAULT_TIMEOUT
+  )
+    @host = host
+    @port = port
+    @auth = auth
+    @headers = headers
+    @timeout = timeout
+    @node = self
+
+    super
+  end
 
-      super
-    end
+  def call(action, params = {})
+    args = { action: action }
+    args.merge!(params) if params.is_a?(Hash)
+    args = extract_proxy_args(args)
+    rpc_post(args)
+  end
 
-    # Condense host/port on object inspection
-    def inspect
-      "#{inspect_prefix}, @url=\"#{@host}:#{port}\">"
-    end
+  # Condense host/port on object inspection
+  def inspect
+    "#{inspect_prefix}, @url=\"#{@host}:#{port}\">"
+  end
 
-    def call(action, params = {})
-      args = { action: action }
-      args.merge!(params) if params.is_a?(Hash)
-      args = extract_proxy_args(args)
-      rpc_post(args)
+  proxy_method :available_supply
+  proxy_method :block, required: %i[hash]
+  proxy_method :block_account, required: %i[hash]
+  proxy_method :block_confirm, required: %i[hash]
+  proxy_method :block_count
+  proxy_method :block_count_type
+  proxy_method :block_create,
+               required: %i[type key representative source],
+               optional: %i[work]
+  proxy_method :blocks, required: %i[hashes]
+  proxy_method :blocks_info,
+               required: %i[hashes],
+               optional: %i[pending source balance]
+  proxy_method :bootstrap, required: %i[address port]
+  proxy_method :bootstrap_any
+  proxy_method :chain, required: %i[block count]
+  proxy_method :confirmation_history
+  proxy_method :deterministic_key, required: %i[seed index]
+  proxy_method :frontier_count
+  proxy_method :history, required: %i[hash count]
+  proxy_method :keepalive, required: %i[address port]
+  proxy_method :key_create
+  proxy_method :key_expand, required: %i[key]
+  proxy_method :krai_from_raw, required: %i[amount]
+  proxy_method :krai_to_raw, required: %i[amount]
+  proxy_method :mrai_from_raw, required: %i[amount]
+  proxy_method :mrai_to_raw, required: %i[amount]
+  proxy_method :payment_wait, required: %i[account amount timeout]
+  proxy_method :peers
+  proxy_method :pending_exists, required: %i[hash]
+  proxy_method :process, required: %i[block]
+  proxy_method :rai_from_raw, required: %i[amount]
+  proxy_method :rai_to_raw, required: %i[amount]
+  proxy_method :receive_minimum
+  proxy_method :receive_minimum_set, required: %i[amount]
+  proxy_method :representatives
+  proxy_method :representatives_online
+  proxy_method :republish,
+               required: %i[hash],
+               optional: %i[count sources destinations]
+  proxy_method :search_pending, required: %i[wallet]
+  proxy_method :search_pending_all
+  proxy_method :stats, required: %i[type]
+  proxy_method :stop
+  proxy_method :successors, required: %i[block count]
+  proxy_method :unchecked, required: %i[count]
+  proxy_method :unchecked_clear
+  proxy_method :unchecked_get, required: %i[hash]
+  proxy_method :unchecked_keys, required: %i[key count]
+  proxy_method :receive_minimum
+  proxy_method :receive_minimum_set, required: %i[amount]
+  proxy_method :representatives
+  proxy_method :representatives_online
+  proxy_method :republish,
+               required: %i[hash],
+               optional: %i[count sources destinations]
+  proxy_method :search_pending, required: %i[wallet]
+  proxy_method :search_pending_all
+  proxy_method :stats, required: %i[type]
+  proxy_method :stop
+  proxy_method :successors, required: %i[block count]
+  proxy_method :unchecked, required: %i[count]
+  proxy_method :unchecked_clear
+  proxy_method :unchecked_get, required: %i[hash]
+  proxy_method :unchecked_keys, required: %i[key count]
+  proxy_method :version
+  proxy_method :wallet_create
+  proxy_method :work_cancel, required: %i[hash]
+  proxy_method :work_generate,
+               required: %i[hash],
+               optional: %i[use_peers]
+  proxy_method :work_peer_add, required: %i[address port]
+  proxy_method :work_peers
+  proxy_method :work_peers_clear
+  proxy_method :work_validate, required: %i[work hash]
+
+  private
+
+  def extract_proxy_args(args)
+    args.each do |k, v|
+      m = proxy_method(v)
+      args[k] = v.send(m) if m
     end
+    args
+  end
 
-    proxy_method :available_supply
-    proxy_method :block, required: %i[hash]
-    proxy_method :block_account, required: %i[hash]
-    proxy_method :block_confirm, required: %i[hash]
-    proxy_method :block_count
-    proxy_method :block_count_type
-    proxy_method :block_create,
-                 required: %i[type key representative source],
-                 optional: %i[work]
-    proxy_method :blocks, required: %i[hashes]
-    proxy_method :blocks_info,
-                 required: %i[hashes],
-                 optional: %i[pending source balance]
-    proxy_method :bootstrap, required: %i[address port]
-    proxy_method :bootstrap_any
-    proxy_method :chain, required: %i[block count]
-    proxy_method :confirmation_history
-    proxy_method :deterministic_key, required: %i[seed index]
-    proxy_method :frontier_count
-    proxy_method :history, required: %i[hash count]
-    proxy_method :keepalive, required: %i[address port]
-    proxy_method :key_create
-    proxy_method :key_expand, required: %i[key]
-    proxy_method :krai_from_raw, required: %i[amount]
-    proxy_method :krai_to_raw, required: %i[amount]
-    proxy_method :mrai_from_raw, required: %i[amount]
-    proxy_method :mrai_to_raw, required: %i[amount]
-    proxy_method :payment_wait, required: %i[account amount timeout]
-    proxy_method :peers
-    proxy_method :pending_exists, required: %i[hash]
-    proxy_method :process, required: %i[block]
-    proxy_method :rai_from_raw, required: %i[amount]
-    proxy_method :rai_to_raw, required: %i[amount]
-    proxy_method :receive_minimum
-    proxy_method :receive_minimum_set, required: %i[amount]
-    proxy_method :representatives
-    proxy_method :representatives_online
-    proxy_method :republish,
-                 required: %i[hash],
-                 optional: %i[count sources destinations]
-    proxy_method :search_pending, required: %i[wallet]
-    proxy_method :search_pending_all
-    proxy_method :stats, required: %i[type]
-    proxy_method :stop
-    proxy_method :successors, required: %i[block count]
-    proxy_method :unchecked, required: %i[count]
-    proxy_method :unchecked_clear
-    proxy_method :unchecked_get, required: %i[hash]
-    proxy_method :unchecked_keys, required: %i[key count]
-    proxy_method :version
-    proxy_method :wallet_create
-    proxy_method :work_cancel, required: %i[hash]
-    proxy_method :work_generate,
-                 required: %i[hash],
-                 optional: %i[use_peers]
-    proxy_method :work_peer_add, required: %i[address port]
-    proxy_method :work_peers
-    proxy_method :work_peers_clear
-    proxy_method :work_validate, required: %i[work hash]
-
-    private
-
-    def extract_proxy_args(args)
-      args.each do |k, v|
-        m = proxy_method(v)
-        args[k] = v.send(m) if m
-      end
-      args
+  def proxy_method(obj)
+    if obj.is_a?(NanoRpc::Wallet)
+      :seed
+    elsif obj.is_a?(NanoRpc::Accounts)
+      :addresses
+    elsif obj.is_a?(NanoRpc::Account)
+      :address
     end
+  end
 
-    def proxy_method(obj)
-      if obj.is_a?(NanoRpc::Wallet)
-        :seed
-      elsif obj.is_a?(NanoRpc::Accounts)
-        :addresses
-      elsif obj.is_a?(NanoRpc::Account)
-        :address
-      end
-    end
+  def rpc_post(params)
+    response = rest_client_post(params)
+    ensure_status_success(response)
+    data = NanoRpc::Response.new(JSON[response&.body])
+    ensure_valid_response(data)
 
-    def rpc_post(params)
-      response = rest_client_post(url, params)
-      ensure_status_success(response)
-      data = NanoRpc::Response.new(JSON[response&.body])
-      ensure_valid_response(data)
+    data
+  end
 
-      data
-    end
+  def request_headers
+    h = headers || {}
+    h['Content-Type'] = 'json'
+    h['Authorization'] = auth unless auth.nil?
+    h
+  end
 
-    def request_headers
-      h = headers || {}
-      h['Content-Type'] = 'json'
-      h['Authorization'] = auth unless auth.nil?
-      h
-    end
+  def rest_client_post(params)
+    execute_post(params)
+  rescue Errno::ECONNREFUSED
+    raise NanoRpc::NodeConnectionFailure,
+          "Node connection failure at #{url}"
+  rescue RestClient::Exceptions::OpenTimeout
+    raise NanoRpc::NodeOpenTimeout,
+          'Node failed to respond in time'
+  end
 
-    def rest_client_post(url, params)
-      RestClient.post(url, params.to_json, request_headers)
-    rescue Errno::ECONNREFUSED
-      raise NanoRpc::NodeConnectionFailure,
-            "Node connection failure at #{url}"
-    rescue RestClient::Exceptions::OpenTimeout
-      raise NanoRpc::NodeOpenTimeout,
-            'Node failed to respond in time'
-    end
+  def execute_post(params)
+    RestClient::Request.execute(
+      method: :post,
+      url: url,
+      headers: request_headers,
+      payload: params.to_json,
+      timeout: timeout
+    )
+  end
 
-    def url
-      if host.start_with?('http://', 'https://')
-        "#{host}:#{port}"
-      else
-        "http://#{host}:#{port}"
-      end
+  def url
+    if host.start_with?('http://', 'https://')
+      "#{host}:#{port}"
+    else
+      "http://#{host}:#{port}"
     end
+  end
 
-    def ensure_status_success(response)
-      return if response&.code == 200
-      raise NanoRpc::BadRequest,
-            "Error response from node: #{JSON[response&.body]}"
-    end
+  def ensure_status_success(response)
+    return if response&.code == 200
+    raise NanoRpc::BadRequest,
+          "Error response from node: #{JSON[response&.body]}"
+  end
 
-    def ensure_valid_response(data)
-      return unless data['error']
-      raise NanoRpc::InvalidRequest,
-            "Invalid request: #{data['error']}"
-    end
+  def ensure_valid_response(data)
+    return unless data['error']
+    raise NanoRpc::InvalidRequest,
+          "Invalid request: #{data['error']}"
   end
 end

data/lib/nano_rpc/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module NanoRpc
-  VERSION = '0.14.0'
+  VERSION = '0.15.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: nano_rpc
 version: !ruby/object:Gem::Version
-  version: 0.14.0
+  version: 0.15.0
 platform: ruby
 authors:
 - Justin Craig-Kuhn (JCK)