nano_rpc 0.9.0 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 31ae67733c43baa9c7abad5602ce086a4869f97b758b2fc6dfa2936fe2e1faac
-  data.tar.gz: 65972b80fc7b29dc8e1dd8d01897f3ef3758f32cca06bece13048a1253d343ea
+  metadata.gz: 4a14ad62aa7895381a7d304358397e3e0c84895e98a910d6958d8f89f0caf80c
+  data.tar.gz: f873b576248b45a70bcddca71721215dde596950c9ce1833918b1dfa66a72133
 SHA512:
-  metadata.gz: 8320b2affa49d105293af12ffdf551928d5f5242a04087d3ef45714d74e8f18a9db6cfe6c0e4b612a55bc649df14077ade65dc70c1cae667c87d2afff9418a06
-  data.tar.gz: a23042ec1d7ce8fb19b19f10ba621f1e8dfa94461327d3b813df7def5db131f6bdd9ef5bbcf8262eee459566cf2e801d7d570753a44e4d9129e508de7a6921c6
+  metadata.gz: baef53c6d16c0ffc55bc649335dbf61c339a7e3638bf5d05bf199b9de990e108938af88ec01888275efe99e61f96dfb8ef7862b3b861a8264297adec1ba6534a
+  data.tar.gz: 583673b49fc417a05d8b0c08d9caa8ad9bfad57eabb26bbaff0e735222b27ea6f6f5c564c76cc1ee256024412c0e4416dcce7b5428a5483a9c253b9d862b1dda

data/.rubocop.yml

@@ -1,8 +1,15 @@
 AllCops:
   TargetRubyVersion: 2.5.0
   Exclude:
-    - 'bin/*'
+    - bin/*
   DisplayCopNames: true
+Metrics/BlockLength:
+  Exclude:
+    - spec/**/*
+Metrics/ModuleLength:
+  Max: 200
+Metrics/ClassLength:
+  Max: 200
 Style/ClassAndModuleChildren:
   EnforcedStyle: compact
 Style/EmptyMethod:

data/README.md

@@ -1,3 +1,5 @@
+[![Maintainability](https://api.codeclimate.com/v1/badges/a99a88d28ad37a79dbf6/maintainability)](https://codeclimate.com/github/codeclimate/codeclimate/maintainability)
+
 ![Ruby Nano RPC Logo](https://i.imgur.com/ihmmYcp.png)
 
 Nano RPC is a Ruby wrapper for making Remote Procedure Calls against Nano digital currency nodes. Arbitrary RPC access is provided along with proxy objects that expose helper methods ([Wiki](https://github.com/jcraigk/ruby_nano_rpc/wiki)).
@@ -22,90 +24,89 @@ Or install it yourself as:
 
 ## Usage
 
-There are two ways to use this gem.  You can make direct calls to the RPC client using Ruby hashes or you can use proxy objects for terser code.
+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 RCP client exposes raw Remote Procedure Call methods according to the [Nano RPC Docs](https://github.com/clemahieu/raiblocks/wiki/RPC-protocol).
+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 client:
+First setup the node connection:
 
 ```ruby
 # Connect to the default node (localhost:7076)
-client = Nano.client
+node = NanoRpc.node
 
 # or connect to a custom node
-client = Nano::Client.new(host: 'mynanonode', port: 1234)
+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
-client = Nano::Client.new(auth: 'someauthkey')
+node = NanoRpc::Node.new(auth: 'someauthkey')
 ```
 
 You can also specify custom headers as a hash. These will be sent with every RPC request.
 
 ```ruby
-client = Nano::Client.new(headers: { 'Authorization' => 'someauthkey' })
+node = NanoRpc::Node.new(headers: { 'Authorization' => 'someauthkey' })
 ```
 
-Once the client is created, make a `call`, passing the action and data:
+Once the node is setup, make a `call`, passing the action and data:
 
 ```ruby
-  client.call(:account_balance, account: 'xrb_someaddress1234')
-  # => {"balance"=>100, "pending"=>0}
-````
+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 = client.call(:account_balance, account: 'xrb_someaddress1234')
-  # => {"balance"=>100, "pending"=>0}
-  data.balance
-  # => 100
-  data[:balance]
-  # => 100
-  data['balance']
-  # => 100
-````
+data = node.call(:account_balance, account: 'xrb_1234')
+# => {"balance"=>100, "pending"=>0}
+data.balance
+# => 100
+data[:balance]
+# => 100
+data['balance']
+# => 100
+```
 
 ### Proxy Objects / Helper Methods
 
 Proxy objects are provided to ease interaction with the API by providing logically grouped helper methods. Here we do not strictly follow the grouping as expressed in the [Nano RPC Docs](https://github.com/clemahieu/raiblocks/wiki/RPC-protocol).  Instead, the following objects are provided:
 
-* [Nano::Account](https://github.com/jcraigk/ruby_nano_rpc/wiki/Nano::Account)
-* [Nano::Accounts](https://github.com/jcraigk/ruby_nano_rpc/wiki/Nano::Accounts)
-* [Nano::Node](https://github.com/jcraigk/ruby_nano_rpc/wiki/Nano::Node)
-* [Nano::Wallet](https://github.com/jcraigk/ruby_nano_rpc/wiki/Nano::Wallet)
+* [NanoRpc::Account](https://github.com/jcraigk/ruby_nano_rpc/wiki/NanoRpc::Account)
+* [NanoRpc::Accounts](https://github.com/jcraigk/ruby_nano_rpc/wiki/NanoRpc::Accounts)
+* [NanoRpc::Node](https://github.com/jcraigk/ruby_nano_rpc/wiki/NanoRpc::Node)
+* [NanoRpc::Wallet](https://github.com/jcraigk/ruby_nano_rpc/wiki/NanoRpc::Wallet)
 
 `Account`, `Accounts`, and `Wallet` each require a single parameter to be passed during initialization (`address`, `addresses`, and `seed`, respectively).  This parameter is persisted for subsequent calls.  All RPC methods are provided directly as methods.
 
 ```ruby
-  account = Nano::Account.new('xrb_someaddress1234')
-
-  account.account_balance
-  # => {"balance"=>100, "pending"=>5}
-  account.account_balance.balance
-  # => 100
+account = node.account('xrb_1234') # Account address required
+accounts = node.accounts(['xrb_1234', 'xrb_456']) # Array of account addresses required
+wallet = node.wallet('3AF91AE') # Wallet seed required
 ```
 
-There are also helper methods to bypass repetitive nested calls:
+You can call standard RPC methods on each object:
 
 ```ruby
-  account.balance
-  # => 100
-  account.pending_balance
-  # => 5
+account.account_balance
+# => {"balance"=>100, "pending"=>5}
+account.account_balance.balance
+# => 100
 ```
 
-You can point each proxy object at its own node by passing in a client instance:
+There are also helper methods to bypass repetitive nested calls:
 
 ```ruby
-  client = Nano::Client.new(host: 'mynanonode', port: 1234)
-  account = Nano::Account.new('xrb_someaddress1234', client: client)
+account.balance
+# => 100
+account.pending_balance
+# => 5
 ```
 
 For a comprehensive guide, see the [Wiki](https://github.com/jcraigk/ruby_nano_rpc/wiki).

data/lib/nano_rpc/errors.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-module Nano
+module NanoRpc
   class Error < StandardError; end
 
   class NodeConnectionFailure < Error; end

data/lib/nano_rpc/helpers/account_helper.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
-module Nano::AccountHelper
-  include Nano::ApplicationHelper
+module NanoRpc::AccountHelper
+  include NanoRpc::ApplicationHelper
 
   def balance
     account_balance.balance

data/lib/nano_rpc/helpers/accounts_helper.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
-module Nano::AccountsHelper
-  include Nano::ApplicationHelper
+module NanoRpc::AccountsHelper
+  include NanoRpc::ApplicationHelper
 
   def balances
     accounts_balances
@@ -36,11 +36,11 @@ module Nano::AccountsHelper
   end
   alias pending_blocks pending
 
-  # Array-like access for Nano::Account
+  # Array-like access for NanoRpc::Account
   def [](idx)
     return unless @addresses[idx]
     @account_objects ||= []
-    @account_objects[idx] ||= Nano::Account.new(@addresses[idx], client: client)
+    @account_objects[idx] ||= NanoRpc::Account.new(@addresses[idx], node: node)
   end
 
   def <<(val)
@@ -49,7 +49,7 @@ module Nano::AccountsHelper
 
   def each(&_block)
     @addresses.each do |address|
-      yield Nano::Account.new(address, client: client)
+      yield NanoRpc::Account.new(address, node: node)
     end
   end
 

data/lib/nano_rpc/helpers/application_helper.rb

@@ -1,8 +1,12 @@
 # frozen_string_literal: true
-module Nano::ApplicationHelper
+module NanoRpc::ApplicationHelper
   private
 
   def inspect_prefix
-    "#<#{self.class}:#{format('0x00%x', object_id << 1)}"
+    "#<#{self.class}:#{obj_id}"
+  end
+
+  def obj_id
+    format('0x00%<object_id>x', object_id: object_id << 1)
   end
 end

data/lib/nano_rpc/helpers/node_helper.rb

@@ -1,13 +1,21 @@
 # frozen_string_literal: true
-module Nano::NodeHelper
-  include Nano::ApplicationHelper
+module NanoRpc::NodeHelper
+  include NanoRpc::ApplicationHelper
 
   def account_containing_block(hash:)
     block_account(hash: hash).account
   end
 
+  def account(address)
+    NanoRpc::Account.new(address, node: self)
+  end
+
+  def accounts(addresses)
+    NanoRpc::Accounts.new(addresses, node: self)
+  end
+
   def create_wallet
-    Nano::Wallet.new(wallet_create.wallet, client: client)
+    NanoRpc::Wallet.new(wallet_create.wallet, node: self)
   end
 
   def knano_from_raw(amount:)
@@ -46,6 +54,10 @@ module Nano::NodeHelper
     available_supply.available
   end
 
+  def wallet(seed)
+    NanoRpc::Wallet.new(seed, node: self)
+  end
+
   def work_valid?(work:, hash:)
     work_validate(work: work, hash: hash).valid == 1
   end

data/lib/nano_rpc/helpers/wallet_helper.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
-module Nano::WalletHelper
-  include Nano::ApplicationHelper
+module NanoRpc::WalletHelper
+  include NanoRpc::ApplicationHelper
 
   def account_work(account:)
     work_get(account: account).work
@@ -8,7 +8,7 @@ module Nano::WalletHelper
 
   def accounts
     return [] unless account_list.accounts.size.positive?
-    Nano::Accounts.new(account_list.accounts, client: client)
+    NanoRpc::Accounts.new(account_list.accounts, node: node)
   end
 
   def add_key(key:, work: true)
@@ -49,12 +49,12 @@ module Nano::WalletHelper
 
   def create_account(work: true)
     address = account_create(work: work).account
-    Nano::Account.new(address, client: client)
+    NanoRpc::Account.new(address, node: node)
   end
 
   def create_accounts(count:, work: true)
     addresses = accounts_create(count: count, work: work).accounts
-    Nano::Accounts.new(addresses, client: client)
+    NanoRpc::Accounts.new(addresses, node: node)
   end
 
   def destroy
@@ -67,7 +67,7 @@ module Nano::WalletHelper
   alias unlock enter_password
 
   def export
-    Nano::Response.new(JSON[wallet_export.json])
+    NanoRpc::Response.new(JSON[wallet_export.json])
   end
 
   def frontiers
@@ -79,7 +79,7 @@ module Nano::WalletHelper
   end
 
   def ledger
-    wallet_ledger
+    wallet_ledger.accounts
   end
 
   def locked?

data/lib/nano_rpc/node.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+require 'rest-client'
+require 'json'
+
+module NanoRpc
+  def self.node
+    @node ||= Node.new
+  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
+
+      super
+    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)
+    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]
+    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
+
+    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(url, params)
+      ensure_status_success!(response)
+      data = NanoRpc::Response.new(JSON[response&.body])
+      ensure_valid_response!(data)
+
+      data
+    end
+
+    def request_headers
+      h = headers || {}
+      h['Content-Type'] = 'json'
+      h['Authorization'] = auth unless auth.nil?
+      h
+    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 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_valid_response!(data)
+      return unless data['error']
+      raise NanoRpc::InvalidRequest,
+            "Invalid request: #{data['error']}"
+    end
+  end
+end

data/lib/nano_rpc/proxies/account.rb

@@ -1,13 +1,13 @@
 # frozen_string_literal: true
-class Nano::Account
-  include Nano::Proxy
-  include Nano::AccountHelper
+class NanoRpc::Account
+  include NanoRpc::Proxy
+  include NanoRpc::AccountHelper
 
   attr_reader :address
 
   def initialize(address = nil, opts = {})
     unless address.is_a?(String)
-      raise Nano::MissingParameters,
+      raise NanoRpc::MissingParameters,
             'Missing argument: address (str)'
     end
 
@@ -33,7 +33,9 @@ class Nano::Account
   proxy_method :frontiers, required: %i[count]
   proxy_method :ledger,
                required: %i[count],
-               optional: %i[representative weight pending modified_since sorting]
+               optional: %i[
+                 representative weight pending modified_since sorting
+               ]
   proxy_method :validate_account_number
   proxy_method :pending, required: %i[count], optional: %i[threshold exists]
   proxy_method :payment_wait, required: %i[amount timeout]

data/lib/nano_rpc/proxies/accounts.rb

@@ -1,13 +1,13 @@
 # frozen_string_literal: true
-class Nano::Accounts
-  include Nano::Proxy
-  include Nano::AccountsHelper
+class NanoRpc::Accounts
+  include NanoRpc::Proxy
+  include NanoRpc::AccountsHelper
 
   attr_reader :addresses
 
   def initialize(addresses = nil, opts = {})
     unless addresses.is_a?(Array)
-      raise Nano::MissingParameters,
+      raise NanoRpc::MissingParameters,
             'Missing argument: addresses (str[])'
     end
 
@@ -19,7 +19,9 @@ class Nano::Accounts
 
   proxy_method :account_move, required: %i[wallet source]
   proxy_method :accounts_balances
-  proxy_method :accounts_create, required: %i[wallet count], optional: %i[work]
+  proxy_method :accounts_create,
+               required: %i[wallet count],
+               optional: %i[work]
   proxy_method :accounts_frontiers
   proxy_method :accounts_pending,
                required: %i[count], optional: %i[threshold source]

data/lib/nano_rpc/proxies/wallet.rb

@@ -1,14 +1,14 @@
 # frozen_string_literal: true
-class Nano::Wallet
-  include Nano::Proxy
-  include Nano::WalletHelper
+class NanoRpc::Wallet
+  include NanoRpc::Proxy
+  include NanoRpc::WalletHelper
 
   attr_reader :seed
 
   def initialize(seed = nil, opts = {})
     unless seed.is_a?(String)
-      raise Nano::MissingParameters,
-            'Missing argument: address (str)'
+      raise NanoRpc::MissingParameters,
+            'Missing argument: seed (str)'
     end
 
     @seed = seed
@@ -17,7 +17,7 @@ class Nano::Wallet
 
   # Hide secret seed on object inspection
   def inspect
-    "#{inspect_prefix}, @client=#{@client.inspect}>"
+    "#{inspect_prefix}, @node=#{@node.inspect}>"
   end
 
   proxy_params wallet: :seed

data/lib/nano_rpc/proxy.rb

@@ -1,11 +1,9 @@
 # frozen_string_literal: true
-module Nano::Proxy
-  include Nano::ApplicationHelper
-
-  attr_accessor :client
+module NanoRpc::Proxy
+  attr_reader :node
 
   def initialize(opts = {})
-    @client = opts[:client] || Nano.client
+    @node ||= opts[:node] || NanoRpc.node
     self.class.proxy_methods&.each { |m| define_proxy_method(m) }
   end
 
@@ -35,9 +33,9 @@ module Nano::Proxy
 
   private
 
-  def define_proxy_method(m)
-    self.class.send(:define_method, method_alias(m)) do |args = {}|
-      @m = m
+  def define_proxy_method(meth)
+    self.class.send(:define_method, method_alias(meth)) do |args = {}|
+      @meth = meth
       @call_args = args
 
       validate_params!
@@ -46,7 +44,7 @@ module Nano::Proxy
   end
 
   def execute_call
-    expose_nested_data(@client.call(@m, @call_args))
+    expose_nested_data(node.call(@meth, @call_args))
   end
 
   def base_params
@@ -61,13 +59,16 @@ module Nano::Proxy
   end
 
   # Nano `send` action is also the method caller in Ruby ;)
-  def method_alias(m)
-    m == :send ? :send_currency : m
+  def method_alias(meth)
+    meth == :send ? :send_currency : meth
   end
 
   # If single-key response matches method name, expose nested data
   def expose_nested_data(data)
-    data.is_a?(Hash) && data.keys.map(&:to_s) == [@m.to_s] ? data[@m] : data
+    if data.is_a?(Hash) && data.keys.map(&:to_s) == [@meth.to_s]
+      return data[@meth]
+    end
+    data
   end
 
   def validate_params!
@@ -91,14 +92,14 @@ module Nano::Proxy
   def ensure_required_params!
     missing_params = required_params - opts_keys
     return unless missing_params.any?
-    raise Nano::MissingParameters,
+    raise NanoRpc::MissingParameters,
           "Missing required parameter(s): #{missing_params.join(', ')}"
   end
 
   def prevent_forbidden_params!
     forbidden_params = base_param_keys + opts_keys - allowed_params
     return unless forbidden_params.any?
-    raise Nano::ForbiddenParameter,
+    raise NanoRpc::ForbiddenParameter,
           "Forbidden parameter(s) passed: #{forbidden_params.join(', ')}"
   end
 
@@ -115,13 +116,13 @@ module Nano::Proxy
   end
 
   def required_params
-    return [] unless method_def && method_def[@m]
-    method_def[@m][:required] || []
+    return [] unless method_def && method_def[@meth]
+    method_def[@meth][:required] || []
   end
 
   def optional_params
-    return [] unless method_def && method_def[@m]
-    method_def[@m][:optional] || []
+    return [] unless method_def && method_def[@meth]
+    method_def[@meth][:optional] || []
   end
 
   def base_param_keys

data/lib/nano_rpc/response.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 require 'hashie'
 
-class Nano::Response < Hash
+class NanoRpc::Response < Hash
   include ::Hashie::Extensions::MergeInitializer
   include ::Hashie::Extensions::IndifferentAccess
   include ::Hashie::Extensions::MethodAccess
@@ -17,15 +17,15 @@ class Nano::Response < Hash
     merge!(self) { |_k, v| to_f_or_i_or_s(v) }
   end
 
-  def to_f_or_i_or_s(v)
-    return if v.nil?
-    return v.to_i if big_integer?(v)
-    (float = Float(v)) && (float % 1.0).zero? ? float.to_i : float
+  def to_f_or_i_or_s(val)
+    return if val.nil?
+    return val.to_i if big_integer?(val)
+    (float = Float(val)) && (float % 1.0).zero? ? float.to_i : float
   rescue ArgumentError, TypeError
-    v
+    val
   end
 
-  def big_integer?(v)
-    v.respond_to?(:to_i) && v.to_i > 1_000_000_000_000_000
+  def big_integer?(val)
+    val.respond_to?(:to_i) && val.to_i > 1_000_000_000_000_000
   end
 end

data/lib/nano_rpc/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
-module Nano
-  VERSION = '0.9.0'
+module NanoRpc
+  VERSION = '0.10.0'
 end

data/lib/nano_rpc.rb

@@ -1,15 +1,16 @@
 # frozen_string_literal: true
 require 'nano_rpc/version'
+
 require 'nano_rpc/helpers/application_helper'
 require 'nano_rpc/helpers/account_helper'
 require 'nano_rpc/helpers/accounts_helper'
 require 'nano_rpc/helpers/node_helper'
 require 'nano_rpc/helpers/wallet_helper'
-require 'nano_rpc/client'
-require 'nano_rpc/errors'
+
 require 'nano_rpc/proxy'
+require 'nano_rpc/node'
+require 'nano_rpc/errors'
 require 'nano_rpc/response'
 require 'nano_rpc/proxies/account'
 require 'nano_rpc/proxies/accounts'
-require 'nano_rpc/proxies/node'
 require 'nano_rpc/proxies/wallet'

data/nano_rpc.gemspec

@@ -5,7 +5,7 @@ require 'nano_rpc/version'
 
 Gem::Specification.new do |spec|
   spec.name          = 'nano_rpc'
-  spec.version       = Nano::VERSION
+  spec.version       = NanoRpc::VERSION
   spec.authors       = ['Justin Craig-Kuhn (JCK)']
   spec.email         = ['jcraigk@gmail.com']
 
@@ -23,12 +23,12 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = %w[lib]
 
-  spec.add_development_dependency 'bundler', '~> 1.16'
+  spec.add_development_dependency 'bundler', '~> 1.16.1'
   spec.add_development_dependency 'pry', '~> 0.11.3'
-  spec.add_development_dependency 'rake', '~> 10.0'
-  spec.add_development_dependency 'rspec', '~> 3.0'
-  spec.add_development_dependency 'rubocop', '~> 0.52.1'
-  spec.add_development_dependency 'simplecov', '~> 0.15.1'
+  spec.add_development_dependency 'rake', '~> 12.3.1'
+  spec.add_development_dependency 'rspec', '~> 3.7.0'
+  spec.add_development_dependency 'rubocop', '~> 0.56.0'
+  spec.add_development_dependency 'simplecov', '~> 0.16.1'
 
   spec.add_runtime_dependency 'hashie', '~> 3.5', '>= 3.5.7'
   spec.add_runtime_dependency 'rest-client', '~> 2.0', '>= 2.0.2'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nano_rpc
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.10.0
 platform: ruby
 authors:
 - Justin Craig-Kuhn (JCK)
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-05-11 00:00:00.000000000 Z
+date: 2018-05-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.16'
+        version: 1.16.1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.16'
+        version: 1.16.1
 - !ruby/object:Gem::Dependency
   name: pry
   requirement: !ruby/object:Gem::Requirement
@@ -44,56 +44,56 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: 12.3.1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: 12.3.1
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: 3.7.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: 3.7.0
 - !ruby/object:Gem::Dependency
   name: rubocop
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.52.1
+        version: 0.56.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.52.1
+        version: 0.56.0
 - !ruby/object:Gem::Dependency
   name: simplecov
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.15.1
+        version: 0.16.1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.15.1
+        version: 0.16.1
 - !ruby/object:Gem::Dependency
   name: hashie
   requirement: !ruby/object:Gem::Requirement
@@ -152,16 +152,15 @@ files:
 - bin/console
 - bin/setup
 - lib/nano_rpc.rb
-- lib/nano_rpc/client.rb
 - lib/nano_rpc/errors.rb
 - lib/nano_rpc/helpers/account_helper.rb
 - lib/nano_rpc/helpers/accounts_helper.rb
 - lib/nano_rpc/helpers/application_helper.rb
 - lib/nano_rpc/helpers/node_helper.rb
 - lib/nano_rpc/helpers/wallet_helper.rb
+- lib/nano_rpc/node.rb
 - lib/nano_rpc/proxies/account.rb
 - lib/nano_rpc/proxies/accounts.rb
-- lib/nano_rpc/proxies/node.rb
 - lib/nano_rpc/proxies/wallet.rb
 - lib/nano_rpc/proxy.rb
 - lib/nano_rpc/response.rb

data/lib/nano_rpc/client.rb

@@ -1,100 +0,0 @@
-# frozen_string_literal: true
-require 'rest-client'
-require 'json'
-
-module Nano
-  def self.client
-    @client ||= Client.new
-  end
-
-  class Client
-    include Nano::ApplicationHelper
-
-    attr_reader :host, :port, :auth, :headers
-
-    def initialize(host: 'localhost', port: 7076, auth: nil, headers: nil)
-      @host = host
-      @port = port
-      @auth = auth
-      @headers = headers
-    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)
-    end
-
-    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
-
-    def proxy_method(v)
-      if v.is_a?(Nano::Wallet)
-        :seed
-      elsif v.is_a?(Nano::Accounts)
-        :addresses
-      elsif v.is_a?(Nano::Account)
-        :address
-      end
-    end
-
-    def rpc_post(params)
-      response = rest_client_post(url, params)
-      ensure_status_success!(response)
-      data = Nano::Response.new(JSON[response&.body])
-      ensure_valid_response!(data)
-
-      data
-    end
-
-    def request_headers
-      h = headers || {}
-      h['Content-Type'] = 'json'
-      h['Authorization'] = auth unless auth.nil?
-      h
-    end
-
-    def rest_client_post(url, params)
-      RestClient.post(url, params.to_json, request_headers)
-    rescue Errno::ECONNREFUSED
-      raise Nano::NodeConnectionFailure,
-            "Node connection failure at #{url}"
-    rescue RestClient::Exceptions::OpenTimeout
-      raise Nano::NodeOpenTimeout,
-            'Node failed to respond in time'
-    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 Nano::BadRequest,
-            "Error response from node: #{JSON[response&.body]}"
-    end
-
-    def ensure_valid_response!(data)
-      return unless data['error']
-      raise Nano::InvalidRequest,
-            "Invalid request: #{data['error']}"
-    end
-  end
-end

data/lib/nano_rpc/proxies/node.rb

@@ -1,63 +0,0 @@
-# frozen_string_literal: true
-class Nano::Node
-  include Nano::Proxy
-  include Nano::NodeHelper
-
-  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]
-  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]
-end