raiblocks_rpc 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 59e7a8aaac7c10d6376abdd0aaf840ff90d8e22d67acffa0a5920ce1e1848e2d
-  data.tar.gz: be96b5e6188593865f80507fd92cae0c218790c91a1dbf9fedf13a5a6397c43d
+  metadata.gz: e8ce256987fa884ae76a35442663619aca83e7066c488b5bbc057d19f5845310
+  data.tar.gz: ddf09a688159fa73df64c9f9de92503e0c022ef9884530afc03177794583b445
 SHA512:
-  metadata.gz: 9c7482203fbeed536648a9c67b4f07284a0953b774abc6be17ec92159badb2956fb95385c430a4598af2822684b83458e522649d4ac5a669d2fda6c94ee98586
-  data.tar.gz: 229ea7d13d2aca576da81fc439d5c47bff6064e388ab2be56962c76e456a10b525d0d72907711d32fd8ac74cc455099aea5da5f50d873b8a74de7f0d7c865070
+  metadata.gz: 401f882f6e8557ab9a56df31eb381a1c1ca4848e92ce1dcf921803c1214b4808865a174b91411e8aeb2fd0db509856c5dc2feafbb01f3c17306de57929e2f03e
+  data.tar.gz: d8788cdfe0d40faf4b750b01c0d757a8e9d333102ac8af783a41eea524be17ac769c7383273e2a77298d93c7e41a68062b530a10b7f74587a373d34b6738ee97

data/README.md

@@ -1,132 +1,3 @@
 # Raiblocks RPC
 
-An RPC wrapper for RaiBlocks written in Ruby.  It connects to an individual 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 convenience methods.
-
-To run a RaiBlocks node locally, see [RaiBlocks Docker Docs](https://github.com/clemahieu/raiblocks/wiki/Docker-node).
-
-## Installation
-
-Add this line to your application's Gemfile:
-
-```ruby
-gem 'raiblocks_rpc'
-```
-
-And then execute:
-
-    $ bundle
-
-Or install it yourself as:
-
-    $ gem install raiblocks_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 that provide helper methods for terser code.
-
-### Raw RPC Calls
-
-The RCP client exposes raw Remote Procedure Call methods according to the [RaiBlocks 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 = Raiblocks.client
-
-# Connect to custom host
-client = Raiblocks::Client.new(host: 'myraiblocksnode', port: 1234)
-```
-
-Then make a `call`, passing the the action and the data:
-
-```ruby
-  client.call(:account_balance, account: 'xrb_someaddress1234')
-  # => {"balance"=>100, "pending"=>0}
-````
-
-Response data are provided as `Hashie` objects with integer coercion, indifferent access, and method access so you have several options for accessing returned values.
-
-```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 [RaiBlocks RPC Docs](https://github.com/clemahieu/raiblocks/wiki/RPC-protocol).  Instead, the following objects are provided:
-
-```ruby
-  Raiblocks::Account # { account: 'xrb_address12345' }
-  Raiblocks::Accounts # { accounts: %w[xrb_address12345 xrb_address67890] }
-  Raiblocks::Node
-  Raiblocks::Wallet # { wallet: 'F3093AB' }
-```
-
-`Account`, `Accounts`, and `Wallet` each require a single parameter to be passed during initialization.  You can then make calls on these objects without needing to pass in the param for subsequent calls.  All RPC methods are provided directly as methods.
-
-```ruby
-  account = Raiblocks::Account.new('xrb_someaddress1234')
-
-  account.account_balance
-  # => {"balance"=>100, "pending"=>0}
-  account.account_balance.balance
-  # 100
-  account.balance # Fastest to use #balance helper method
-  # 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, :account_history, :account_info, :account_key, :account_list, :account_move, :account_remove, :account_representative, :account_representative_set, :account_weight, :accounts_balances, :accounts_create, :accounts_frontiers, :accounts_pending, :delegators, :delegators_count, :frontier_count, :frontiers, :ledger, :payment_wait, :pending, :validate_account_number]
-```
-
-Helper methods are provided for frequently used calls:
-
-```ruby
-  Raiblocks::Account.helper_methods
-  # => [:balance]
-
-  Raiblocks::Account.new('xrb_someaddress1234').balance
-  # => 250
-```
-
-`Node` methods are provided at both the instance and class levels:
-
-```ruby
-  Raiblocks::Node.version
-  # => {"rpc_version"=>1, "store_version"=>10, "node_vendor"=>"RaiBlocks 9.0"}
-
-  node = Raiblocks::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 = Raiblocks::Client.new(host: 'myraiblocksnode', port: 1234)
-  account = Raiblocks::Account.new('xrb_someaddress1234', client: client)
-```
-
-For a more comprehensive guide, see the [Wiki](https://github.com/jcraigk/ruby_raiblocks_rpc/wiki).
-
-## License
-
-The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+Moved to [Nano RPC](https://github.com/jcraigk/ruby_nano_rpc).

data/lib/raiblocks/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module Raiblocks
-  VERSION = '0.4.0'
+  VERSION = '0.5.0'
 end

data/lib/raiblocks_rpc.rb

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

data/raiblocks_rpc.gemspec

@@ -18,6 +18,12 @@ Gem::Specification.new do |spec|
   spec.homepage      = 'https://github.com/jcraigk/ruby_raiblocks_rpc'
   spec.license       = 'MIT'
 
+  spec.post_install_message = <<-MESSAGE
+  !    The `raiblocks_rpc` gem has been deprecated and has been replaced by `nano_rpc`.
+  !    See: https://rubygems.org/gems/nano_rpc
+  !    And: https://github.com/jcraigk/ruby_nano_rpc
+  MESSAGE
+
   spec.files = `git ls-files -z`.split("\x0").reject do |f|
     f.match(%r{^(test|spec|features)/})
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: raiblocks_rpc
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Justin Craig-Kuhn (JCK)
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-01-27 00:00:00.000000000 Z
+date: 2018-01-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -152,19 +152,6 @@ files:
 - Rakefile
 - bin/console
 - bin/setup
-- lib/raiblocks/client.rb
-- lib/raiblocks/errors.rb
-- lib/raiblocks/helpers/account_proxy_helper.rb
-- lib/raiblocks/helpers/accounts_proxy_helper.rb
-- lib/raiblocks/helpers/node_proxy_helper.rb
-- lib/raiblocks/helpers/wallet_proxy_helper.rb
-- lib/raiblocks/proxies/account.rb
-- lib/raiblocks/proxies/accounts.rb
-- lib/raiblocks/proxies/node.rb
-- lib/raiblocks/proxies/wallet.rb
-- lib/raiblocks/proxy.rb
-- lib/raiblocks/proxy_context.rb
-- lib/raiblocks/response.rb
 - lib/raiblocks/version.rb
 - lib/raiblocks_rpc.rb
 - raiblocks_rpc.gemspec
@@ -172,7 +159,10 @@ homepage: https://github.com/jcraigk/ruby_raiblocks_rpc
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message: |2
+    !    The `raiblocks_rpc` gem has been deprecated and has been replaced by `nano_rpc`.
+    !    See: https://rubygems.org/gems/nano_rpc
+    !    And: https://github.com/jcraigk/ruby_nano_rpc
 rdoc_options: []
 require_paths:
 - lib

data/lib/raiblocks/client.rb

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-require 'rest-client'
-require 'json'
-
-module Raiblocks
-  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 = Raiblocks::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 Raiblocks::NodeConnectionFailure,
-            "Node connection failure at #{url}"
-    end
-
-    def url
-      "http://#{host}:#{port}"
-    end
-
-    def ensure_status_success!(response)
-      return if response.code == 200
-      raise Raiblocks::BadRequest,
-            "Error response from node: #{JSON[response.body]}"
-    end
-
-    def ensure_valid_response!(data)
-      return unless data['error']
-      raise Raiblocks::InvalidRequest,
-            "Invalid request: #{data['error']}"
-    end
-  end
-end

data/lib/raiblocks/errors.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-module Raiblocks
-  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/raiblocks/helpers/account_proxy_helper.rb

@@ -1,70 +0,0 @@
-# frozen_string_literal: true
-module Raiblocks::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/raiblocks/helpers/accounts_proxy_helper.rb

@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-module Raiblocks::AccountsProxyHelper
-  def frontiers
-    accounts_frontiers.frontiers
-  end
-
-  def balances
-    accounts_balances.balances
-  end
-
-  def create(wallet:, count:, work: nil)
-    accounts_create(wallet: wallet, count: count, work: work).accounts
-  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 Raiblocks::Account
-  def [](idx)
-    return unless @addresses[idx]
-    @account_objects ||= []
-    @account_objects[idx] ||= Raiblocks::Account.new(@addresses[idx])
-  end
-
-  def <<(val)
-    @addresses << val
-  end
-
-  def each(&_block)
-    @addresses.each do |address|
-      yield Raiblocks::Account.new(address)
-    end
-  end
-
-  def first
-    self[0]
-  end
-
-  def second
-    self[1]
-  end
-
-  def third
-    self[2]
-  end
-end

data/lib/raiblocks/helpers/node_proxy_helper.rb

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-module Raiblocks::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/raiblocks/helpers/wallet_proxy_helper.rb

@@ -1,105 +0,0 @@
-# frozen_string_literal: true
-module Raiblocks::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/raiblocks/proxies/account.rb

@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-class Raiblocks::Account
-  include Raiblocks::Proxy
-  include Raiblocks::AccountProxyHelper
-
-  attr_accessor :address
-
-  def initialize(address = nil, opts = {})
-    unless address.is_a?(String)
-      raise Raiblocks::MissingParameters,
-            'Missing argument: address (str)'
-    end
-
-    @address = address
-    @client = opts[:client] || Raiblocks.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/raiblocks/proxies/accounts.rb

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

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-class Raiblocks::Node
-  include Raiblocks::Proxy
-  include Raiblocks::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/raiblocks/proxies/wallet.rb

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-class Raiblocks::Wallet
-  include Raiblocks::Proxy
-  include Raiblocks::WalletProxyHelper
-
-  attr_accessor :seed
-
-  def initialize(wallet_seed = nil, opts = {})
-    unless wallet_seed.is_a?(String)
-      raise Raiblocks::MissingParameters,
-            'Missing argument: address (str)'
-    end
-
-    @seed = wallet_seed
-    @client = opts[:client] || Raiblocks.client
-  end
-
-  proxy_params wallet: :seed
-
-  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
-  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
-end

data/lib/raiblocks/proxy.rb

@@ -1,100 +0,0 @@
-# frozen_string_literal: true
-module Raiblocks::Proxy
-  attr_accessor :client
-
-  def initialize(opts = {})
-    @client = opts[:client] || Raiblocks.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 = Raiblocks::ProxyContext.new(
-          singleton ? self : self.class, m, opts
-        ).populate_params(singleton ? nil : base_params)
-        data = Raiblocks.client.call(m, params)
-        data.is_a?(Hash) && data.keys.map(&:to_s) == [m.to_s] ? data[m] : data
-      end
-    end
-
-    private
-
-    # Raiblocks `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] ||= Raiblocks::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/raiblocks/proxy_context.rb

@@ -1,80 +0,0 @@
-# frozen_string_literal: true
-class Raiblocks::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 Raiblocks::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 Raiblocks::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 Raiblocks::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/raiblocks/response.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-require 'hashie'
-
-class Raiblocks::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