nano_rpc 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: da3e826d03d97a0b481735d2c930a9f2dfd098167ae263c6a91b2b7da55dd607
-  data.tar.gz: a22e93555b44d86f5b53cb07ca13d6bc16a38f6f1d9025051655604d146b16a3
+  metadata.gz: 5505de736e20d672bed90df3856fef48148882a3726f27bb10fa03eb2db5e4b0
+  data.tar.gz: 20a28a63f524ecc1af9a2a94f91b724b5996b767ba35202a7416841ffd98aac8
 SHA512:
-  metadata.gz: 4ebe96119c1db5db4e4ac8d1a75a0dab74717d0fa718062fda33651820113b2021d5da2994fa7508cd67281c19e673d1b26229504720cef3fc77b46905686302
-  data.tar.gz: 461f6bdd4eb3db88ca94c2781519616e58bb412e44ab407f6abc76a381b4faa55f0741e054f7604829b3958753f7592e5d2d6f82dc6c716854bf5355dc8a864e
+  metadata.gz: 61056e815bf6a31ccb9dbacc4581b4fd99ee9769fba6251c5f84da884f1bb9d430604a09fb053b4a21613e9b318b81f40c9950f1fc718d5bd4ff2656cf60f703
+  data.tar.gz: 03e4d60c84c306ebe878c527d00a3084b083de0e788795995dc0f0d2459f6a48b6e6c49f7a0e4474baaa2f81f9d727bbf9cad9ac0c170b3a03ef004e933d1cf8

data/README.md

@@ -1,6 +1,6 @@
 # Nano RPC
 
-An RPC wrapper for Nano (the digital currency) written in Ruby.  It connects to an individual Nano node that you control.  There's a client object you can use to make explicit RPC calls as well as proxy objects with logically grouped helper methods ([Wiki](https://github.com/jcraigk/ruby_nano_rpc/wiki/Proxy-Object-Reference)).
+An RPC wrapper for Nano digitial currency nodes. Arbitrary RPC access is provided along with proxy objects that expose helper methods ([Wiki](https://github.com/jcraigk/ruby_nano_rpc/wiki/Proxy-Object-Reference)).
 
 To run a Nano node locally, see [Nano Docker Docs](https://github.com/clemahieu/raiblocks/wiki/Docker-node).
 
@@ -65,10 +65,10 @@ Response data are provided as [Hashie](https://github.com/intridea/hashie) objec
 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:
 
 ```ruby
-  Nano::Account # { account: 'xrb_address12345' }
-  Nano::Accounts # { accounts: %w[xrb_address12345 xrb_address67890] }
+  Nano::Account
+  Nano::Accounts
   Nano::Node
-  Nano::Wallet # { wallet: 'F3093AB' }
+  Nano::Wallet
 ```
 
 `Account`, `Accounts`, and `Wallet` each require a single parameter to be passed during initialization.  This parameter is persisted for subsequent calls.  All RPC methods are provided directly as methods.
@@ -99,13 +99,6 @@ There are also helper methods for terser code:
   # 0
 ```
 
-You can ask an object what helper methods it provides using `helper_methods` (coming soon):
-
-```ruby
-  account.helper_methods
-  # => [:balance, :pending_balance, ...]
-```
-
 `Node` methods are provided at both the instance and class levels:
 
 ```ruby
@@ -113,17 +106,19 @@ You can ask an object what helper methods it provides using `helper_methods` (co
   # => {"rpc_version"=>1, "store_version"=>10, "node_vendor"=>"RaiBlocks 9.0"}
 
   node = Nano::Node.new
-  version.rpc_version
+  node.version.rpc_version
   # => 1
   node.peers
-  # => {"peers"=>{"[::ffff:2.80.5.202]:64317"=>"5", "[::ffff:2.249.74.58]:7075"=>"5", "[::ffff:5.9.31.82]:7077"=>"4", ... }
+  # => {"[::ffff:2.80.5.202]:64317"=>"5", "[::ffff:2.249.74.58]:7075"=>"5", "[::ffff:5.9.31.82]:7077"=>"4", ... }
   node.available_supply
   # => {"available"=>132596127030666124778600855847014518457}
+  node.available
+  # => 132596127030666124778600855847014518457
   node.block_count.unchecked
   # => 4868605
 ```
 
-To connect to a custom node, instantiate a client and pass it into the proxy object as `client`:
+You can point each proxy object at its own node by passing a custom client in:
 
 ```ruby
   client = Nano::Client.new(host: 'mynanonode', port: 1234)

data/lib/nano/helpers/account_proxy_helper.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 module Nano::AccountProxyHelper
+  include Nano::ApplicationHelper
+
   def balance
     account_balance.balance
   end
@@ -8,12 +10,10 @@ module Nano::AccountProxyHelper
     account_block_count.block_count
   end
 
-  def create(wallet:, work:)
-    account_create(wallet: wallet, work: work).account
-  end
-
-  def history(count:)
-    account_history(count: count).history
+  def history(opts)
+    account_history(
+      count: opts_pluck(opts, :count)
+    ).history
   end
 
   def info
@@ -21,23 +21,22 @@ module Nano::AccountProxyHelper
   end
 
   def key
-    account_key.key
-  end
-
-  def list
-    account_list.accounts
-  end
-
-  def move(wallet:, source:, accounts:)
-    account_move(wallet: wallet, source: source, accounts: accounts).moved == 1
+    account_key['key']
   end
 
-  def wallet_work(wallet:)
-    work_get(wallet: wallet).work
+  def move(from:, to:)
+    account_move(
+      wallet: to,
+      source: from,
+      accounts: [address]
+    ).moved == 1
   end
 
   def wallet_work_set(wallet:, work:)
-    work_set(wallet: wallet, work: work).work[:success] == ''
+    work_set(
+      wallet: wallet,
+      work: work
+    ).success == ''
   end
 
   def pending_balance
@@ -45,13 +44,19 @@ module Nano::AccountProxyHelper
   end
   alias balance_pending pending_balance
 
-  def pending_blocks(count:, threshold: nil, exists: nil)
-    pending(count: count, threshold: threshold, exists: exists).locks
+  def pending_blocks(count:, threshold: nil, source: nil)
+    pending(
+      count: count,
+      threshold: threshold,
+      source: source
+    ).blocks
   end
   alias blocks_pending pending_blocks
 
-  def remove(wallet:)
-    account_remove(wallet: wallet).removed == 1
+  def remove(opts)
+    account_remove(
+      wallet: opts_pluck(opts, :wallet)
+    ).removed == 1
   end
 
   def representative
@@ -60,7 +65,8 @@ module Nano::AccountProxyHelper
 
   def representative_set(wallet:, representative:)
     account_representative_set(
-      wallet: wallet, representative: representative
+      wallet: wallet,
+      representative: representative
     ).set == 1
   end
 

data/lib/nano/helpers/accounts_proxy_helper.rb

@@ -1,19 +1,34 @@
 # frozen_string_literal: true
 module Nano::AccountsProxyHelper
   def balances
-    accounts_balances.balances
+    accounts_balances
+      .balances
+      .each_with_object({}) do |(k, v), hash|
+      hash[k] = v['balance']
+    end
   end
 
-  def create(wallet:, count:, work: nil)
-    accounts_create(wallet: wallet, count: count, work: work).accounts
+  def pending_balances
+    accounts_balances
+      .balances
+      .each_with_object({}) do |(k, v), hash|
+      hash[k] = v['pending']
+    end
   end
+  alias balances_pending pending_balances
 
   def frontiers
     accounts_frontiers.frontiers
   end
 
+  def move(from:, to:)
+    account_move(wallet: to, source: from).moved == 1
+  end
+
   def pending(count:, threshold: nil, source: nil)
-    accounts_pending(count: count, threshold: threshold, source: source).blocks
+    accounts_pending(
+      count: count, threshold: threshold, source: source
+    ).blocks
   end
   alias pending_blocks pending
 

data/lib/nano/helpers/application_helper.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+module Nano::ApplicationHelper
+  private
+
+  def opts_pluck(opts, key)
+    opts.is_a?(Hash) ? opts[key] : opts
+  end
+end

data/lib/nano/helpers/node_proxy_helper.rb

@@ -1,42 +1,58 @@
 # frozen_string_literal: true
 module Nano::NodeProxyHelper
-  def account_containing_block(hash)
-    block_account(hash: hash).account
+  include Nano::ApplicationHelper
+
+  def account_containing_block(opts)
+    block_account(opts_hash(opts)).account
   end
 
   def available
     available_supply.available
   end
 
-  def krai_from(amount:)
-    krai_from_raw(amount: amount).amount
+  def create_wallet
+    Nano::Wallet.new(wallet_create.wallet)
+  end
+
+  def krai_from(opts)
+    krai_from_raw(opts_amount(opts)).amount
   end
 
-  def krai_to(amount:)
-    krai_to_raw(amount: amount).amount
+  def krai_to(opts)
+    krai_to_raw(opts_amount(opts)).amount
   end
 
-  def mrai_from(amount:)
-    mrai_from_raw(amount: amount).amount
+  def mrai_from(opts)
+    mrai_from_raw(opts_amount(opts)).amount
   end
 
-  def mrai_to(amount:)
-    mrai_to_raw(amount: amount).amount
+  def mrai_to(opts)
+    mrai_to_raw(opts_amount(opts)).amount
   end
 
-  def pending_exists?(hash:)
-    pending_exists(hash: hash).exists == 1
+  def pending_exists?(opts)
+    pending_exists(opts_hash(opts)).exists == 1
   end
 
-  def rai_from(amount:)
-    rai_from_raw(amount: amount).amount
+  def rai_from(opts)
+    rai_from_raw(opts_amount(opts)).amount
   end
 
-  def rai_to(amount:)
-    rai_to_raw(amount: amount).amount
+  def rai_to(opts)
+    rai_to_raw(opts_amount(opts)).amount
   end
 
   def work_valid?(work:, hash:)
     work_validate(work: work, hash: hash).valid == 1
   end
+
+  private
+
+  def opts_amount(opts)
+    { amount: opts_pluck(opts, :amount) }
+  end
+
+  def opts_hash(opts)
+    { hash: opts_pluck(opts, :hash) }
+  end
 end

data/lib/nano/helpers/wallet_proxy_helper.rb

@@ -1,10 +1,12 @@
 # frozen_string_literal: true
 module Nano::WalletProxyHelper
-  def account_work(account:)
-    work_get.work(account: account).work
+  include Nano::ApplicationHelper
+
+  def account_work(opts)
+    work_get(opts_account(opts)).work
   end
 
-  def add(key:, work: nil)
+  def add_key(key:, work: true)
     wallet_add(key: key, work: work).account
   end
 
@@ -13,39 +15,53 @@ module Nano::WalletProxyHelper
   end
 
   def balances(threshold: nil)
-    wallet_balances(threshold: threshold).balances
+    wallet_balances(threshold: threshold)
+      .balances
+      .each_with_object({}) do |(k, v), hash|
+        hash[k] = v['balance'].to_i
+      end
   end
 
   def begin_payment
     payment_begin.account
   end
 
-  def change_password(new_password:)
-    password_change(password: new_password).changed == 1
+  def change_password(opts)
+    password_change(
+      password: opts_pluck(opts, :new_password)
+    ).changed == 1
+  end
+
+  def change_seed(opts)
+    wallet_change_seed(
+      seed: opts_pluck(opts, :new_seed)
+    ).success == ''
   end
 
-  def change_seed(new_seed:)
-    wallet_change_seed(seed: new_seed)[:success] == ''
+  def contains?(opts)
+    wallet_contains(opts_account(opts)).exists == 1
   end
 
-  def contains?(account:)
-    wallet_contains(account: account).exists == 1
+  def create_account(work: true)
+    account_create(work: work).account
   end
 
-  def create
-    wallet_create.wallet
+  def create_accounts(count:, work: true)
+    accounts_create(count: count, work: work).accounts
   end
 
   def destroy
     wallet_destroy
   end
 
-  def enter_password(password)
-    password_enter(password: password).valid == 1
+  def enter_password(opts)
+    password_enter(
+      password: opts_pluck(opts, :password)
+    ).valid == 1
   end
 
   def export
-    JSON[wallet_export.json]
+    Nano::Response.new(JSON[wallet_export.json])
   end
 
   def frontiers
@@ -60,46 +76,88 @@ module Nano::WalletProxyHelper
     wallet_locked.locked == 1
   end
 
-  def password_valid?(password:)
-    password_valid(password: password).valid == 1
+  def move_accounts(to:, accounts:)
+    account_move(
+      wallet: to,
+      source: seed,
+      accounts: accounts
+    ).moved == 1
+  end
+
+  def password_valid?(opts)
+    password_valid(
+      password: opts_pluck(opts, :password)
+    ).valid == 1
   end
 
   def pending_balance
     wallet_balance_total.pending
   end
+  alias balance_pending pending_balance
+
+  def pending_balances(threshold: nil)
+    wallet_balances(threshold: threshold)
+      .balances
+      .each_with_object({}) do |(k, v), hash|
+        hash[k] = v['pending'].to_i
+      end
+  end
+  alias balances_pending pending_balances
 
   def pending_blocks(count:, threshold: nil, source: nil)
-    wallet_pending(count: count, threshold: threshold, source: source).blocks
+    wallet_pending(
+      count: count,
+      threshold: threshold,
+      source: source
+    ).blocks
   end
+  alias blocks_pending pending_blocks
 
   def receive_block(account:, block:)
-    receive.block(account: account, block: block).block
+    receive(account: account, block: block).block
+  end
+
+  def remove_account(opts)
+    account_remove(opts_account(opts)).removed == 1
   end
 
   def representative
     wallet_representative.representative
   end
 
-  def republish(count:)
-    wallet_republish(count: count).blocks
+  def republish(opts)
+    wallet_republish(count: opts_pluck(opts, :count)).blocks
   end
 
   def account_work_set(account:, work:)
-    work_set(account: account, work: work).work[:success] == ''
+    work_set(account: account, work: work).success == ''
   end
   alias set_account_work account_work_set
 
-  def representative_set(representative:)
-    wallet_representative_set(representative: representative).set == 1
+  def representative_set(opts)
+    wallet_representative_set(
+      representative: opts_pluck(opts, :representative)
+    ).set == 1
   end
   alias set_representative representative_set
 
-  def send_tx(source:, destination:, amount:)
-    rai_send(source: source, destination: destination, amount: amount).block
+  def send_nano(from:, to:, amount:, work: nil)
+    send_currency(
+      source: from,
+      destination: to,
+      amount: amount,
+      work: work
+    ).block
   end
-  alias send_transaction send_tx
+  alias send_transaction send_nano
 
   def work
     wallet_work_get.works
   end
+
+  private
+
+  def opts_account(opts)
+    { account: opts_pluck(opts, :account) }
+  end
 end

data/lib/nano/proxies/account.rb

@@ -12,7 +12,7 @@ class Nano::Account
     end
 
     @address = address
-    @client = opts[:client] || Nano.client
+    super(opts)
   end
 
   proxy_params account: :address
@@ -22,7 +22,6 @@ class Nano::Account
   proxy_method :account_info
   proxy_method :account_create, required: %i[wallet], optional: %i[work]
   proxy_method :account_history, required: %i[count]
-  proxy_method :account_list
   proxy_method :account_move, required: %i[wallet source accounts]
   proxy_method :account_key
   proxy_method :account_remove, required: %i[wallet]

data/lib/nano/proxies/accounts.rb

@@ -5,18 +5,19 @@ class Nano::Accounts
 
   attr_accessor :addresses
 
-  def initialize(addresses = nil, client = nil)
+  def initialize(addresses = nil, opts = {})
     unless addresses.is_a?(Array)
       raise Nano::MissingParameters,
             'Missing argument: addresses (str[])'
     end
 
     @addresses = addresses
-    @client = client || Nano.client
+    super(opts)
   end
 
   proxy_params accounts: :addresses
 
+  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_frontiers

data/lib/nano/proxies/node.rb

@@ -46,6 +46,7 @@ class Nano::Node
   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]

data/lib/nano/proxies/wallet.rb

@@ -5,25 +5,29 @@ class Nano::Wallet
 
   attr_accessor :seed
 
-  def initialize(wallet_seed = nil, opts = {})
-    unless wallet_seed.is_a?(String)
+  def initialize(seed = nil, opts = {})
+    unless seed.is_a?(String)
       raise Nano::MissingParameters,
             'Missing argument: address (str)'
     end
 
-    @seed = wallet_seed
-    @client = opts[:client] || Nano.client
+    @seed = seed
+    super(opts)
   end
 
   proxy_params wallet: :seed
 
+  proxy_method :account_create, optional: %i[work]
+  proxy_method :accounts_create, required: %i[count], optional: %i[work]
+  proxy_method :account_list
+  proxy_method :account_remove, required: %i[account]
   proxy_method :password_change, required: %i[password]
   proxy_method :password_enter, required: %i[password]
   proxy_method :password_valid
   proxy_method :payment_begin
   proxy_method :payment_init
   proxy_method :payment_end, required: %i[account]
-  proxy_method :receive, required: %i[account block]
+  proxy_method :receive, required: %i[account block], optional: %i[work]
   proxy_method :send, required: %i[wallet source destination amount]
   proxy_method :search_pending
   proxy_method :wallet_add, required: %i[key], optional: %i[work]
@@ -31,7 +35,6 @@ class Nano::Wallet
   proxy_method :wallet_balances, optional: %i[threshold]
   proxy_method :wallet_change_seed, required: %i[seed]
   proxy_method :wallet_contains, required: %i[account]
-  proxy_method :wallet_create
   proxy_method :wallet_destroy
   proxy_method :wallet_export
   proxy_method :wallet_frontiers

data/lib/nano/proxy.rb

@@ -30,23 +30,25 @@ module Nano::Proxy
     end
 
     def define_proxy_method(m, singleton = false)
-      send(
-        singleton ? :define_singleton_method : :define_method,
-        method_alias(m)
-      ) do |opts = {}|
+      send(method_style(singleton), method_alias(m)) do |opts = {}|
         params = Nano::ProxyContext.new(
           singleton ? self : self.class, m, opts
         ).populate_params(singleton ? nil : base_params)
-        data = Nano.client.call(m, params)
+        data = (singleton ? Nano.client : @client).call(m, params)
+        # If single-key response matches method name, expose nested data
         data.is_a?(Hash) && data.keys.map(&:to_s) == [m.to_s] ? data[m] : data
       end
     end
 
     private
 
+    def method_style(singleton)
+      singleton ? :define_singleton_method : :define_method
+    end
+
     # Nano `send` action is also the method caller in Ruby ;)
     def method_alias(m)
-      m == :send ? :tx_send : m
+      m == :send ? :send_currency : m
     end
 
     def method_missing(m, *args, &_block)
@@ -62,11 +64,6 @@ module Nano::Proxy
     def valid_method?(m)
       proxy_param_def.nil? && methods.include?(m)
     end
-
-    def proxy_context(m)
-      @proxy_context ||= {}
-      @proxy_context[m] ||= Nano::ProxyContext.new(self, m)
-    end
   end
 
   def proxy_methods

data/lib/nano/proxy_context.rb

@@ -8,10 +8,6 @@ class Nano::ProxyContext
     @opts = opts
   end
 
-  def valid_proxy_method?
-    rpc_action?
-  end
-
   def populate_params(params)
     opts = validate_opts!
     opts.merge!(params) if params
@@ -69,12 +65,4 @@ class Nano::ProxyContext
   def base_param_keys
     @param_def.is_a?(Hash) ? @param_def.keys : []
   end
-
-  def method_expansion
-    "#{action_prefix}#{@m}"
-  end
-
-  def action_prefix
-    @klass.name.split('::').last.downcase + '_'
-  end
 end

data/lib/nano/response.rb

@@ -18,8 +18,14 @@ class Nano::Response < Hash
   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
-  rescue ArgumentError, TypeErrror
+  rescue ArgumentError, TypeError
     v
   end
+
+  def big_integer?(v)
+    v.respond_to?(:to_i) && v.to_i > 1_000_000_000_000_000
+  end
 end

data/lib/nano/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module Nano
-  VERSION = '0.1.0'
+  VERSION = '0.2.0'
 end

data/lib/nano_rpc.rb

@@ -5,6 +5,7 @@ require 'nano/errors'
 require 'nano/proxy'
 require 'nano/proxy_context'
 require 'nano/response'
+require 'nano/helpers/application_helper'
 require 'nano/helpers/account_proxy_helper'
 require 'nano/helpers/accounts_proxy_helper'
 require 'nano/helpers/node_proxy_helper'

data/nano_rpc.gemspec

@@ -10,10 +10,9 @@ Gem::Specification.new do |spec|
   spec.email         = ['jcraigk@gmail.com']
 
   spec.summary       = 'RPC wrapper for Nano digital nodes written in Ruby'
-  spec.description   = 'An RPC wrapper for Nano nodes written in Ruby.' \
-                       'It connects to an individual node that you control. ' \
-                       'A client object provides arbitrary RPC access and ' \
-                       'proxy objects provide logically grouped helper methods.'
+  spec.description   = 'An RPC wrapper for Nano digitial currency nodes. ' \
+                       'Arbitrary RPC access is provided along with proxy ' \
+                       'objects that expose helper methods.'
   spec.homepage      = 'https://github.com/jcraigk/ruby_nano_rpc'
   spec.license       = 'MIT'
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nano_rpc
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Justin Craig-Kuhn (JCK)
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-01-31 00:00:00.000000000 Z
+date: 2018-02-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -134,9 +134,8 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 2.0.2
-description: An RPC wrapper for Nano nodes written in Ruby.It connects to an individual
-  node that you control. A client object provides arbitrary RPC access and proxy objects
-  provide logically grouped helper methods.
+description: An RPC wrapper for Nano digitial currency nodes. Arbitrary RPC access
+  is provided along with proxy objects that expose helper methods.
 email:
 - jcraigk@gmail.com
 executables: []
@@ -156,6 +155,7 @@ files:
 - lib/nano/errors.rb
 - lib/nano/helpers/account_proxy_helper.rb
 - lib/nano/helpers/accounts_proxy_helper.rb
+- lib/nano/helpers/application_helper.rb
 - lib/nano/helpers/node_proxy_helper.rb
 - lib/nano/helpers/wallet_proxy_helper.rb
 - lib/nano/proxies/account.rb