nano_rpc 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: da3e826d03d97a0b481735d2c930a9f2dfd098167ae263c6a91b2b7da55dd607
+  data.tar.gz: a22e93555b44d86f5b53cb07ca13d6bc16a38f6f1d9025051655604d146b16a3
+SHA512:
+  metadata.gz: 4ebe96119c1db5db4e4ac8d1a75a0dab74717d0fa718062fda33651820113b2021d5da2994fa7508cd67281c19e673d1b26229504720cef3fc77b46905686302
+  data.tar.gz: 461f6bdd4eb3db88ca94c2781519616e58bb412e44ab407f6abc76a381b4faa55f0741e054f7604829b3958753f7592e5d2d6f82dc6c716854bf5355dc8a864e

data/.gitignore

@@ -0,0 +1,11 @@
+.DS_Store
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+.rspec_status
+Gemfile.lock

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,13 @@
+AllCops:
+  TargetRubyVersion: 2.5.0
+  Exclude:
+    - 'bin/*'
+  DisplayCopNames: true
+Style/ClassAndModuleChildren:
+  EnforcedStyle: compact
+Style/EmptyMethod:
+  EnforcedStyle: expanded
+Layout/EmptyLineAfterMagicComment:
+  Enabled: false
+Documentation:
+  Enabled: false

data/Gemfile

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+source 'https://rubygems.org'
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Justin Craig-Kuhn
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,137 @@
+# 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)).
+
+To run a Nano node locally, see [Nano Docker Docs](https://github.com/clemahieu/raiblocks/wiki/Docker-node).
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'nano_rpc'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install nano_rpc
+
+## 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.
+
+### 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).
+
+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:
+
+```ruby
+# Connect to localhost:7076
+client = Nano.client
+
+# Connect to custom host
+client = Nano::Client.new(host: 'mynanonode', port: 1234)
+```
+
+Then make a `call`, passing the action and data:
+
+```ruby
+  client.call(:account_balance, account: 'xrb_someaddress1234')
+  # => {"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
+````
+
+### Proxy Objects
+
+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::Node
+  Nano::Wallet # { wallet: 'F3093AB' }
+```
+
+`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.
+
+```ruby
+  account = Nano::Account.new('xrb_someaddress1234')
+
+  account.account_balance
+  # => {"balance"=>100, "pending"=>0}
+  account.account_balance.balance
+  # 100
+```
+
+You can ask an object what raw RPC methods it provides using `proxy_methods`:
+
+```ruby
+  account.proxy_methods
+  # => [:account_balance, :account_block_count, :account_create, ...]
+```
+
+There are also helper methods for terser code:
+
+```ruby
+  account = Nano::Account.new('xrb_someaddress1234')
+  account.balance
+  # 100
+  account.pending_balance
+  # 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
+  Nano::Node.version
+  # => {"rpc_version"=>1, "store_version"=>10, "node_vendor"=>"RaiBlocks 9.0"}
+
+  node = Nano::Node.new
+  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", ... }
+  node.available_supply
+  # => {"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`:
+
+```ruby
+  client = Nano::Client.new(host: 'mynanonode', port: 1234)
+  account = Nano::Account.new('xrb_someaddress1234', client: client)
+```
+
+For a more comprehensive guide, see the [Wiki](https://github.com/jcraigk/ruby_nano_rpc/wiki/Proxy-Object-Reference).
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+task default: :spec

data/bin/console

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'nano_rpc'

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/nano/client.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+require 'rest-client'
+require 'json'
+
+module Nano
+  def self.client
+    @client ||= Client.new
+  end
+
+  class Client
+    attr_accessor :host, :port
+
+    def initialize(host: 'localhost', port: 7076)
+      @host = host
+      @port = port
+    end
+
+    def call(action, params = {})
+      args = { action: action }
+      args.merge!(params) if params.is_a?(Hash)
+      post(args)
+    end
+
+    private
+
+    def 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 rest_client_post(url, params)
+      RestClient.post(url, params.to_json)
+    rescue Errno::ECONNREFUSED
+      raise Nano::NodeConnectionFailure,
+            "Node connection failure at #{url}"
+    end
+
+    def url
+      "http://#{host}:#{port}"
+    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/errors.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+module Nano
+  class Error < StandardError; end
+
+  class NodeConnectionFailure < Error; end
+  class BadRequest < Error; end
+  class InvalidRequest < Error; end
+  class InvalidParameterType < Error; end
+  class ForbiddenParameter < Error; end
+  class MissingParameters < Error; end
+end

data/lib/nano/helpers/account_proxy_helper.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+module Nano::AccountProxyHelper
+  def balance
+    account_balance.balance
+  end
+
+  def block_count
+    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
+  end
+
+  def info
+    account_info
+  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
+  end
+
+  def wallet_work(wallet:)
+    work_get(wallet: wallet).work
+  end
+
+  def wallet_work_set(wallet:, work:)
+    work_set(wallet: wallet, work: work).work[:success] == ''
+  end
+
+  def pending_balance
+    account_balance.pending
+  end
+  alias balance_pending pending_balance
+
+  def pending_blocks(count:, threshold: nil, exists: nil)
+    pending(count: count, threshold: threshold, exists: exists).locks
+  end
+  alias blocks_pending pending_blocks
+
+  def remove(wallet:)
+    account_remove(wallet: wallet).removed == 1
+  end
+
+  def representative
+    account_representative.representative
+  end
+
+  def representative_set(wallet:, representative:)
+    account_representative_set(
+      wallet: wallet, representative: representative
+    ).set == 1
+  end
+
+  def weight
+    account_weight.weight
+  end
+end

data/lib/nano/helpers/accounts_proxy_helper.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+module Nano::AccountsProxyHelper
+  def balances
+    accounts_balances.balances
+  end
+
+  def create(wallet:, count:, work: nil)
+    accounts_create(wallet: wallet, count: count, work: work).accounts
+  end
+
+  def frontiers
+    accounts_frontiers.frontiers
+  end
+
+  def pending(count:, threshold: nil, source: nil)
+    accounts_pending(count: count, threshold: threshold, source: source).blocks
+  end
+  alias pending_blocks pending
+
+  # Array-like access for Nano::Account
+  def [](idx)
+    return unless @addresses[idx]
+    @account_objects ||= []
+    @account_objects[idx] ||= Nano::Account.new(@addresses[idx])
+  end
+
+  def <<(val)
+    @addresses << val
+  end
+
+  def each(&_block)
+    @addresses.each do |address|
+      yield Nano::Account.new(address)
+    end
+  end
+
+  def first
+    self[0]
+  end
+
+  def second
+    self[1]
+  end
+
+  def third
+    self[2]
+  end
+end

data/lib/nano/helpers/node_proxy_helper.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+module Nano::NodeProxyHelper
+  def account_containing_block(hash)
+    block_account(hash: hash).account
+  end
+
+  def available
+    available_supply.available
+  end
+
+  def krai_from(amount:)
+    krai_from_raw(amount: amount).amount
+  end
+
+  def krai_to(amount:)
+    krai_to_raw(amount: amount).amount
+  end
+
+  def mrai_from(amount:)
+    mrai_from_raw(amount: amount).amount
+  end
+
+  def mrai_to(amount:)
+    mrai_to_raw(amount: amount).amount
+  end
+
+  def pending_exists?(hash:)
+    pending_exists(hash: hash).exists == 1
+  end
+
+  def rai_from(amount:)
+    rai_from_raw(amount: amount).amount
+  end
+
+  def rai_to(amount:)
+    rai_to_raw(amount: amount).amount
+  end
+
+  def work_valid?(work:, hash:)
+    work_validate(work: work, hash: hash).valid == 1
+  end
+end

data/lib/nano/helpers/wallet_proxy_helper.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+module Nano::WalletProxyHelper
+  def account_work(account:)
+    work_get.work(account: account).work
+  end
+
+  def add(key:, work: nil)
+    wallet_add(key: key, work: work).account
+  end
+
+  def balance
+    wallet_balance_total.balance
+  end
+
+  def balances(threshold: nil)
+    wallet_balances(threshold: threshold).balances
+  end
+
+  def begin_payment
+    payment_begin.account
+  end
+
+  def change_password(new_password:)
+    password_change(password: new_password).changed == 1
+  end
+
+  def change_seed(new_seed:)
+    wallet_change_seed(seed: new_seed)[:success] == ''
+  end
+
+  def contains?(account:)
+    wallet_contains(account: account).exists == 1
+  end
+
+  def create
+    wallet_create.wallet
+  end
+
+  def destroy
+    wallet_destroy
+  end
+
+  def enter_password(password)
+    password_enter(password: password).valid == 1
+  end
+
+  def export
+    JSON[wallet_export.json]
+  end
+
+  def frontiers
+    wallet_frontiers.frontiers
+  end
+
+  def init_payment
+    payment_init.status == 'Ready'
+  end
+
+  def locked?
+    wallet_locked.locked == 1
+  end
+
+  def password_valid?(password:)
+    password_valid(password: password).valid == 1
+  end
+
+  def pending_balance
+    wallet_balance_total.pending
+  end
+
+  def pending_blocks(count:, threshold: nil, source: nil)
+    wallet_pending(count: count, threshold: threshold, source: source).blocks
+  end
+
+  def receive_block(account:, block:)
+    receive.block(account: account, block: block).block
+  end
+
+  def representative
+    wallet_representative.representative
+  end
+
+  def republish(count:)
+    wallet_republish(count: count).blocks
+  end
+
+  def account_work_set(account:, work:)
+    work_set(account: account, work: work).work[:success] == ''
+  end
+  alias set_account_work account_work_set
+
+  def representative_set(representative:)
+    wallet_representative_set(representative: representative).set == 1
+  end
+  alias set_representative representative_set
+
+  def send_tx(source:, destination:, amount:)
+    rai_send(source: source, destination: destination, amount: amount).block
+  end
+  alias send_transaction send_tx
+
+  def work
+    wallet_work_get.works
+  end
+end

data/lib/nano/proxies/account.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+class Nano::Account
+  include Nano::Proxy
+  include Nano::AccountProxyHelper
+
+  attr_accessor :address
+
+  def initialize(address = nil, opts = {})
+    unless address.is_a?(String)
+      raise Nano::MissingParameters,
+            'Missing argument: address (str)'
+    end
+
+    @address = address
+    @client = opts[:client] || Nano.client
+  end
+
+  proxy_params account: :address
+
+  proxy_method :account_balance
+  proxy_method :account_block_count
+  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]
+  proxy_method :account_representative
+  proxy_method :account_representative_set, required: %i[wallet representative]
+  proxy_method :account_weight
+  proxy_method :delegators
+  proxy_method :delegators_count
+  proxy_method :frontiers, required: %i[count]
+  proxy_method :frontier_count
+  proxy_method :ledger,
+               required: %i[count],
+               optional: %i[representative weight pending sorting]
+  proxy_method :validate_account_number
+  proxy_method :pending, required: %i[count], optional: %i[threshold exists]
+  proxy_method :payment_wait, required: %i[amount timeout]
+  proxy_method :work_get
+  proxy_method :work_set
+end

data/lib/nano/proxies/accounts.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+class Nano::Accounts
+  include Nano::Proxy
+  include Nano::AccountsProxyHelper
+
+  attr_accessor :addresses
+
+  def initialize(addresses = nil, client = nil)
+    unless addresses.is_a?(Array)
+      raise Nano::MissingParameters,
+            'Missing argument: addresses (str[])'
+    end
+
+    @addresses = addresses
+    @client = client || Nano.client
+  end
+
+  proxy_params accounts: :addresses
+
+  proxy_method :accounts_balances
+  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]
+end

data/lib/nano/proxies/node.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+class Nano::Node
+  include Nano::Proxy
+  include Nano::NodeProxyHelper
+
+  proxy_method :available_supply
+  proxy_method :block, required: %i[hash]
+  proxy_method :block_account, 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]
+  proxy_method :bootstrap, required: %i[address port]
+  proxy_method :bootstrap_any
+  proxy_method :chain, required: %i[block count]
+  proxy_method :deterministic_key, required: %i[seed index]
+  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 :republish,
+               required: %i[hash],
+               optional: %i[count sources destinations]
+  proxy_method :search_pending, required: %i[wallet]
+  proxy_method :search_pending_all
+  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 :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

data/lib/nano/proxies/wallet.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+class Nano::Wallet
+  include Nano::Proxy
+  include Nano::WalletProxyHelper
+
+  attr_accessor :seed
+
+  def initialize(wallet_seed = nil, opts = {})
+    unless wallet_seed.is_a?(String)
+      raise Nano::MissingParameters,
+            'Missing argument: address (str)'
+    end
+
+    @seed = wallet_seed
+    @client = opts[:client] || Nano.client
+  end
+
+  proxy_params wallet: :seed
+
+  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 :send, required: %i[wallet source destination amount]
+  proxy_method :search_pending
+  proxy_method :wallet_add, required: %i[key], optional: %i[work]
+  proxy_method :wallet_balance_total
+  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
+  proxy_method :wallet_locked
+  proxy_method :wallet_pending,
+               required: %i[count], optional: %i[threshold source]
+  proxy_method :wallet_representative
+  proxy_method :wallet_representative_set, required: %i[representative]
+  proxy_method :wallet_republish, required: %i[count]
+  proxy_method :wallet_work_get
+  proxy_method :work_get
+  proxy_method :work_set
+end

data/lib/nano/proxy.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+module Nano::Proxy
+  attr_accessor :client
+
+  def initialize(opts = {})
+    @client = opts[:client] || Nano.client
+  end
+
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+  module ClassMethods
+    attr_reader :proxy_method_def, :proxy_param_def
+
+    def proxy_params(param_def = nil)
+      @proxy_param_def = param_def
+    end
+
+    def proxy_method(name, signature = nil)
+      @proxy_method_def ||= {}
+      @proxy_method_def[name] = signature
+    end
+
+    def proxy_methods
+      proxy_method_def.keys.sort
+    end
+
+    def methods
+      (super + proxy_methods).sort
+    end
+
+    def define_proxy_method(m, singleton = false)
+      send(
+        singleton ? :define_singleton_method : :define_method,
+        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.is_a?(Hash) && data.keys.map(&:to_s) == [m.to_s] ? data[m] : data
+      end
+    end
+
+    private
+
+    # Nano `send` action is also the method caller in Ruby ;)
+    def method_alias(m)
+      m == :send ? :tx_send : m
+    end
+
+    def method_missing(m, *args, &_block)
+      return super unless valid_method?(m)
+      define_proxy_method(m, true)
+      send(m, args.first)
+    end
+
+    def respond_to_missing?(m, include_private = false)
+      valid_method?(m) || super
+    end
+
+    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
+    self.class.proxy_methods
+  end
+
+  def methods
+    (super + proxy_methods).sort
+  end
+
+  private
+
+  def base_params
+    return if self.class.proxy_param_def.nil?
+    self.class
+        .proxy_param_def
+        .each_with_object({}) do |(k, v), params|
+      params[k] ||= send(v)
+    end
+  end
+
+  def method_missing(m, *args, &_block)
+    return super unless methods.include?(m)
+    self.class.define_proxy_method(m)
+    send(m, args.first)
+  end
+
+  def respond_to_missing?(m, include_private = false)
+    methods.include?(m) || super
+  end
+end

data/lib/nano/proxy_context.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+class Nano::ProxyContext
+  def initialize(klass, m, opts = {})
+    @klass = klass
+    @method_def = klass.proxy_method_def
+    @param_def = klass.proxy_param_def
+    @m = m
+    @opts = opts
+  end
+
+  def valid_proxy_method?
+    rpc_action?
+  end
+
+  def populate_params(params)
+    opts = validate_opts!
+    opts.merge!(params) if params
+    validate_params!
+    opts.delete_if { |_k, v| v.nil? }
+    opts
+  end
+
+  def validate_opts!
+    return @opts if @opts.is_a?(Hash)
+    return {} if @opts.nil?
+    raise Nano::InvalidParameterType,
+          'You must pass a hash to an action method'
+  end
+
+  def validate_params!
+    ensure_required_params!
+    ensure_no_forbidden_params!
+  end
+
+  def ensure_required_params!
+    missing_params = required_params - opts_keys
+    return unless missing_params.any?
+    raise Nano::MissingParameters,
+          "Missing required parameter(s): #{missing_params.join(', ')}"
+  end
+
+  def ensure_no_forbidden_params!
+    forbidden_params = base_param_keys + opts_keys - allowed_params
+    return unless forbidden_params.any?
+    raise Nano::ForbiddenParameter,
+          "Forbidden parameter(s) passed: #{forbidden_params.join(', ')}"
+  end
+
+  private
+
+  def opts_keys
+    @opts.nil? ? [] : @opts.keys
+  end
+
+  def allowed_params
+    base_param_keys + required_params + optional_params
+  end
+
+  def required_params
+    return [] unless @method_def && @method_def[@m]
+    @method_def[@m][:required]
+  end
+
+  def optional_params
+    return [] unless @method_def && @method_def[@m]
+    @method_def[@m][:optional]
+  end
+
+  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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+require 'hashie'
+
+class Nano::Response < Hash
+  include ::Hashie::Extensions::MergeInitializer
+  include ::Hashie::Extensions::IndifferentAccess
+  include ::Hashie::Extensions::MethodAccess
+
+  def initialize(hash = {})
+    super
+    coerce_values
+  end
+
+  private
+
+  def coerce_values
+    merge!(self) { |_k, v| to_f_or_i_or_s(v) }
+  end
+
+  def to_f_or_i_or_s(v)
+    (float = Float(v)) && (float % 1.0).zero? ? float.to_i : float
+  rescue ArgumentError, TypeErrror
+    v
+  end
+end

data/lib/nano/version.rb

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

data/lib/nano_rpc.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+require 'nano/version'
+require 'nano/client'
+require 'nano/errors'
+require 'nano/proxy'
+require 'nano/proxy_context'
+require 'nano/response'
+require 'nano/helpers/account_proxy_helper'
+require 'nano/helpers/accounts_proxy_helper'
+require 'nano/helpers/node_proxy_helper'
+require 'nano/helpers/wallet_proxy_helper'
+require 'nano/proxies/account'
+require 'nano/proxies/accounts'
+require 'nano/proxies/node'
+require 'nano/proxies/wallet'

data/nano_rpc.gemspec

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'nano/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'nano_rpc'
+  spec.version       = Nano::VERSION
+  spec.authors       = ['Justin Craig-Kuhn (JCK)']
+  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.homepage      = 'https://github.com/jcraigk/ruby_nano_rpc'
+  spec.license       = 'MIT'
+
+  spec.files = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = 'exe'
+  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 '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_runtime_dependency 'hashie', '~> 3.5', '>= 3.5.7'
+  spec.add_runtime_dependency 'rest-client', '~> 2.0', '>= 2.0.2'
+end

metadata

@@ -0,0 +1,195 @@
+--- !ruby/object:Gem::Specification
+name: nano_rpc
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Justin Craig-Kuhn (JCK)
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2018-01-31 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.11.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.11.3
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.52.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.52.1
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.15.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.15.1
+- !ruby/object:Gem::Dependency
+  name: hashie
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.5.7
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.5.7
+- !ruby/object:Gem::Dependency
+  name: rest-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+    - - ">="
+      - !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.
+email:
+- jcraigk@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/nano/client.rb
+- lib/nano/errors.rb
+- lib/nano/helpers/account_proxy_helper.rb
+- lib/nano/helpers/accounts_proxy_helper.rb
+- lib/nano/helpers/node_proxy_helper.rb
+- lib/nano/helpers/wallet_proxy_helper.rb
+- lib/nano/proxies/account.rb
+- lib/nano/proxies/accounts.rb
+- lib/nano/proxies/node.rb
+- lib/nano/proxies/wallet.rb
+- lib/nano/proxy.rb
+- lib/nano/proxy_context.rb
+- lib/nano/response.rb
+- lib/nano/version.rb
+- lib/nano_rpc.rb
+- nano_rpc.gemspec
+homepage: https://github.com/jcraigk/ruby_nano_rpc
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.3
+signing_key: 
+specification_version: 4
+summary: RPC wrapper for Nano digital nodes written in Ruby
+test_files: []