nanook 2.5.0 → 4.0.0

data/bin/console

@@ -1,10 +1,11 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
-require "bundler/setup"
-require "nanook"
+require 'bundler/setup'
+require 'nanook'
 
 # You can add fixtures and/or initialization code here to make experimenting
 # with your gem easier. You can also use a different console, if you like.
 
-require "pry"
+require 'pry'
 Pry.start

data/lib/nanook.rb

@@ -1,12 +1,16 @@
+# frozen_string_literal: true
+
 require 'net/http'
 require 'uri'
 require 'forwardable'
 
-Dir[File.dirname(__FILE__) + '/nanook/*.rb'].each { |file| require file }
+Dir["#{File.dirname(__FILE__)}/nanook/*.rb"].sort.each { |file| require file }
+
+require_relative 'nanook/util'
 
 # ==== Initializing
 #
-# Connect to the default RPC host at http://localhost:7076 and with a timeout of 500 seconds:
+# Connect to the default RPC host at http://[::1]:7076 and with a timeout of 60 seconds:
 #
 #    nanook = Nanook.new
 #
@@ -19,8 +23,9 @@ Dir[File.dirname(__FILE__) + '/nanook/*.rb'].each { |file| require file }
 #   Nanook.new(timeout: 600)
 #   Nanook.new("http://ip6-localhost.com:7076", timeout: 600)
 class Nanook
+  include Util
 
-  UNITS = [:raw, :nano]
+  UNITS = %i[raw nano].freeze
   DEFAULT_UNIT = :nano
 
   # @return [Nanook::Rpc]
@@ -32,26 +37,27 @@ class Nanook
   def self.default_unit
     return DEFAULT_UNIT unless defined?(UNIT)
 
-    unless UNITS.include?(UNIT.to_sym)
-      raise Nanook::Error.new("UNIT #{UNIT} must be one of #{UNITS}")
-    end
-
     UNIT.to_sym
   end
 
   # Returns a new instance of {Nanook}.
   #
   # ==== Examples:
-  # Connecting to http://localhost:7076 with the default timeout of 10s:
+  # Connecting to http://[::1]:7076 with the default timeout of 60s:
+  #
   #   Nanook.new
+  #
   # Setting a custom timeout:
+  #
   #   Nanook.new(timeout: 10)
+  #
   # Connecting to a custom RPC host and setting a timeout:
-  #   Nanook.new("http://ip6-localhost.com:7076", timeout: 10)
+  #
+  #   Nanook.new("http://ip6-localhost:7076", timeout: 10)
   #
   # @param uri [String] default is {Nanook::Rpc::DEFAULT_URI}. The RPC host to connect to
   # @param timeout [Integer] default is {Nanook::Rpc::DEFAULT_TIMEOUT}. Connection timeout in number of seconds
-  def initialize(uri=Nanook::Rpc::DEFAULT_URI, timeout:Nanook::Rpc::DEFAULT_TIMEOUT)
+  def initialize(uri = Nanook::Rpc::DEFAULT_URI, timeout: Nanook::Rpc::DEFAULT_TIMEOUT)
     @rpc = Nanook::Rpc.new(uri, timeout: timeout)
   end
 
@@ -63,7 +69,7 @@ class Nanook
   # @param account [String] the id of the account you want to work with
   # @return [Nanook::Account]
   def account(account)
-    Nanook::Account.new(@rpc, account)
+    as_account(account)
   end
 
   # Returns a new instance of {Nanook::Block}.
@@ -74,23 +80,35 @@ class Nanook
   # @param block [String] the id/hash of the block you want to work with
   # @return [Nanook::Block]
   def block(block)
-    Nanook::Block.new(@rpc, block)
+    as_block(block)
   end
 
   # @return [String]
-  def inspect
-    "#{self.class.name}(rpc: #{@rpc.inspect}, object_id: \"#{"0x00%x" % (object_id << 1)}\")"
+  def to_s
+    "#{self.class.name}(rpc: #{@rpc})"
   end
+  alias inspect to_s
 
-  # Returns a new instance of {Nanook::Key}.
+  # Returns a new instance of {Nanook::PrivateKey}.
   #
   # ==== Example:
-  #   key = Nanook.new.key("3068BB1CA04525BB0E416C485FE6A67FD52540227D267CC8B6E8DA958A7FA039")
+  #   key = Nanook.new.private_key("3068BB1CA04525BB0E416C485FE6A67FD52540227D267CC8B6E8DA958A7FA039")
   #
   # @param key [String] a private key
-  # @return [Nanook::Key]
-  def key(key=nil)
-    Nanook::Key.new(@rpc, key)
+  # @return [Nanook::PrivateKey]
+  def private_key(key = nil)
+    as_private_key(key, allow_blank: true)
+  end
+
+  # Returns a new instance of {Nanook::PublicKey}.
+  #
+  # ==== Example:
+  #   key = Nanook.new.public_key("3068BB1CA04525BB0E416C485FE6A67FD52540227D267CC8B6E8DA958A7FA039")
+  #
+  # @param key [String] a public key
+  # @return [Nanook::PublicKey]
+  def public_key(key)
+    as_public_key(key)
   end
 
   # Returns a new instance of {Nanook::Node}.
@@ -110,7 +128,7 @@ class Nanook
   #
   # @param wallet [String] the id of the wallet you want to work with
   # @return [Nanook::Wallet]
-  def wallet(wallet=nil)
+  def wallet(wallet = nil)
     Nanook::Wallet.new(@rpc, wallet)
   end
 
@@ -124,4 +142,42 @@ class Nanook
     Nanook::WorkPeer.new(@rpc)
   end
 
+  # Return summarized metrics received from other nodes of the whole network.
+  #
+  # ==== Example:
+  #   Nanook.new.network_telemetry
+  #
+  # ==== Example response:
+  #   {
+  #     block_count: 5777903,
+  #     cemented_count: 688819,
+  #     unchecked_count: 443468,
+  #     account_count: 620750,
+  #     bandwidth_cap: 1572864,
+  #     peer_count: 32,
+  #     protocol_version: 18,
+  #     uptime: 556896,
+  #     genesis_block: Nanook::Block,
+  #     major_version: 21,
+  #     minor_version: 0,
+  #     patch_version: 0,
+  #     pre_release_version: 0,
+  #     maker: 0,
+  #     timestamp: Time,
+  #     active_difficulty: "ffffffcdbf40aa45"
+  # }
+  #
+  # @return [Nanook::WorkPeer]
+  def network_telemetry
+    response = call_rpc(:telemetry, _coerce: Hash)
+    response[:genesis_block] = as_block(response[:genesis_block])
+    response[:timestamp] = as_time(response[:timestamp])
+    response
+  end
+
+  private
+
+  def call_rpc(action, params = {})
+    @rpc.call(action, params)
+  end
 end

data/lib/nanook/account.rb

@@ -1,5 +1,8 @@
-class Nanook
+# frozen_string_literal: true
+
+require_relative 'util'
 
+class Nanook
   # The <tt>Nanook::Account</tt> class contains methods to discover
   # publicly-available information about accounts on the nano network.
   #
@@ -15,10 +18,38 @@ class Nanook
   #   rpc_conn = Nanook::Rpc.new
   #   account = Nanook::Account.new(rpc_conn, "nano_...")
   class Account
+    include Nanook::Util
 
     def initialize(rpc, account)
       @rpc = rpc
-      @account = account
+      @account = account.to_s
+    end
+
+    # The id of the account.
+    #
+    # ==== Example:
+    #
+    #   account.id # => "nano_16u..."
+    #
+    # @return [String] the id of the account
+    def id
+      @account
+    end
+
+    # @param other [Nanook::Account] account to compare
+    # @return [Boolean] true if accounts 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
 
     # Information about this accounts that have set this account as their representative.
@@ -30,28 +61,36 @@ class Nanook
     # Example response:
     #
     #   {
-    #     :nano_13bqhi1cdqq8yb9szneoc38qk899d58i5rcrgdk5mkdm86hekpoez3zxw5sd=>500000000000000000000000000000000000,
-    #     :nano_17k6ug685154an8gri9whhe5kb5z1mf5w6y39gokc1657sh95fegm8ht1zpn=>961647970820730000000000000000000000
+    #     Nanook::Account=>50.0,
+    #     Nanook::Account=>961.64
     #   }
     #
     # @param unit (see #balance)
-    # @return [Hash{Symbol=>Integer}] account ids which delegate to this account, and their account balance
+    # @return [Hash{Nanook::Account=>Integer|Float}] {Nanook::Account} accounts which delegate to this account, and their account balance
+    # @raise [Nanook::NanoUnitError] if `unit` is invalid
     def delegators(unit: Nanook.default_unit)
-      unless Nanook::UNITS.include?(unit)
-        raise ArgumentError.new("Unsupported unit: #{unit}")
-      end
+      validate_unit!(unit)
 
-      response = rpc(:delegators)[:delegators]
-
-      return response if unit == :raw
+      response = rpc(:delegators, _access: :delegators, _coerce: Hash)
 
       r = response.map do |account_id, balance|
-        balance = Nanook::Util.raw_to_NANO(balance)
+        balance = raw_to_NANO(balance) if unit == :nano
 
-        [account_id, balance]
+        [as_account(account_id), balance]
       end
 
-      Hash[r].to_symbolized_hash
+      Hash[r]
+    end
+
+    # Number of accounts that have set this account as their representative.
+    #
+    # === Example:
+    #
+    #   account.delegators_count # => 2
+    #
+    # @return [Integer]
+    def delegators_count
+      rpc(:delegators_count, _access: :count)
     end
 
     # Returns true if the account has an <i>open</i> block.
@@ -73,13 +112,21 @@ class Nanook
     #
     # @return [Boolean] Indicates if this account has an open block
     def exists?
-      response = rpc(:account_info)
+      begin
+        response = rpc(:account_info)
+      rescue Nanook::Error
+        return false
+      end
+
       !response.empty? && !response[:open_block].nil?
     end
-    alias_method :open?, :exists?
+    alias open? exists?
 
     # An account's history of send and receive payments.
     #
+    # 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.
+    #
     # ==== Example:
     #
     #   account.history
@@ -89,73 +136,90 @@ class Nanook
     #   [
     #     {
     #      type: "send",
-    #      account: "nano_1kdc5u48j3hr5r7eof9iao47szqh81ndqgq5e5hrsn1g9a3sa4hkkcotn3uq",
+    #      account: Nanook::Account,
     #      amount: 2,
-    #      hash: "2C3C570EA8898443C0FD04A1C385A3E3A8C985AD792635FCDCEBB30ADF6A0570"
+    #      block: Nanook::Block
     #     }
     #   ]
     #
-    # @param limit [Integer] maximum number of history items to return
+    # @param limit [Integer] maximum number of history items to return. Defaults to 1000
+    # @param sort [Symbol] default +:asc+. When set to +:desc+ the history will be returned oldest to newest.
     # @param unit (see #balance)
-    # @return [Array<Hash{Symbol=>String}>] the history of send and receive payments for this account
-    def history(limit: 1000, unit: Nanook.default_unit)
-      unless Nanook::UNITS.include?(unit)
-        raise ArgumentError.new("Unsupported unit: #{unit}")
-      end
+    # @return [Array<Hash{Symbol=>String|Float|Integer|Nanook::Account|NanookBlock}>] the history of send and receive payments for this account
+    # @raise [Nanook::NanoUnitError] if `unit` is invalid
+    def history(limit: 1000, unit: Nanook.default_unit, sort: :asc)
+      validate_unit!(unit)
 
-      response = rpc(:account_history, count: limit)[:history]
+      response = rpc(:account_history, count: limit, reverse: (sort == :desc), _access: :history, _coerce: Array)
 
-      if unit == :raw
-        return response
-      end
+      response.map do |history|
+        history[:amount] = raw_to_NANO(history[:amount]) if unit == :nano
+        history[:account] = as_account(history[:account])
+        history[:block] = as_block(history.delete(:hash)) # Rename the key from `hash` to `block`
 
-      response.map! do |history|
-        history[:amount] = Nanook::Util.raw_to_NANO(history[:amount])
         history
       end
     end
 
-    # The last modified time of the account in the time zone of
-    # your nano node (usually UTC).
+    # Return blocks for the account.
+    #
+    # @param limit [Integer] maximum number of history items to return. Defaults to 1000
+    # @param sort [Symbol] default +:asc+. When set to +:desc+ the blocks will be returned oldest to newest.
+    # @return [Array<Nanook::Block>]
+    def blocks(limit: 1000, sort: :asc)
+      history(limit: limit, sort: sort).map { |i| i[:block] }
+    end
+
+    # Returns the open block for the account if it exists on the node.
+    #
+    # @return [Nanook::Block]
+    def open_block
+      blocks(limit: 1, sort: :desc).first
+    end
+
+    # The last modified time of the account in UTC. For many accounts on the node
+    # this will be the timestamp of when the node bootstrapped.
     #
     # ==== Example:
     #
     #   account.last_modified_at # => Time
     #
-    # @return [Time] last modified time of the account in the time zone of
-    #   your nano node (usually UTC).
+    # @return [Time] last modified time of the account in UTC. Can be nil
     def last_modified_at
-      response = rpc(:account_info)
-      Time.at(response[:modified_timestamp])
+      as_time(rpc(:account_info, _access: :modified_timestamp))
     end
 
     # The public key of the account.
     #
     # ==== Example:
     #
-    #   account.public_key # => "3068BB1..."
+    #   account.public_key # => Nanook::PublicKey
     #
-    # @return [String] public key of the account
+    # @return [Nanook::PublicKey] public key of the account
     def public_key
-      rpc(:account_key)[:key]
+      as_public_key(rpc(:account_key, _access: :key))
     end
 
-    # The representative account id for the account.
-    # Representatives are accounts that cast votes in the case of a
-    # fork in the network.
+    # The representative for the account.
     #
     # ==== Example:
     #
-    #   account.representative # => "nano_3pc..."
+    #   account.representative # => Nanook::Account
     #
-    # @return [String] Representative account of the account
+    # @return [Nanook::Account] Representative of the account. Can be nil.
     def representative
-      rpc(:account_representative)[:representative]
+      representative = rpc(:account_representative, _access: :representative)
+      as_account(representative)
     end
 
     # The account's balance, including pending (unreceived payments).
     # To receive a pending amount see {WalletAccount#receive}.
     #
+    # This call returns information that may be based on unconfirmed blocks.
+    # These details should not be relied on for any process or integration that
+    # requires confirmed blocks. The pending balance is calculated from
+    # potentially unconfirmed blocks.
+    #
     # ==== Examples:
     #
     #   account.balance
@@ -177,43 +241,36 @@ class Nanook
     #     balance: 2000000000000000000000000000000,
     #     pending: 1100000000000000000000000000000
     #   }
-    #
+    # @param allow_unconfirmed [Boolean] +false+ by default. When +false+, +balance+
+    #   will only include blocks on this account that have already been confirmed
+    #   and +pending+ will only include incoming send blocks that have already been
+    #   confirmed on the sending account.
     # @param unit [Symbol] default is {Nanook.default_unit}.
     #   Must be one of {Nanook::UNITS}.
     #   Represents the unit that the balances will be returned in.
     #   Note: this method interprets
     #   +:nano+ as NANO, which is technically Mnano.
-    #   See {https://nano.org/en/faq#what-are-nano-units- What are Nano's Units}
-    #
-    # @raise ArgumentError if an invalid +unit+ was given.
+    #   See {https://docs.nano.org/protocol-design/distribution-and-units/#unit-dividers What are Nano's Units}
+    # @raise [Nanook::NanoUnitError] if `unit` is invalid
     # @return [Hash{Symbol=>Integer|Float}]
-    def balance(unit: Nanook.default_unit)
-      unless Nanook::UNITS.include?(unit)
-        raise ArgumentError.new("Unsupported unit: #{unit}")
-      end
+    def balance(allow_unconfirmed: false, unit: Nanook.default_unit)
+      validate_unit!(unit)
+
+      params = {
+        include_only_confirmed: !allow_unconfirmed
+      }
 
-      rpc(:account_balance).tap do |r|
+      rpc(:account_balance, params).tap do |r|
         if unit == :nano
-          r[:balance] = Nanook::Util.raw_to_NANO(r[:balance])
-          r[:pending] = Nanook::Util.raw_to_NANO(r[:pending])
+          r[:balance] = raw_to_NANO(r[:balance])
+          r[:pending] = raw_to_NANO(r[:pending])
         end
       end
     end
 
     # @return [Integer] number of blocks for this account
     def block_count
-      rpc(:account_block_count)[:block_count]
-    end
-
-    # The id of the account.
-    #
-    # ==== Example:
-    #
-    #   account.id # => "nano_16u..."
-    #
-    # @return [String] the id of the account
-    def id
-      @account
+      rpc(:account_block_count, _access: :block_count)
     end
 
     # Information about the account.
@@ -244,66 +301,80 @@ class Nanook
     #     id: "nano_16u1uufyoig8777y6r8iqjtrw8sg8maqrm36zzcm95jmbd9i9aj5i8abr8u5",
     #     balance: 11.439597000000001,
     #     block_count: 4,
-    #     frontier: "2C3C570EA8898443C0FD04A1C385A3E3A8C985AD792635FCDCEBB30ADF6A0570",
-    #     modified_timestamp: 1520500357,
-    #     open_block: "C82376314C387080A753871A32AD70F4168080C317C5E67356F0A62EB5F34FF9",
-    #     pending: 0,
-    #     public_key: "A82C906460046D230D7D37C6663723DC3EFCECC4B3254EBF45294B66746F4FEF",
-    #     representative: "nano_3pczxuorp48td8645bs3m6c3xotxd3idskrenmi65rbrga5zmkemzhwkaznh",
-    #     representative_block: "C82376314C387080A753871A32AD70F4168080C317C5E67356F0A62EB5F34FF9",
-    #     weight: 0
+    #     frontier: Nanook::Block,
+    #     last_modified_at: Time,
+    #     open_block: Nanook::Block,
+    #     pending: 1.0,
+    #     representative: Nanook::Account,
+    #     representative_block: Nanook::Block,
+    #     weight: 0.1
     #   }
     #
-    # @param detailed [Boolean] (default is false). When +true+, four
-    #   additional calls are made to the RPC to return more information
     # @param unit (see #balance)
-    # @return [Hash{Symbol=>String|Integer|Float}] information about the account containing:
+    # @param allow_unconfirmed [Boolean] +false+ by default. When +false+ only confirmed +balance+
+    #   +pending+, and +representative+ values are returned.
+    # @return [Hash{Symbol=>String|Integer|Float|Nanook::Account|Nanook::Block|Time}] information about the account containing:
     #   [+id+] The account id
-    #   [+frontier+] The latest block hash
-    #   [+open_block+] The first block in every account's blockchain. When this block was published the account was officially open
-    #   [+representative_block+] The block that named the representative for the account
-    #   [+balance+] Amount in either NANO or raw (depending on the <tt>unit:</tt> argument)
-    #   [+last_modified+] Unix timestamp
+    #   [+frontier+] The latest {Nanook::Block}
+    #   [+confirmation_height+] Confirmation height
+    #   [+confirmation_height_frontier+] The {Nanook::Block} of the confirmation height
+    #   [+pending+] Pending balance in either NANO or raw (depending on the <tt>unit:</tt> argument)
+    #   [+open_block+] The first {Nanook::Block} in every account's blockchain. When this block was published the account was officially open
+    #   [+representative_block+] The {Nanook::Block} that named the representative for the account
+    #   [+balance+] Balance in either NANO or raw (depending on the <tt>unit:</tt> argument)
+    #   [+last_modified_at+] Time of when the account was last modified in UTC
+    #   [+representative+] Representative {Nanook::Account}
     #   [+block_count+] Number of blocks in the account's blockchain
-    #
-    #   When <tt>detailed: true</tt> is passed as an argument, this method
-    #   makes four additional calls to the RPC to return more information
-    #   about an account:
-    #
     #   [+weight+] See {#weight}
-    #   [+pending+] See {#balance}
-    #   [+representative+] See {#representative}
-    #   [+public_key+] See {#public_key}
-    def info(detailed: false, unit: Nanook.default_unit)
-      unless Nanook::UNITS.include?(unit)
-        raise ArgumentError.new("Unsupported unit: #{unit}")
-      end
+    #
+    # @raise [Nanook::NanoUnitError] if `unit` is invalid
+    def info(allow_unconfirmed: false, unit: Nanook.default_unit)
+      validate_unit!(unit)
+
+      params = {
+        representative: true,
+        weight: true,
+        pending: true,
+        include_confirmed: !allow_unconfirmed
+      }
 
-      response = rpc(:account_info)
+      response = rpc(:account_info, params)
       response.merge!(id: @account)
 
-      if unit == :nano
-        response[:balance] = Nanook::Util.raw_to_NANO(response[:balance])
+      # The RPC returned confirmed data when the `include_confirmed: true`
+      # has been passed. Normalize this data to the same keys as when
+      # unconfirmed data can be returned.
+      unless allow_unconfirmed
+        response[:balance] = response.delete(:confirmed_balance)
+        response[:pending] = response.delete(:confirmed_pending)
+        response[:representative] = response.delete(:confirmed_representative)
+        response[:frontier] = response.delete(:confirmed_frontier)
+        response[:confirmation_height] = response.delete(:confirmed_height)
       end
 
-      # Return the response if we don't need any more info
-      return response unless detailed
+      response[:frontier] = as_block(response[:frontier])
+      response[:open_block] = as_block(response[:open_block])
+      response[:representative_block] = as_block(response[:representative_block])
+      response[:representative] = as_account(response[:representative])
+      response[:last_modified_at] = as_time(response.delete(:modified_timestamp))
+      response[:confirmation_height_frontier] = as_block(response[:confirmation_height_frontier])
 
-      # Otherwise make additional calls
-      response.merge!({
-        weight: weight,
-        pending: balance(unit: unit)[:pending],
-        representative: representative,
-        public_key: public_key
-      })
+      if unit == :nano
+        response.merge!(
+          balance: raw_to_NANO(response[:balance]),
+          pending: raw_to_NANO(response[:pending]),
+          weight: raw_to_NANO(response[:weight])
+        )
+      end
 
-      # Sort this new hash by keys
-      Hash[response.sort].to_symbolized_hash
+      response.compact
     end
 
-    def inspect
-      "#{self.class.name}(id: \"#{id}\", object_id: \"#{"0x00%x" % (object_id << 1)}\")"
+    # @return [String]
+    def to_s
+      "#{self.class.name}(id: \"#{short_id}\")"
     end
+    alias inspect to_s
 
     # Information about the given account as well as other
     # accounts up the ledger. The number of accounts returned is determined
@@ -316,43 +387,56 @@ class Nanook
     # Example response:
     #
     #   {
-    #    :nano_3c3ek3k8135f6e8qtfy8eruk9q3yzmpebes7btzncccdest8ymzhjmnr196j=>{
-    #      :frontier=>"2C3C570EA8898443C0FD04A1C385A3E3A8C985AD792635FCDCEBB30ADF6A0570",
-    #      :open_block=>"C82376314C387080A753871A32AD70F4168080C317C5E67356F0A62EB5F34FF9",
-    #      :representative_block=>"C82376314C387080A753871A32AD70F4168080C317C5E67356F0A62EB5F34FF9",
-    #      :balance=>11439597000000000000000000000000,
-    #      :modified_timestamp=>1520500357,
-    #      :block_count=>4
+    #    Nanook::Account => {
+    #      :frontier => Nanook::Block,
+    #      :open_block => Nanook::Block,
+    #      :representative_block => Nanook::Block,
+    #      :representative => Nanook::Account,
+    #      :balance => 1143.7,
+    #      :last_modified_at => Time,
+    #      :block_count => 4
+    #      :weight => 5
+    #      :pending => 2.0
     #    },
-    #    :nano_3c3ettq59kijuuad5fnaq35itc9schtr4r7r6rjhmwjbairowzq3wi5ap7h8=>{ ... }
+    #    Nanook::Account => { ... }
     #  }
     #
-    # @param [Integer] limit number of accounts to return in the ledger (default is 1)
-    # @param [Time] modified_since return only accounts modified in the local database after this time
+    # @param limit [Integer] number of accounts to return in the ledger (default is 1000)
+    # @param modified_since [Time] optional. Return only accounts modified in the local database after this time (default is from the unix epoch)
     # @param unit (see #balance)
-    # @return [Hash{Symbol=>String|Integer}]
-    def ledger(limit: 1, modified_since:nil, unit: Nanook.default_unit)
-      unless Nanook::UNITS.include?(unit)
-        raise ArgumentError.new("Unsupported unit: #{unit}")
-      end
-
-      params = { count: limit }
-
-      unless modified_since.nil?
-        params[:modified_since] = modified_since.to_i
-      end
-
-      response = rpc(:ledger, params)[:accounts]
-
-      return response if unit == :raw
+    # @param sort [Symbol] default +:asc+. When set to +:desc+ the ledger will be returned oldest to newest.
+    # @return [Hash{Nanook::Account=>String|Integer}]
+    # @raise [Nanook::NanoUnitError] if `unit` is invalid
+    def ledger(limit: 1000, modified_since: 0, unit: Nanook.default_unit, sort: :asc)
+      validate_unit!(unit)
+
+      params = {
+        count: limit,
+        sorting: (sort == :desc),
+        modified_since: modified_since.to_i,
+        _access: :accounts,
+        _coerce: Hash
+      }
+
+      response = rpc(:ledger, params)
+
+      r = response.map do |account_id, ledger|
+        if unit == :nano
+          ledger[:balance] = raw_to_NANO(ledger[:balance])
+          ledger[:pending] = raw_to_NANO(ledger[:pending])
+          ledger[:weight] = raw_to_NANO(ledger[:weight])
+        end
 
-      r = response.map do |account_id, l|
-        l[:balance] = Nanook::Util.raw_to_NANO(l[:balance])
+        ledger[:last_modified_at] = as_time(ledger.delete(:modified_timestamp))
+        ledger[:representative] = as_account(ledger[:representative])
+        ledger[:representative_block] = as_block(ledger[:representative_block])
+        ledger[:open_block] = as_block(ledger[:open_block])
+        ledger[:frontier] = as_block(ledger[:frontier])
 
-        [account_id, l]
+        [as_account(account_id), ledger]
       end
 
-      Hash[r].to_symbolized_hash
+      Hash[r]
     end
 
     # Information about pending blocks (payments) that are
@@ -368,7 +452,7 @@ class Nanook
     #
     # ==== Examples:
     #
-    #   account.pending # => ["000D1BA..."]
+    #   account.pending # => [Nanook::Block, ..."]
     #
     # Asking for more detail to be returned:
     #
@@ -378,39 +462,50 @@ class Nanook
     #
     #   [
     #     {
-    #       block: "000D1BAEC8EC208142C99059B393051BAC8380F9B5A2E6B2489A277D81789F3F",
+    #       block: Nanook::Block,
     #       amount: 6,
-    #       source: "nano_3dcfozsmekr1tr9skf1oa5wbgmxt81qepfdnt7zicq5x3hk65fg4fqj58mbr"
+    #       source: Nanook::Account
     #     },
     #     { ... }
     #   ]
     #
     # @param limit [Integer] number of pending blocks to return (default is 1000)
-    # @param detailed [Boolean]return a more complex Hash of pending block information (default is +false+)
+    # @param detailed [Boolean] return a more complex Hash of pending block information (default is +false+)
+    # @param allow_unconfirmed [Boolean] +false+ by default. When +false+ only returns block which have their confirmation
+    #   height set or are undergoing confirmation height processing.
     # @param unit (see #balance)
-    #
-    # @return [Array<String>]
-    # @return [Array<Hash{Symbol=>String|Integer}>]
-    def pending(limit: 1000, detailed: false, unit: Nanook.default_unit)
-      unless Nanook::UNITS.include?(unit)
-        raise ArgumentError.new("Unsupported unit: #{unit}")
-      end
-
-      params = { count: limit }
+    # @param sorted [Boolean] false by default. Additionally sorts the blocks by their amounts in descending order.
+    #
+    # @return [Array<Nanook::Block>]
+    # @return [Array<Hash{Symbol=>Nanook::Block|Nanook::Account|Integer}>]
+    # @raise [Nanook::NanoUnitError] if `unit` is invalid
+    def pending(limit: 1000, detailed: false, allow_unconfirmed: false, unit: Nanook.default_unit, sorted: false)
+      validate_unit!(unit)
+
+      params = {
+        count: limit,
+        sorting: sorted,
+        include_only_confirmed: !allow_unconfirmed,
+        _access: :blocks,
+        _coerce: (detailed ? Hash : Array)
+      }
       params[:source] = true if detailed
 
-      response = rpc(:pending, params)[:blocks]
-      response = Nanook::Util.coerce_empty_string_to_type(response, (detailed ? Hash : Array))
+      response = rpc(:pending, params)
 
-      return response unless detailed
+      unless detailed
+        return response.map do |block|
+          as_block(block)
+        end
+      end
 
       response.map do |key, val|
-        p = val.merge(block: key.to_s)
-
-        if unit == :nano
-          p[:amount] = Nanook::Util.raw_to_NANO(p[:amount])
-        end
+        p = val.merge(
+          block: as_block(key.to_s),
+          source: as_account(val[:source])
+        )
 
+        p[:amount] = raw_to_NANO(p[:amount]) if unit == :nano
         p
       end
     end
@@ -419,23 +514,29 @@ class Nanook
     #
     # Weight is determined by the account's balance, and represents
     # the voting weight that account has on the network. Only accounts
-    # with greater than 256 weight can vote.
+    # with greater than 0.1% of the online voting weight and are on a node
+    # configured to vote can vote.
     #
     # ==== Example:
     #
     #   account.weight # => 0
     #
-    # @return [Integer] the account's weight
-    def weight
-      rpc(:account_weight)[:weight]
+    # @return [Integer|Float] the account's weight
+    # @raise [Nanook::NanoUnitError] if `unit` is invalid
+    def weight(unit: Nanook.default_unit)
+      validate_unit!(unit)
+
+      weight = rpc(:account_weight, _access: :weight)
+
+      return weight unless unit == :nano
+
+      raw_to_NANO(weight)
     end
 
     private
 
-    def rpc(action, params={})
-      p = @account.nil? ? {} : { account: @account }
-      @rpc.call(action, p.merge(params))
+    def rpc(action, params = {})
+      @rpc.call(action, { account: @account }.merge(params))
     end
-
   end
 end