nanook 2.2.0 → 3.0.0

data/lib/nanook/public_key.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require_relative 'util'
+
+class Nanook
+  # The <tt>Nanook::PublicKey</tt> class lets you manage your node's keys.
+  class PublicKey
+    include Nanook::Util
+
+    def initialize(rpc, key)
+      @rpc = rpc
+      @key = key.to_s
+    end
+
+    def id
+      @key
+    end
+
+    # @param other [Nanook::PublicKey] public key to compare
+    # @return [Boolean] true if keys are equal
+    def ==(other)
+      other.class == self.class &&
+        other.id == id
+    end
+    alias eql? ==
+
+    # The hash value is used along with #eql? by the Hash class to determine if two objects
+    # reference the same hash key.
+    #
+    # @return [Integer]
+    def hash
+      id.hash
+    end
+
+    # Returns the account for a public key
+    #
+    # @return [Nanook::Account] account for the public key
+    def account
+      account = rpc(:account_get, _access: :account)
+      as_account(account)
+    end
+
+    # @return [String]
+    def to_s
+      "#{self.class.name}(id: \"#{short_id}\")"
+    end
+    alias inspect to_s
+
+    private
+
+    def rpc(action, params = {})
+      @rpc.call(action, { key: @key }.merge(params))
+    end
+  end
+end

data/lib/nanook/rpc.rb

@@ -1,8 +1,9 @@
+# frozen_string_literal: true
+
 require 'json'
 require 'symbolized'
 
 class Nanook
-
   # The <tt>Nanook::Rpc</tt> class is responsible for maintaining the
   # connection to the RPC server, calling the RPC and parsing its response
   # into Ruby primitives.
@@ -14,23 +15,35 @@ class Nanook
   #   nanook = Nanook.new
   #   nanook.rpc(:accounts_create, wallet: wallet_id, count: 2)
   class Rpc
-
-    # Default RPC server and port to connect to
-    DEFAULT_URI = "http://localhost:7076"
-    # Default request timeout in seconds
+    # Default RPC server and port to connect to.
+    DEFAULT_URI = 'http://[::1]:7076'
+    # Default request timeout in seconds.
     DEFAULT_TIMEOUT = 60
+    # Error expected to be returned when the RPC makes a call that requires the
+    # `enable_control` setting to be enabled when it is disabled.
+    RPC_CONTROL_DISABLED_ERROR = 'RPC control is disabled'
 
-    def initialize(uri=DEFAULT_URI, timeout:DEFAULT_TIMEOUT)
+    def initialize(uri = DEFAULT_URI, timeout: DEFAULT_TIMEOUT)
       @rpc_server = URI(uri)
 
-      unless ['http', 'https'].include?(@rpc_server.scheme)
-        raise ArgumentError.new("URI must have http or https in it. Was given: #{uri}")
+      unless %w[http https].include?(@rpc_server.scheme)
+        raise ArgumentError, "URI must have http or https in it. Was given: #{uri}"
       end
 
-      @http = Net::HTTP.new(@rpc_server.host, @rpc_server.port)
+      @http = Net::HTTP.new(@rpc_server.hostname, @rpc_server.port)
       @http.read_timeout = timeout
-      @request = Net::HTTP::Post.new(@rpc_server.request_uri, {"user-agent" => "Ruby nanook gem"})
-      @request.content_type = "application/json"
+      @request = Net::HTTP::Post.new(@rpc_server.request_uri, { 'user-agent' => "Ruby nanook gem v#{Nanook::VERSION}" })
+      @request.content_type = 'application/json'
+    end
+
+    # Tests the RPC connection. Returns +true+ if connection is successful,
+    # otherwise raises an exception.
+    #
+    # @raise [Errno::ECONNREFUSED] if connection is unsuccessful
+    # @return [Boolean] true if connection is successful
+    def test
+      call(:telemetry)
+      true
     end
 
     # Calls the RPC server and returns the response.
@@ -39,57 +52,104 @@ class Nanook
     #   expects an "action" param to identify what RPC action is being called.
     # @param params [Hash] all other params to pass to the RPC
     # @return [Hash] the response from the RPC
-    def call(action, params={})
-      # Stringify param values
-      params = Hash[params.map {|k, v| [k, v.to_s] }]
+    def call(action, params = {})
+      coerce_to = params.delete(:_coerce)
+      access_as = params.delete(:_access)
 
-      @request.body = { action: action }.merge(params).to_json
+      raw_hash = make_call(action, params)
 
-      response = @http.request(@request)
+      check_for_errors!(raw_hash)
 
-      if response.is_a?(Net::HTTPSuccess)
-        hash = JSON.parse(response.body)
-        process_hash(hash)
-      else
-        raise Nanook::Error.new("Encountered net/http error #{response.code}: #{response.class.name}")
-      end
+      hash = parse_values(raw_hash)
+
+      hash = hash[access_as] if access_as
+      hash = coerce_empty_string_to_type(hash, coerce_to) if coerce_to
+
+      hash
     end
 
     # @return [String]
-    def inspect
-      "#{self.class.name}(host: \"#{@rpc_server}\", timeout: #{@http.read_timeout} object_id: \"#{"0x00%x" % (object_id << 1)}\")"
+    def to_s
+      "#{self.class.name}(host: \"#{@rpc_server}\", timeout: #{@http.read_timeout})"
     end
+    alias inspect to_s
 
     private
 
+    def make_call(action, params)
+      # Stringify param values
+      params = params.dup.transform_values do |v|
+        next v if v.is_a?(Array)
+
+        v.to_s
+      end
+
+      @request.body = { action: action }.merge(params).to_json
+
+      response = @http.request(@request)
+
+      raise Nanook::ConnectionError, "Encountered net/http error #{response.code}: #{response.class.name}" \
+        unless response.is_a?(Net::HTTPSuccess)
+
+      JSON.parse(response.body)
+    end
+
+    # Raises a {Nanook::NodeRpcConfigurationError} or {Nanook::NodeRpcError} if the RPC
+    # response contains an `:error` key.
+    def check_for_errors!(response)
+      # Raise a special error for when `enable_control` should be enabled.
+      if response['error'] == RPC_CONTROL_DISABLED_ERROR
+        raise Nanook::NodeRpcConfigurationError,
+              'RPC must have the `enable_control` setting enabled to perform this action.'
+      end
+
+      # Raise any other error.
+      raise Nanook::NodeRpcError, "An error was returned from the RPC: #{response['error']}" if response.key?('error')
+    end
+
     # Recursively parses the RPC response, sending values to #parse_value
-    def process_hash(h)
-      new_hash = h.map do |k,v|
-        v = if v.is_a?(Array)
-          if v[0].is_a?(Hash)
-            v.map{|v| process_hash(v)}
-          else
-            v.map{|v| parse_value(v)}
-          end
-        elsif v.is_a?(Hash)
-          process_hash(v)
-        else
-          parse_value(v)
-        end
-
-        [k, v]
+    def parse_values(hash)
+      new_hash = hash.map do |k, val|
+        new_val = case val
+                  when Array
+                    if val[0].is_a?(Hash)
+                      val.map { |v| parse_values(v) }
+                    else
+                      val.map { |v| parse_value(v) }
+                    end
+                  when Hash
+                    parse_values(val)
+                  else
+                    parse_value(val)
+                  end
+
+        [k, new_val]
       end
 
       Hash[new_hash.sort].to_symbolized_hash
     end
 
     # Converts Strings to primitives
-    def parse_value(v)
-      return v.to_i if v.match(/^\d+\Z/)
-      return true if v == "true"
-      return false if v == "false"
-      v
+    def parse_value(value)
+      return value.to_i if value.match(/^\d+\Z/)
+      return true if value == 'true'
+      return false if value == 'false'
+
+      value
     end
 
+    # Converts an empty String value into an empty version of another type.
+    #
+    # The RPC often returns an empty String as a value to signal
+    # emptiness, rather than consistent types like an empty Array,
+    # or empty Hash.
+    #
+    # @param response the value returned from the RPC server
+    # @param type the type to return an empty of
+    def coerce_empty_string_to_type(response, type)
+      return type.new if response == '' || response.nil?
+
+      response
+    end
   end
 end

data/lib/nanook/util.rb

@@ -1,44 +1,93 @@
+# frozen_string_literal: true
+
 require 'bigdecimal'
 
 class Nanook
-
-  # Set of class utility methods.
-  class Util
-
+  # Set of utility methods.
+  module Util
     # Constant used to convert back and forth between raw and NANO.
-    STEP = BigDecimal.new("10")**BigDecimal.new("30")
+    STEP = BigDecimal('10')**BigDecimal('30')
+
+    private
 
     # Converts an amount of NANO to an amount of raw.
     #
     # @param nano [Float|Integer] amount in nano
     # @return [Integer] amount in raw
-    def self.NANO_to_raw(nano)
-      (BigDecimal.new(nano.to_s) * STEP).to_i
+    def NANO_to_raw(nano)
+      return if nano.nil?
+
+      (BigDecimal(nano.to_s) * STEP).to_i
     end
 
     # Converts an amount of raw to an amount of NANO.
     #
     # @param raw [Integer] amount in raw
     # @return [Float|Integer] amount in NANO
-    def self.raw_to_NANO(raw)
+    def raw_to_NANO(raw)
+      return if raw.nil?
+
       (raw.to_f / STEP).to_f
     end
 
-    # Converts an empty String value into an empty version of another type.
+    # @return [TrueClass] if unit is valid.
+    # @raise [Nanook::NanoUnitError] if `unit` is invalid.
+    def validate_unit!(unit)
+      unless Nanook::UNITS.include?(unit.to_sym)
+        raise Nanook::NanoUnitError, "Unit #{unit} must be one of #{Nanook::UNITS}"
+      end
+
+      true
+    end
+
+    # Returns the +id+ of the object as a short id.
+    # See #shorten_id.
     #
-    # The RPC often returns an empty String (<tt>""</tt>) as a value, when a
-    # +nil+, or empty Array (<tt>[]</tt>), or empty Hash (<tt>{}</tt>) would be better.
-    # If the response might be
+    # @return [String]
+    def short_id
+      shorten_id(id)
+    end
+
+    # Returns an id string (hash or nano account) truncated with an ellipsis.
+    # The first 7 and last 4 characters are retained for easy identification.
     #
-    # @param response the value returned from the RPC server
-    # @param type the type to return an empty of
-    def self.coerce_empty_string_to_type(response, type)
-      if response == "" || response.nil?
-        return type.new
-      end
+    # ==== Examples:
+    #
+    #   shorten_id('nano_16u1uufyoig8777y6r8iqjtrw8sg8maqrm36zzcm95jmbd9i9aj5i8abr8u5')
+    #     # => "16u1uuf...r8u5"
+    #
+    #   shorten_id('A170D51B94E00371ACE76E35AC81DC9405D5D04D4CEBC399AEACE07AE05DD293')
+    #     # => "A170D51...D293"
+    #
+    # @return [String]
+    def shorten_id(long_id)
+      return unless long_id
+
+      [long_id.sub('nano_', '')[0..6], long_id[-4, 4]].join('...')
+    end
 
-      response
+    def as_account(account_id)
+      Nanook::Account.new(@rpc, account_id)
     end
 
+    def as_wallet_account(account_id)
+      Nanook::WalletAccount.new(@rpc, @wallet, account_id)
+    end
+
+    def as_block(block_id)
+      Nanook::Block.new(@rpc, block_id)
+    end
+
+    def as_private_key(key)
+      Nanook::PrivateKey.new(@rpc, key)
+    end
+
+    def as_public_key(key)
+      Nanook::PublicKey.new(@rpc, key)
+    end
+
+    def as_time(time)
+      Time.at(time).utc if time
+    end
   end
 end

data/lib/nanook/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Nanook
-  VERSION = "2.2.0"
+  VERSION = '3.0.0'
 end

data/lib/nanook/wallet.rb

@@ -1,7 +1,10 @@
-class Nanook
+# frozen_string_literal: true
+
+require_relative 'util'
 
-  # The <tt>Nanook::Wallet</tt> class lets you manage your nano wallets,
-  # as well as some account-specific things like making and receiving payments.
+class Nanook
+  # The <tt>Nanook::Wallet</tt> class lets you manage your nano wallets.
+  # Your node will need the <tt>enable_control</tt> setting enabled.
   #
   # === Wallet seeds vs ids
   #
@@ -18,7 +21,7 @@ class Nanook
   # person needs to know your wallet id as well as have access to run
   # RPC commands against your nano node to be able to control your accounts.
   #
-  # A _seed_ on the otherhand can be used to link any wallet to another
+  # A _seed_ on the other hand can be used to link any wallet to another
   # wallet's accounts, from anywhere in the nano network. This happens
   # by setting a wallet's seed to be the same as a previous wallet's seed.
   # When a wallet has the same seed as another wallet, any accounts
@@ -33,8 +36,7 @@ class Nanook
   # want to restore the wallet anywhere else on the nano network besides
   # the node you originally created it on. The nano command line interface
   # (CLI) is the only method for discovering a wallet's seed. See the
-  # {https://github.com/nanocurrency/raiblocks/wiki/Command-line-interface
-  # --wallet_decrypt_unsafe CLI command}.
+  # {https://docs.nano.org/commands/command-line-interface/#-wallet_decrypt_unsafe-walletwallet-passwordpassword}.
   #
   # === Initializing
   #
@@ -48,10 +50,32 @@ class Nanook
   #   rpc_conn = Nanook::Rpc.new
   #   wallet = Nanook::Wallet.new(rpc_conn, wallet_id)
   class Wallet
+    include Nanook::Util
 
-    def initialize(rpc, wallet)
+    def initialize(rpc, wallet = nil)
       @rpc = rpc
-      @wallet = wallet
+      @wallet = wallet.to_s if wallet
+    end
+
+    # @return [String] the wallet id
+    def id
+      @wallet
+    end
+
+    # @param other [Nanook::Wallet] wallet to compare
+    # @return [Boolean] true if wallets are equal
+    def ==(other)
+      other.class == self.class &&
+        other.id == id
+    end
+    alias eql? ==
+
+    # The hash value is used along with #eql? by the Hash class to determine if two objects
+    # reference the same hash key.
+    #
+    # @return [Integer]
+    def hash
+      id.hash
     end
 
     # Returns the given account in the wallet as a {Nanook::WalletAccount} instance
@@ -67,17 +91,18 @@ class Nanook
     #
     # ==== Examples:
     #
-    #   wallet.account("xrb_...") # => Nanook::WalletAccount
+    #   wallet.account("nano_...") # => Nanook::WalletAccount
     #   wallet.account.create     # => Nanook::WalletAccount
     #
-    # @param [String] account optional String of an account (starting with
+    # @param account [String] optional String of an account (starting with
     #   <tt>"xrb..."</tt>) to start working with. Must be an account within
     #   the wallet. When no account is given, the instance returned only
     #   allows you to call +create+ on it, to create a new account.
-    # @raise [ArgumentError] if the wallet does no contain the account
+    # @raise [ArgumentError] if the wallet does not contain the account
     # @return [Nanook::WalletAccount]
-    def account(account=nil)
-      Nanook::WalletAccount.new(@rpc, @wallet, account)
+    def account(account = nil)
+      check_wallet_required!
+      as_wallet_account(account)
     end
 
     # Array of {Nanook::WalletAccount} instances of accounts in the wallet.
@@ -91,13 +116,33 @@ class Nanook
     #
     # @return [Array<Nanook::WalletAccount>] all accounts in the wallet
     def accounts
-      wallet_required!
-      response = rpc(:account_list)[:accounts]
-      Nanook::Util.coerce_empty_string_to_type(response, Array).map do |account|
-        Nanook::WalletAccount.new(@rpc, @wallet, account)
+      rpc(:account_list, _access: :accounts, _coerce: Array).map do |account|
+        as_wallet_account(account)
       end
     end
 
+    # Move accounts from another {Nanook::Wallet} on the node to this {Nanook::Wallet}.
+    #
+    # ==== Example:
+    #
+    #   wallet.move_accounts("0023200...", ["nano_3e3j5...", "nano_5f2a1..."]) # => true
+    #
+    # @return [Boolean] true when the move was successful
+    def move_accounts(wallet, accounts)
+      rpc(:account_move, source: wallet, accounts: accounts, _access: :moved) == 1
+    end
+
+    # Remove an {Nanook::Account} from this {Nanook::Wallet}.
+    #
+    # ==== Example:
+    #
+    #   wallet.remove_account("nano_3e3j5...") # => true
+    #
+    # @return [Boolean] true when the remove was successful
+    def remove_account(account)
+      rpc(:account_remove, account: account, _access: :removed) == 1
+    end
+
     # Balance of all accounts in the wallet, optionally breaking the balances down by account.
     #
     # ==== Examples:
@@ -128,58 +173,60 @@ class Nanook
     # Example response:
     #
     #   {
-    #     "xrb_3e3j5tkog48pnny9dmfzj1r16pg8t1e76dz5tmac6iq689wyjfpi00000000"=>{
+    #     "nano_3e3j5tkog48pnny9dmfzj1r16pg8t1e76dz5tmac6iq689wyjfpi00000000"=>{
     #       "balance"=>2.5,
     #       "pending"=>1
     #     },
-    #     "xrb_1e5aqegc1jb7qe964u4adzmcezyo6o146zb8hm6dft8tkp79za3sxwjym5rx"=>{
+    #     "nano_1e5aqegc1jb7qe964u4adzmcezyo6o146zb8hm6dft8tkp79za3sxwjym5rx"=>{
     #       "balance"=>51.4,
     #       "pending"=>0
     #     },
     #   }
     #
-    # @param [Boolean] account_break_down (default is +false+). When +true+
+    # @param account_break_down [Boolean] (default is +false+). When +true+
     #  the response will contain balances per account.
     # @param unit (see Nanook::Account#balance)
     #
     # @return [Hash{Symbol=>Integer|Float|Hash}]
+    # @raise [Nanook::NanoUnitError] if `unit` is invalid
     def balance(account_break_down: false, unit: Nanook.default_unit)
-      wallet_required!
-
-      unless Nanook::UNITS.include?(unit)
-        raise ArgumentError.new("Unsupported unit: #{unit}")
-      end
+      validate_unit!(unit)
 
       if account_break_down
-        return Nanook::Util.coerce_empty_string_to_type(rpc(:wallet_balances)[:balances], Hash).tap do |r|
+        return rpc(:wallet_balances, _access: :balances, _coerce: Hash).tap do |r|
           if unit == :nano
-            r.each do |account, balances|
-              r[account][:balance] = Nanook::Util.raw_to_NANO(r[account][:balance])
-              r[account][:pending] = Nanook::Util.raw_to_NANO(r[account][:pending])
+            r.each do |account, _balances|
+              r[account][:balance] = raw_to_NANO(r[account][:balance])
+              r[account][:pending] = raw_to_NANO(r[account][:pending])
             end
           end
         end
       end
 
-      rpc(:wallet_balance_total).tap do |r|
-        if unit == :nano
-          r[:balance] = Nanook::Util.raw_to_NANO(r[:balance])
-          r[:pending] = Nanook::Util.raw_to_NANO(r[:pending])
-        end
-      end
+      response = rpc(:wallet_info, _coerce: Hash).slice(:balance, :pending)
+      return response unless unit == :nano
+
+      {
+        balance: raw_to_NANO(response[:balance]),
+        pending: raw_to_NANO(response[:pending])
+      }
     end
 
     # Changes a wallet's seed.
     #
+    # It's recommended to only change the seed of a wallet that contains
+    # no accounts. This will clear all deterministic accounts in the wallet.
+    # To restore accounts after changing the seed, see Nanook::WalletAccount#create.
+    #
     # ==== Example:
     #
     #   wallet.change_seed("000D1BA...") # => true
+    #   wallet.account.create(5) # Restores first 5 accounts for wallet with new seed
     #
     # @param seed [String] the seed to change to.
     # @return [Boolean] indicating whether the change was successful.
     def change_seed(seed)
-      wallet_required!
-      rpc(:wallet_change_seed, seed: seed).has_key?(:success)
+      rpc(:wallet_change_seed, seed: seed).key?(:success)
     end
 
     # Creates a new wallet.
@@ -197,7 +244,8 @@ class Nanook
     #
     # @return [Nanook::Wallet]
     def create
-      @wallet = rpc(:wallet_create)[:wallet]
+      skip_wallet_required!
+      @wallet = rpc(:wallet_create, _access: :wallet)
       self
     end
 
@@ -209,49 +257,57 @@ class Nanook
     #
     # @return [Boolean] indicating success of the action
     def destroy
-      wallet_required!
-      rpc(:wallet_destroy)
-      true
+      rpc(:wallet_destroy, _access: :destroyed) == 1
     end
 
     # Generates a String containing a JSON representation of your wallet.
     #
     # ==== Example:
     #
-    #   wallet.export # => "{\n    \"0000000000000000000000000000000000000000000000000000000000000000\": \"0000000000000000000000000000000000000000000000000000000000000003\",\n    \"0000000000000000000000000000000000000000000000000000000000000001\": \"C3A176FC3B90113277BFC91F55128FC9A1F1B6166A73E7446927CFFCA4C2C9D9\",\n    \"0000000000000000000000000000000000000000000000000000000000000002\": \"3E58EC805B99C52B4715598BD332C234A1FBF1780577137E18F53B9B7F85F04B\",\n    \"0000000000000000000000000000000000000000000000000000000000000003\": \"5FF8021122F3DEE0E4EC4241D35A3F41DEF63CCF6ADA66AF235DE857718498CD\",\n    \"0000000000000000000000000000000000000000000000000000000000000004\": \"A30E0A32ED41C8607AA9212843392E853FCBCB4E7CB194E35C94F07F91DE59EF\",\n    \"0000000000000000000000000000000000000000000000000000000000000005\": \"E707002E84143AA5F030A6DB8DD0C0480F2FFA75AB1FFD657EC22B5AA8E395D5\",\n    \"0000000000000000000000000000000000000000000000000000000000000006\": \"0000000000000000000000000000000000000000000000000000000000000001\",\n    \"8646C0423160DEAEAA64034F9C6858F7A5C8A329E73E825A5B16814F6CCAFFE3\": \"0000000000000000000000000000000000000000000000000000000100000000\"\n}\n"
+    #   wallet.export
+    #     # => "{\n    \"0000000000000000000000000000000000000000000000000000000000000000\": \"0000000000000000000000000000000000000000000000000000000000000003\",\n    \"0000000000000000000000000000000000000000000000000000000000000001\": \"C3A176FC3B90113277BFC91F55128FC9A1F1B6166A73E7446927CFFCA4C2C9D9\",\n    \"0000000000000000000000000000000000000000000000000000000000000002\": \"3E58EC805B99C52B4715598BD332C234A1FBF1780577137E18F53B9B7F85F04B\",\n    \"0000000000000000000000000000000000000000000000000000000000000003\": \"5FF8021122F3DEE0E4EC4241D35A3F41DEF63CCF6ADA66AF235DE857718498CD\",\n    \"0000000000000000000000000000000000000000000000000000000000000004\": \"A30E0A32ED41C8607AA9212843392E853FCBCB4E7CB194E35C94F07F91DE59EF\",\n    \"0000000000000000000000000000000000000000000000000000000000000005\": \"E707002E84143AA5F030A6DB8DD0C0480F2FFA75AB1FFD657EC22B5AA8E395D5\",\n    \"0000000000000000000000000000000000000000000000000000000000000006\": \"0000000000000000000000000000000000000000000000000000000000000001\",\n    \"8646C0423160DEAEAA64034F9C6858F7A5C8A329E73E825A5B16814F6CCAFFE3\": \"0000000000000000000000000000000000000000000000000000000100000000\"\n}\n"
+    #
+    # @return [String]
     def export
-      wallet_required!
-      rpc(:wallet_export)[:json]
+      rpc(:wallet_export, _access: :json)
+    end
+
+    # Returns true if wallet exists on the node.
+    #
+    # ==== Example:
+    #
+    #   wallet.exists? # => true
+    #
+    # @return [Boolean] true if wallet exists on the node
+    def exists?
+      export
+      true
+    rescue Nanook::NodeRpcError
+      false
     end
 
     # Will return +true+ if the account exists in the wallet.
     #
     # ==== Example:
-    #   wallet.contains?("xrb_...") # => true
+    #   wallet.contains?("nano_...") # => true
     #
-    # @param account [String] id (will start with <tt>"xrb_..."</tt>)
+    # @param account [String] id (will start with <tt>"nano_..."</tt>)
     # @return [Boolean] indicating if the wallet contains the given account
     def contains?(account)
-      wallet_required!
-      response = rpc(:wallet_contains, account: account)
-      !response.empty? && response[:exists] == 1
-    end
-
-    # @return [String] the wallet id
-    def id
-      @wallet
+      rpc(:wallet_contains, account: account, _access: :exists) == 1
     end
 
     # @return [String]
-    def inspect
-      "#{self.class.name}(id: \"#{id}\", object_id: \"#{"0x00%x" % (object_id << 1)}\")"
+    def to_s
+      "#{self.class.name}(id: \"#{short_id}\")"
     end
+    alias inspect to_s
 
     # Makes a payment from an account in your wallet to another account
     # on the nano network.
     #
     # Note, there may be a delay in receiving a response due to Proof of
-    # Work being done. From the {Nano RPC}[https://github.com/nanocurrency/raiblocks/wiki/RPC-protocol#account-create]:
+    # Work being done. From the {Nano RPC}[https://docs.nano.org/commands/rpc-protocol/#send]:
     #
     # <i>Proof of Work is precomputed for one transaction in the
     # background. If it has been a while since your last transaction it
@@ -260,8 +316,9 @@ class Nanook
     #
     # ==== Examples:
     #
-    #   wallet.pay(from: "xrb_...", to: "xrb_...", amount: 1.1, id: "myUniqueId123") # => "9AE2311..."
-    #   wallet.pay(from: "xrb_...", to: "xrb_...", amount: 54000000000000, unit: :raw, id: "myUniqueId123") # => "9AE2311..."
+    #   wallet.pay(from: "nano_...", to: "nano_...", amount: 1.1, id: "myUniqueId123") # => "9AE2311..."
+    #   wallet.pay(from: "nano_...", to: "nano_...", amount: 54000000000000, unit: :raw, id: "myUniqueId123")
+    #     # => "9AE2311..."
     #
     # @param from [String] account id of an account in your wallet
     # @param to (see Nanook::WalletAccount#pay)
@@ -270,8 +327,7 @@ class Nanook
     # @params id (see Nanook::WalletAccount#pay)
     # @return (see Nanook::WalletAccount#pay)
     # @raise [Nanook::Error] if unsuccessful
-    def pay(from:, to:, amount:, unit: Nanook.default_unit, id:)
-      wallet_required!
+    def pay(from:, to:, amount:, id:, unit: Nanook.default_unit)
       validate_wallet_contains_account!(from)
       account(from).pay(to: to, amount: amount, unit: unit, id: id)
     end
@@ -292,12 +348,12 @@ class Nanook
     # Example response:
     #
     #   {
-    #     :xrb_1111111111111111111111111111111111111111111111111117353trpda=>[
-    #       "142A538F36833D1CC78B94E11C766F75818F8B940771335C6C1B8AB880C5BB1D",
-    #       "718CC2121C3E641059BC1C2CFC45666C99E8AE922F7A807B7D07B62C995D79E2"
+    #     Nanook::Account=>[
+    #       Nanook::Block,
+    #       Nanook::Block"
     #     ],
-    #     :xrb_3t6k35gi95xu6tergt6p69ck76ogmitsa8mnijtpxm9fkcm736xtoncuohr3=>[
-    #       "4C1FEEF0BEA7F50BE35489A1233FE002B212DEA554B55B1B470D78BD8F210C74"
+    #     Nanook::Account=>[
+    #       Nanook::Block
     #     ]
     #   }
     #
@@ -308,57 +364,69 @@ class Nanook
     # Example response:
     #
     #   {
-    #     :xrb_1111111111111111111111111111111111111111111111111117353trpda=>[
+    #     Nanook::Account=>[
     #       {
     #         :amount=>6.0,
-    #         :source=>"xrb_3dcfozsmekr1tr9skf1oa5wbgmxt81qepfdnt7zicq5x3hk65fg4fqj58mbr",
-    #         :block=>:"142A538F36833D1CC78B94E11C766F75818F8B940771335C6C1B8AB880C5BB1D"
+    #         :source=>Nanook::Account,
+    #         :block=>Nanook::Block
     #       },
     #       {
     #         :amount=>12.0,
-    #         :source=>"xrb_3dcfozsmekr1tr9skf1oa5wbgmxt81qepfdnt7zicq5x3hk65fg4fqj58mbr",
-    #         :block=>:"242A538F36833D1CC78B94E11C766F75818F8B940771335C6C1B8AB880C5BB1D"
+    #         :source=>Nanook::Account,
+    #         :block=>Nanook::Block
     #       }
     #     ],
-    #     :xrb_3t6k35gi95xu6tergt6p69ck76ogmitsa8mnijtpxm9fkcm736xtoncuohr3=>[
+    #     Nanook::Account=>[
     #       {
     #         :amount=>106.370018,
-    #         :source=>"xrb_13ezf4od79h1tgj9aiu4djzcmmguendtjfuhwfukhuucboua8cpoihmh8byo",
-    #         :block=>:"4C1FEEF0BEA7F50BE35489A1233FE002B212DEA554B55B1B470D78BD8F210C74"
+    #         :source=>Nanook::Account,
+    #         :block=>Nanook::Block
     #       }
     #     ]
     #   }
-    def pending(limit:1000, detailed:false, unit:Nanook.default_unit)
-      wallet_required!
+    #
+    # @raise [Nanook::NanoUnitError] if `unit` is invalid
+    def pending(limit: 1000, detailed: false, unit: Nanook.default_unit)
+      validate_unit!(unit)
 
-      unless Nanook::UNITS.include?(unit)
-        raise ArgumentError.new("Unsupported unit: #{unit}")
-      end
+      params = {
+        count: limit,
+        _access: :blocks,
+        _coerce: Hash
+      }
 
-      params = { count: limit }
       params[:source] = true if detailed
 
-      response = rpc(:wallet_pending, params)[:blocks]
-      response = Nanook::Util.coerce_empty_string_to_type(response, Hash)
+      response = rpc(:wallet_pending, params)
 
-      return response unless detailed
+      unless detailed
+
+        x = response.map do |account, block_ids|
+          blocks = block_ids.map { |block_id| as_block(block_id) }
+          [as_account(account), blocks]
+        end
+
+        return Hash[x]
+      end
 
       # Map the RPC response, which is:
       # account=>block=>[amount|source] into
       # account=>[block|amount|source]
       x = response.map do |account, data|
         new_data = data.map do |block, amount_and_source|
-          d = amount_and_source.merge(block: block.to_s)
-          if unit == :nano
-            d[:amount] = Nanook::Util.raw_to_NANO(d[:amount])
-          end
+          d = {
+            block: as_block(block),
+            source: as_account(amount_and_source[:source]),
+            amount: amount_and_source[:amount]
+          }
+          d[:amount] = raw_to_NANO(d[:amount]) if unit == :nano
           d
         end
 
-        [account, new_data]
+        [as_account(account), new_data]
       end
 
-      Hash[x].to_symbolized_hash
+      Hash[x]
     end
 
     # Receives a pending payment into an account in the wallet.
@@ -366,7 +434,7 @@ class Nanook
     # When called with no +block+ argument, the latest pending payment
     # for the account will be received.
     #
-    # Returns a <i>receive</i> block hash id if a receive was successful,
+    # Returns a <i>receive</i> block if a receive was successful,
     # or +false+ if there were no pending payments to receive.
     #
     # You can receive a specific pending block if you know it by
@@ -374,19 +442,76 @@ class Nanook
     #
     # ==== Examples:
     #
-    #   wallet.receive(into: "xrb...")               # => "9AE2311..."
-    #   wallet.receive("718CC21...", into: "xrb...") # => "9AE2311..."
+    #   wallet.receive(into: "xrb...")               # => Nanook::Block
+    #   wallet.receive("718CC21...", into: "xrb...") # => Nanook::Block
     #
     # @param block (see Nanook::WalletAccount#receive)
     # @param into [String] account id of account in your wallet to receive the
     #   payment into
     # @return (see Nanook::WalletAccount#receive)
-    def receive(block=nil, into:)
-      wallet_required!
+    def receive(block = nil, into:)
       validate_wallet_contains_account!(into)
       account(into).receive(block)
     end
 
+    # Rebroadcast blocks for accounts from wallet starting at frontier down to count to the network.
+    #
+    # ==== Examples:
+    #
+    #   wallet.republish_blocks             # => [Nanook::Block, ...]
+    #   wallet.republish_blocks(limit: 10)  # => [Nanook::Block, ...
+    #
+    # @param limit [Integer] limit of blocks to publish. Default is 1000.
+    # @return [Array<Nanook::Block>] republished blocks
+    def republish_blocks(limit: 1000)
+      rpc(:wallet_republish, count: limit, _access: :blocks, _coerce: Array).map do |block|
+        as_block(block)
+      end
+    end
+
+    # The default representative account id for the wallet. This is the
+    # representative that all new accounts created in this wallet will have.
+    #
+    # Changing the default representative for a wallet does not change
+    # the representatives for any accounts that have been created.
+    #
+    # ==== Example:
+    #
+    #   wallet.default_representative # => "nano_3pc..."
+    #
+    # @return [Nanook::Account] Representative account. Can be nil.
+    def default_representative
+      representative = rpc(:wallet_representative, _access: :representative)
+      as_account(representative) if representative
+    end
+    alias representative default_representative
+
+    # Sets the default representative for the wallet. A wallet's default
+    # representative is the representative all new accounts created in
+    # the wallet will have. Changing the default representative for a
+    # wallet does not change the representatives for existing accounts
+    # in the wallet.
+    #
+    # ==== Example:
+    #
+    #   wallet.change_default_representative("nano_...") # => "nano_..."
+    #
+    # @param representative [String] id of the representative account
+    #   to set as this account's representative
+    # @return [Nanook::Account] the representative account
+    # @raise [Nanook::Error] if setting the representative fails
+    def change_default_representative(representative)
+      unless as_account(representative).exists?
+        raise Nanook::Error, "Representative account does not exist: #{representative}"
+      end
+
+      raise Nanook::Error, 'Setting the representative failed' \
+        unless rpc(:wallet_representative_set, representative: representative, _access: :set) == 1
+
+      as_account(representative)
+    end
+    alias change_representative change_default_representative
+
     # Restores a previously created wallet by its seed.
     # A new wallet will be created on your node (with a new wallet id)
     # and will have its seed set to the given seed.
@@ -400,18 +525,149 @@ class Nanook
     #
     # @return [Nanook::Wallet] a new wallet
     # @raise [Nanook::Error] if unsuccessful
-    def restore(seed, accounts:0)
+    def restore(seed, accounts: 0)
+      skip_wallet_required!
+
       create
 
-      unless change_seed(seed)
-        raise Nanook::Error.new("Unable to set seed for wallet")
+      raise Nanook::Error, 'Unable to set seed for wallet' unless change_seed(seed)
+
+      account.create(accounts) if accounts.positive?
+
+      self
+    end
+
+    # Information ledger information about this wallet's accounts.
+    #
+    # This call may return results that include unconfirmed blocks, so it should not be
+    # used in any processes or integrations requiring only details from blocks confirmed
+    # by the network.
+    #
+    # ==== Examples:
+    #
+    #   wallet.ledger
+    #
+    # Example response:
+    #
+    #    {
+    #      Nanook::Account => {
+    #        frontier: "E71AF3E9DD86BBD8B4620EFA63E065B34D358CFC091ACB4E103B965F95783321",
+    #        open_block: "643B77F1ECEFBDBE1CC909872964C1DBBE23A6149BD3CEF2B50B76044659B60F",
+    #        representative_block: "643B77F1ECEFBDBE1CC909872964C1DBBE23A6149BD3CEF2B50B76044659B60F",
+    #        balance: 1.45,
+    #        modified_timestamp: 1511476234,
+    #        block_count: 2
+    #      },
+    #      Nanook::Account => { ... }
+    #    }
+    #
+    # @param unit (see Nanook::Account#balance)
+    # @return [Hash{Nanook::Account=>Hash{Symbol=>Nanook::Block|Integer|Float|Time}}] ledger.
+    # @raise [Nanook::NanoUnitError] if `unit` is invalid
+    def ledger(unit: Nanook.default_unit)
+      validate_unit!(unit)
+
+      response = rpc(:wallet_ledger, _access: :accounts, _coerce: Hash)
+
+      accounts = response.map do |account_id, data|
+        data[:frontier] = as_block(data[:frontier]) if data[:frontier]
+        data[:open_block] = as_block(data[:open_block]) if data[:open_block]
+        data[:representative_block] = as_block(data[:representative_block]) if data[:representative_block]
+        data[:balance] = raw_to_NANO(data[:balance]) if unit == :nano && data[:balance]
+        data[:last_modified_at] = as_time(data.delete(:modified_timestamp))
+
+        [as_account(account_id), data]
       end
 
-      if accounts > 0
-        account.create(accounts)
+      Hash[accounts]
+    end
+
+    # Information about this wallet.
+    #
+    # This call may return results that include unconfirmed blocks, so it should not be
+    # used in any processes or integrations requiring only details from blocks confirmed
+    # by the network.
+    #
+    # ==== Examples:
+    #
+    #   wallet.info
+    #
+    # Example response:
+    #
+    #   {
+    #     balance: 1.0,
+    #     pending: 2.3
+    #     accounts_count: 3,
+    #     adhoc_count: 1,
+    #     deterministic_count: 2,
+    #     deterministic_index: 2
+    # }
+    #
+    # @param unit (see Nanook::Account#balance)
+    # @return [Hash{Symbol=>Integer|Float}] information about the wallet.
+    # @raise [Nanook::NanoUnitError] if `unit` is invalid
+    def info(unit: Nanook.default_unit)
+      validate_unit!(unit)
+
+      response = rpc(:wallet_info, _coerce: Hash)
+
+      if unit == :nano
+        response[:balance] = raw_to_NANO(response[:balance])
+        response[:pending] = raw_to_NANO(response[:pending])
       end
 
-      self
+      response
+    end
+
+    # Reports send/receive information for accounts in wallet. Change blocks are skipped,
+    # open blocks will appear as receive. Response will start with most recent blocks
+    # according to local ledger.
+    #
+    # ==== Example:
+    #
+    #   wallet.history
+    #
+    # Example response:
+    #
+    #   [
+    #     {
+    #       "type": "send",
+    #       "account": Nanook::Account,
+    #       "amount": 3.2,
+    #       "block_account": Nanook::Account,
+    #       "hash": Nanook::Block,
+    #       "local_timestamp": Time
+    #     },
+    #     {
+    #       ...
+    #     }
+    #   ]
+    #
+    # @param unit (see #balance)
+    # @return [Array<Hash{Symbol=>String|Nanook::Account|Nanook::WalletAccount|Nanook::Block|Integer|Float|Time}>]
+    # @raise [Nanook::NanoUnitError] if `unit` is invalid
+    def history(unit: Nanook.default_unit)
+      validate_unit!(unit)
+
+      rpc(:wallet_history, _access: :history, _coerce: Array).map do |h|
+        h[:account] = account(h[:account])
+        h[:block_account] = as_account(h[:block_account])
+        h[:amount] = raw_to_NANO(h[:amount]) if unit == :nano
+        h[:block] = as_block(h.delete(:hash))
+        h[:local_timestamp] = as_time(h[:local_timestamp])
+        h
+      end
+    end
+
+    # Locks the wallet. A locked wallet cannot pocket pending transactions or make payments. See {#unlock}.
+    #
+    # ==== Example:
+    #
+    #   wallet.lock #=> true
+    #
+    # @return [Boolean] indicates if the wallet was successfully locked
+    def lock
+      rpc(:wallet_lock, _access: :locked) == 1
     end
 
     # Returns +true+ if the wallet is locked.
@@ -422,9 +678,7 @@ class Nanook
     #
     # @return [Boolean] indicates if the wallet is locked
     def locked?
-      wallet_required!
-      response = rpc(:wallet_locked)
-      !response.empty? && response[:locked] != 0
+      rpc(:wallet_locked, _access: :locked) == 1
     end
 
     # Unlocks a previously locked wallet.
@@ -434,9 +688,8 @@ class Nanook
     #   wallet.unlock("new_pass") #=> true
     #
     # @return [Boolean] indicates if the unlocking action was successful
-    def unlock(password)
-      wallet_required!
-      rpc(:password_enter, password: password)[:valid] == 1
+    def unlock(password = nil)
+      rpc(:password_enter, password: password, _access: :valid) == 1
     end
 
     # Changes the password for a wallet.
@@ -446,33 +699,73 @@ class Nanook
     #   wallet.change_password("new_pass") #=> true
     # @return [Boolean] indicates if the action was successful
     def change_password(password)
-      wallet_required!
-      rpc(:password_change, password: password)[:changed] == 1
+      rpc(:password_change, password: password, _access: :changed) == 1
+    end
+
+    # Tells the node to look for pending blocks for any account in the wallet.
+    #
+    # ==== Example:
+    #
+    #   wallet.search_pending #=> true
+    # @return [Boolean] indicates if the action was successful
+    def search_pending
+      rpc(:search_pending, _access: :started) == 1
+    end
+
+    # Returns a list of pairs of {Nanook::WalletAccount} and work for wallet.
+    #
+    # ==== Example:
+    #
+    #   wallet.work
+    #
+    # ==== Example response:
+    #
+    #   {
+    #     Nanook::WalletAccount: "432e5cf728c90f4f",
+    #     Nanook::WalletAccount: "4efec5f63fc902cf"
+    #   }
+    # @return [Boolean] indicates if the action was successful
+    def work
+      hash = rpc(:wallet_work_get, _access: :works, _coerce: Hash).map do |account_id, work|
+        [as_wallet_account(account_id), work]
+      end
+
+      Hash[hash]
     end
 
     private
 
-    def rpc(action, params={})
-      p = @wallet.nil? ? {} : { wallet: @wallet }
-      @rpc.call(action, p.merge(params))
+    def rpc(action, params = {})
+      check_wallet_required!
+
+      p = { wallet: @wallet }.compact
+      @rpc.call(action, p.merge(params)).tap { reset_skip_wallet_required! }
     end
 
-    def wallet_required!
-      if @wallet.nil?
-        raise ArgumentError.new("Wallet must be present")
-      end
+    def skip_wallet_required!
+      @skip_wallet_required_check = true
+    end
+
+    def reset_skip_wallet_required!
+      @skip_wallet_required_check = false
+    end
+
+    def check_wallet_required!
+      return if @wallet || @skip_wallet_required_check
+
+      raise ArgumentError, 'Wallet must be present'
     end
 
     def validate_wallet_contains_account!(account)
       @known_valid_accounts ||= []
       return if @known_valid_accounts.include?(account)
 
-      if contains?(account)
-        @known_valid_accounts << account
-      else
-        raise ArgumentError.new("Account does not exist in wallet. Account: #{account}, wallet: #{@wallet}")
+      unless contains?(account)
+        raise ArgumentError,
+              "Account does not exist in wallet. Account: #{account}, wallet: #{@wallet}"
       end
-    end
 
+      @known_valid_accounts << account
+    end
   end
 end