nano_rpc 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5505de736e20d672bed90df3856fef48148882a3726f27bb10fa03eb2db5e4b0
-  data.tar.gz: 20a28a63f524ecc1af9a2a94f91b724b5996b767ba35202a7416841ffd98aac8
+  metadata.gz: 0d161d743c5ec1f860437f0c90189ed939280bc090f135cbacd7f9c442404000
+  data.tar.gz: ff48c6fdd7cbf214ff0d967e5fdf924ad6c51aa5a803dfbe3f92c343d453a19e
 SHA512:
-  metadata.gz: 61056e815bf6a31ccb9dbacc4581b4fd99ee9769fba6251c5f84da884f1bb9d430604a09fb053b4a21613e9b318b81f40c9950f1fc718d5bd4ff2656cf60f703
-  data.tar.gz: 03e4d60c84c306ebe878c527d00a3084b083de0e788795995dc0f0d2459f6a48b6e6c49f7a0e4474baaa2f81f9d727bbf9cad9ac0c170b3a03ef004e933d1cf8
+  metadata.gz: a71a9d9558fb9abdca9484158761567edb522cf29322e36a764811c5b669e3eeb086f3d3125ca94d3de862e45b8cf071a1bd3fb48f1534c6251ccd0f0f4f32b4
+  data.tar.gz: c928cd95666dd0e84e67f71275e6d475947c90da9c89a82cfb1ae6f4193c87a9686c1dec3ba004c722373f20f3dca857c4c285c7fc652c64d61792d8552a4e41

data/README.md

@@ -1,6 +1,8 @@
 # Nano RPC
 
-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)).
+![Ruby Logo](https://i.imgur.com/pTKxwQq.png)
+
+An RPC wrapper for Nano digitial currency nodes written in Ruby. 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).
 
@@ -33,10 +35,10 @@ Every method requires an `action`, which is passed as the first argument to `cal
 First setup the client:
 
 ```ruby
-# Connect to localhost:7076
+# Connect to the default node (localhost:7076)
 client = Nano.client
 
-# Connect to custom host
+# or connect to a custom node
 client = Nano::Client.new(host: 'mynanonode', port: 1234)
 ```
 
@@ -60,72 +62,43 @@ Response data are provided as [Hashie](https://github.com/intridea/hashie) objec
   # => 100
 ````
 
-### Proxy Objects
+### 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:
 
-```ruby
-  Nano::Account
-  Nano::Accounts
-  Nano::Node
-  Nano::Wallet
-```
+* [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)
 
-`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.
+`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"=>0}
+  # => {"balance"=>100, "pending"=>5}
   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, ...]
+  # => 100
 ```
 
-There are also helper methods for terser code:
+There are also helper methods to bypass repetitive nested calls:
 
 ```ruby
-  account = Nano::Account.new('xrb_someaddress1234')
   account.balance
-  # 100
+  # => 100
   account.pending_balance
-  # 0
-```
-
-`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
-  node.version.rpc_version
-  # => 1
-  node.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.available
-  # => 132596127030666124778600855847014518457
-  node.block_count.unchecked
-  # => 4868605
+  # => 5
 ```
 
-You can point each proxy object at its own node by passing a custom client in:
+You can point each proxy object at its own node by passing in a client instance:
 
 ```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).
+For a comprehensive guide, see the [Wiki](https://github.com/jcraigk/ruby_nano_rpc/wiki).
 
 ## License
 

data/lib/{nano → nano_rpc}/errors.rb

@@ -5,7 +5,6 @@ module Nano
   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 → nano_rpc}/helpers/account_proxy_helper.rb

@@ -26,15 +26,15 @@ module Nano::AccountProxyHelper
 
   def move(from:, to:)
     account_move(
-      wallet: to,
-      source: from,
+      wallet: wallet_seed(to),
+      source: wallet_seed(from),
       accounts: [address]
     ).moved == 1
   end
 
   def wallet_work_set(wallet:, work:)
     work_set(
-      wallet: wallet,
+      wallet: wallet_seed(wallet),
       work: work
     ).success == ''
   end
@@ -55,7 +55,7 @@ module Nano::AccountProxyHelper
 
   def remove(opts)
     account_remove(
-      wallet: opts_pluck(opts, :wallet)
+      wallet: wallet_seed(opts_pluck(opts, :wallet))
     ).removed == 1
   end
 
@@ -65,7 +65,7 @@ module Nano::AccountProxyHelper
 
   def representative_set(wallet:, representative:)
     account_representative_set(
-      wallet: wallet,
+      wallet: wallet_seed(wallet),
       representative: representative
     ).set == 1
   end

data/lib/{nano → nano_rpc}/helpers/accounts_proxy_helper.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 module Nano::AccountsProxyHelper
+  include Nano::ApplicationHelper
+
   def balances
     accounts_balances
       .balances
@@ -22,7 +24,10 @@ module Nano::AccountsProxyHelper
   end
 
   def move(from:, to:)
-    account_move(wallet: to, source: from).moved == 1
+    account_move(
+      source: wallet_seed(from),
+      wallet: wallet_seed(to)
+    ).moved == 1
   end
 
   def pending(count:, threshold: nil, source: nil)
@@ -60,4 +65,12 @@ module Nano::AccountsProxyHelper
   def third
     self[2]
   end
+
+  def last
+    self[-1]
+  end
+
+  def size
+    addresses.size
+  end
 end

data/lib/nano_rpc/helpers/application_helper.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+module Nano::ApplicationHelper
+  private
+
+  def opts_pluck(opts, key)
+    opts.is_a?(Hash) ? opts[key] : opts
+  end
+
+  def wallet_seed(wallet)
+    wallet.is_a?(Nano::Wallet) ? wallet.seed : wallet
+  end
+
+  def account_address(account)
+    account.is_a?(Nano::Account) ? account.address : account
+  end
+
+  def accounts_addresses(accounts)
+    accounts.is_a?(Nano::Accounts) ? accounts.addresses : accounts
+  end
+end

data/lib/{nano → nano_rpc}/helpers/node_proxy_helper.rb

@@ -6,7 +6,7 @@ module Nano::NodeProxyHelper
     block_account(opts_hash(opts)).account
   end
 
-  def available
+  def available_nano
     available_supply.available
   end
 
@@ -14,44 +14,16 @@ module Nano::NodeProxyHelper
     Nano::Wallet.new(wallet_create.wallet)
   end
 
-  def krai_from(opts)
-    krai_from_raw(opts_amount(opts)).amount
-  end
-
-  def krai_to(opts)
-    krai_to_raw(opts_amount(opts)).amount
-  end
-
-  def mrai_from(opts)
-    mrai_from_raw(opts_amount(opts)).amount
-  end
-
-  def mrai_to(opts)
-    mrai_to_raw(opts_amount(opts)).amount
-  end
-
   def pending_exists?(opts)
     pending_exists(opts_hash(opts)).exists == 1
   end
 
-  def rai_from(opts)
-    rai_from_raw(opts_amount(opts)).amount
-  end
-
-  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

data/lib/{nano → nano_rpc}/helpers/wallet_proxy_helper.rb

@@ -3,7 +3,13 @@ module Nano::WalletProxyHelper
   include Nano::ApplicationHelper
 
   def account_work(opts)
-    work_get(opts_account(opts)).work
+    work_get(
+      account: account_address(opts_pluck(opts, :account))
+    ).work
+  end
+
+  def accounts
+    Nano::Accounts.new(account_list.accounts)
   end
 
   def add_key(key:, work: true)
@@ -39,15 +45,17 @@ module Nano::WalletProxyHelper
   end
 
   def contains?(opts)
-    wallet_contains(opts_account(opts)).exists == 1
+    wallet_contains(
+      account: account_address(opts_pluck(opts, :account))
+    ).exists == 1
   end
 
   def create_account(work: true)
-    account_create(work: work).account
+    Nano::Account.new(account_create(work: work).account)
   end
 
   def create_accounts(count:, work: true)
-    accounts_create(count: count, work: work).accounts
+    Nano::Accounts.new(accounts_create(count: count, work: work).accounts)
   end
 
   def destroy
@@ -78,9 +86,9 @@ module Nano::WalletProxyHelper
 
   def move_accounts(to:, accounts:)
     account_move(
-      wallet: to,
+      wallet: wallet_seed(to),
       source: seed,
-      accounts: accounts
+      accounts: accounts_addresses(accounts)
     ).moved == 1
   end
 
@@ -114,11 +122,16 @@ module Nano::WalletProxyHelper
   alias blocks_pending pending_blocks
 
   def receive_block(account:, block:)
-    receive(account: account, block: block).block
+    receive(
+      account: account_address(account),
+      block: block
+    ).block
   end
 
   def remove_account(opts)
-    account_remove(opts_account(opts)).removed == 1
+    account_remove(
+      account: account_address(opts_pluck(opts, :account))
+    ).removed == 1
   end
 
   def representative
@@ -130,7 +143,10 @@ module Nano::WalletProxyHelper
   end
 
   def account_work_set(account:, work:)
-    work_set(account: account, work: work).success == ''
+    work_set(
+      account: account_address(account),
+      work: work
+    ).success == ''
   end
   alias set_account_work account_work_set
 
@@ -143,8 +159,8 @@ module Nano::WalletProxyHelper
 
   def send_nano(from:, to:, amount:, work: nil)
     send_currency(
-      source: from,
-      destination: to,
+      source: wallet_seed(from),
+      destination: wallet_seed(to),
       amount: amount,
       work: work
     ).block
@@ -154,10 +170,4 @@ module Nano::WalletProxyHelper
   def work
     wallet_work_get.works
   end
-
-  private
-
-  def opts_account(opts)
-    { account: opts_pluck(opts, :account) }
-  end
 end

data/lib/nano_rpc/proxy.rb

@@ -0,0 +1,153 @@
+# 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
+  end
+
+  def proxy_methods
+    self.class.proxy_methods
+  end
+
+  def methods
+    (super + proxy_methods).sort
+  end
+
+  private
+
+  def method_missing(m, *args, &_block)
+    return super unless methods.include?(m)
+    define_proxy_method(m)
+    send(m, args.first)
+  end
+
+  def respond_to_missing?(m, include_private = false)
+    methods.include?(m) || super
+  end
+
+  def define_proxy_method(m)
+    self.class.send(:define_method, method_alias(m)) do |call_args = {}|
+      @m = m
+      @call_args = call_args
+
+      validate_params!
+      execute_call
+    end
+  end
+
+  def execute_call
+    expose_nested_data(@client.call(@m, @call_args))
+  end
+
+  def base_params
+    @base_params ||= begin
+      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
+  end
+
+  # Nano `send` action is also the method caller in Ruby ;)
+  def method_alias(m)
+    m == :send ? :send_currency : m
+  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
+  end
+
+  def validate_params!
+    prepare_params
+    ensure_required_params!
+    prevent_forbidden_params!
+    drop_nil_params
+  end
+
+  def prepare_params
+    # Allow non-Hash literal argument if this method requires single param
+    # Ex `create('new')` vs `create(name: 'new')`
+    @call_args = if required_params.size == 1 && !@call_args.is_a?(Hash)
+                   { required_params.first => @call_args }
+                 else
+                   @call_args.is_a?(Hash) ? @call_args : {}
+                 end
+    @call_args.merge!(base_params) if base_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 prevent_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
+
+  def drop_nil_params
+    @call_args.delete_if { |_k, v| v.nil? }
+  end
+
+  def opts_keys
+    @call_args.is_a?(Hash) ? @call_args.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_def
+    self.class.proxy_method_def
+  end
+
+  def param_def
+    self.class.proxy_param_def
+  end
+end

data/lib/{nano → nano_rpc}/version.rb

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

data/lib/nano_rpc.rb

@@ -1,16 +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/application_helper'
-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'
+require 'nano_rpc/version'
+require 'nano_rpc/client'
+require 'nano_rpc/errors'
+require 'nano_rpc/proxy'
+require 'nano_rpc/response'
+require 'nano_rpc/helpers/application_helper'
+require 'nano_rpc/helpers/account_proxy_helper'
+require 'nano_rpc/helpers/accounts_proxy_helper'
+require 'nano_rpc/helpers/node_proxy_helper'
+require 'nano_rpc/helpers/wallet_proxy_helper'
+require 'nano_rpc/proxies/account'
+require 'nano_rpc/proxies/accounts'
+require 'nano_rpc/proxies/node'
+require 'nano_rpc/proxies/wallet'

data/nano_rpc.gemspec

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'nano/version'
+require 'nano_rpc/version'
 
 Gem::Specification.new do |spec|
   spec.name          = 'nano_rpc'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nano_rpc
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Justin Craig-Kuhn (JCK)
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-02-04 00:00:00.000000000 Z
+date: 2018-02-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -151,22 +151,21 @@ files:
 - 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/application_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
+- lib/nano_rpc/client.rb
+- lib/nano_rpc/errors.rb
+- lib/nano_rpc/helpers/account_proxy_helper.rb
+- lib/nano_rpc/helpers/accounts_proxy_helper.rb
+- lib/nano_rpc/helpers/application_helper.rb
+- lib/nano_rpc/helpers/node_proxy_helper.rb
+- lib/nano_rpc/helpers/wallet_proxy_helper.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
+- lib/nano_rpc/version.rb
 - nano_rpc.gemspec
 homepage: https://github.com/jcraigk/ruby_nano_rpc
 licenses:

data/lib/nano/helpers/application_helper.rb

@@ -1,8 +0,0 @@
-# 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/proxy.rb

@@ -1,97 +0,0 @@
-# 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(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 = (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 ? :send_currency : 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
-  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

@@ -1,68 +0,0 @@
-# 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 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
-end