nanook 1.0.2 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fa82959fcb3f2cd690b3a68e209a7c8ba72cb03f
-  data.tar.gz: c56d17490352c48cfd933b8ee9ef7e270058f0d3
+  metadata.gz: f71938ce617e3ee52fe2fb04cf9eebe97191f5d5
+  data.tar.gz: 210a3c2b1ce7ad7b767c0139eaf5ae153c9e8fda
 SHA512:
-  metadata.gz: 2763e3d7b87d63c2cd9cf4b582297fa43af8321965bd2c1ac638bc09f04aea715958ea84ec8a452a7639208dd7210219c1e7d10b9baf5d9729b05d15ea42ff6b
-  data.tar.gz: 74b7058a9686f41b1aafa07c4432baf8df5e1a083947bc12d35237c5adf1d65e06ea3812cccf4b20582bef0e235977bd34024b2f357c9ed885f73027fde07a38
+  metadata.gz: 68baffb5984f1509bf4b1e6889b8c378906db8a41c070afc22902fb3369be03ee8b6db36dabb70befd79562f938380b74193a2007b033f6d2d25273871fbaa96
+  data.tar.gz: a6610e8c5d616b48940d4c2837bd0cc6974d84d3b6c20418eb22543719740f353bd4c5c59ef86990dd8fe75b5c0b6c9e1386beb64b505a3784298a4fd77fa24c

data/CHANGELOG.md

@@ -4,6 +4,43 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
 and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
 
+## 2.0.0
+
+### Added
+
+- User can define `Nanook::UNIT = :raw` to set the default unit to `:raw` instead of `:nano`.
+- `Nanook::Wallet#restore` to create a wallet, change its seed and create x number of accounts.
+- `Nanook::WalletAccount#create` takes an optional argument to signal
+  how many accounts to create.
+- New `Nanook::WalletAccount#change_representative` method to change an
+  account's representative.
+- New `Nanook::Node#account_count` method to return number of known accounts in ledger.
+- New `Nanook::Node#synchronizing_blocks` method to return information about "unchecked" synchronizing blocks.
+- New `Nanook::Account#last_modified_at` method.
+- Added ruby version requirement >= 2.0 to gemspec.
+
+### Changed
+- `Nanook::Rpc#inspect` displays full hostname with scheme and port.
+- `Nanook::Account#new` `account` param is now required.
+- `Nanook::Account#info` now also returns the `id` of the account.
+- `Nanook::Account#history` now returns `amount` in NANO by default, takes `unit: :raw` argument to return in raw.
+- `Nanook::Account#info` now returns `balance` and `pending` in NANO by default, takes `unit: :raw` argument to return in raw.
+- `Nanook::Account#exists?` now checks for open block.
+- `Nanook::Account#pending` now takes additional arguments `detailed:` and `unit:`.
+- `Nanook::Block#account` now returns a `Nanook::Account` instance.
+- `Nanook::Block#info` now also returns the `id` of the block.
+- `Nanook::Wallet#accounts` now returns `Nanook::WalletAccount` instances.
+- `Nanook::Wallet#create` now returns a `Nanook::Wallet` instance.
+- `Nanook::Wallet#pending` now takes additional arguments `detailed:` and `unit:`.
+- `Nanook::Wallet#seed` alias method of `#id`.
+- `Nanook::WalletAccount#create` now returns `Nanook::WalletAccount` instances.
+- Changed documentation generating tool from rdoc to yard.
+
+### Fixed
+- Missing `Nanook#rpc` accessor.
+- `Nanook::Block#publish` can return false when publish fails.
+- `Nanook::Block#info` correctly handles `allow_unchecked: true` errors.
+
 ## 1.0.1
 
 ### Fixed
@@ -31,6 +68,3 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 - All pay methods continue to take NANO as the default unit, but can now
   also take an argument `unit:` which can be set to `:raw` to have the
   `amount` argument be treated as being in raw instead of NANO.
-
-
-### Removed

data/README.md

@@ -11,7 +11,7 @@ This is a Ruby library for managing a [nano currency](https://nano.org/) node, i
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'nanook', "~> 1.0"
+gem 'nanook', "~> 2.0"
 ```
 
 And then execute:
@@ -120,17 +120,26 @@ wallet.receive(block_id, into: account_id)
 
 ## All commands
 
-Below is a quick reference list of commands. See the [full Nanook documentation](https://lukes.github.io/nanook/1.0.0/) for a searchable detailed description of every class and method, what the arguments mean, and example responses (Tip: expand the "**Nanook** < Object" item in the sidebar).
+Below is a quick reference list of commands. See the [full Nanook documentation](https://lukes.github.io/nanook/2.0.0/) for a searchable detailed description of every class and method, what the arguments mean, and example responses (Tip: expand the "**Nanook** < Object" item in the sidebar).
 
 ### Wallets
 
-See the [full documentation for Nanook::Wallet](https://lukes.github.io/nanook/1.0.0/classes/Nanook/Wallet.html) for a detailed description of each method and example responses.
+See the [full documentation for Nanook::Wallet](https://lukes.github.io/nanook/2.0.0/classes/Nanook/Wallet.html) for a detailed description of each method and example responses.
 
 #### Create wallet:
 
 ```ruby
 Nanook.new.wallet.create
 ```
+#### Restoring a wallet from a seed
+
+```ruby
+Nanook.new.wallet.restore(seed)
+```
+Optionally also restore the wallet's accounts:
+```ruby
+Nanook.new.wallet.restore(seed, accounts: 2)
+```
 
 #### Working with a single wallet:
 
@@ -142,6 +151,10 @@ wallet.balance(account_break_down: true)
 wallet.balance(unit: :raw)
 wallet.pay(from: your_account_id, to: recipient_account_id, amount: 2, id: unique_id)
 wallet.pay(from: your_account_id, to: recipient_account_id, amount: 2, unit: :raw, id: unique_id)
+wallet.pending
+wallet.pending(limit: 1)
+wallet.pending(detailed: true)
+wallet.pending(unit: :raw)
 wallet.receive(into: account_id)
 wallet.receive(pending_block_id, into: account_id)
 
@@ -164,6 +177,12 @@ wallet.destroy
 Nanook.new.wallet(wallet_id).account.create
 ```
 
+#### Create multiple accounts:
+
+```ruby
+Nanook.new.wallet(wallet_id).account.create(5)
+```
+
 #### Working with a single account:
 
 ```ruby
@@ -175,19 +194,25 @@ account.pay(to: recipient_account_id, amount: 2, id: unique_id)
 account.pay(to: recipient_account_id, amount: 2, unit: :raw, id: unique_id)
 account.pending
 account.pending(limit: 1)
+account.pending(detailed: true)
+account.pending(unit: :raw)
 account.receive
 account.receive(pending_block_id)
 
 account.exists?
 account.info
 account.info(detailed: true)
+account.info(unit: :raw)
+account.last_modified_at
 account.ledger
 account.ledger(limit: 10)
 account.history
 account.history(limit: 1)
+account.history(unit: :raw)
 account.public_key
 account.delegators
 account.representative
+account.change_representative(new_representative)
 account.weight
 
 account.destroy
@@ -195,7 +220,7 @@ account.destroy
 
 #### Working with any account (not necessarily in your wallet):
 
-See the [full documentation for Nanook::Account](https://lukes.github.io/nanook/1.0.0/classes/Nanook/Account.html) for a detailed description of each method and example responses.
+See the [full documentation for Nanook::Account](https://lukes.github.io/nanook/2.0.0/classes/Nanook/Account.html) for a detailed description of each method and example responses.
 
 ```ruby
 account = Nanook.new.account(account_id)
@@ -204,14 +229,19 @@ account.balance
 account.balance(unit: :raw)
 account.pending
 account.pending(limit: 1)
+account.pending(detailed: true)
+account.pending(unit: :raw)
 
 account.exists?
 account.info
 account.info(detailed: true)
+account.info(unit: :raw)
+account.last_modified_at
 account.ledger
 account.ledger(limit: 10)
 account.history
 account.history(limit: 1)
+account.history(unit: :raw)
 account.public_key
 account.delegators
 account.representative
@@ -220,7 +250,7 @@ account.weight
 
 ### Blocks
 
-See the [full documentation for Nanook::Block](https://lukes.github.io/nanook/1.0.0/classes/Nanook/Block.html) for a detailed description of each method and example responses.
+See the [full documentation for Nanook::Block](https://lukes.github.io/nanook/2.0.0/classes/Nanook/Block.html) for a detailed description of each method and example responses.
 
 ```ruby
 block = Nanook.new.block(block_id)
@@ -250,14 +280,15 @@ block.is_valid_work?(work_id)
 ```ruby
 node = Nanook.new.node
 
+node.account_count
 node.block_count
 node.block_count_type
 node.bootstrap_any
 node.bootstrap(address: "::ffff:138.201.94.249", port: 7075)
-node.frontier_count
 node.peers
 node.representatives
-node.representatives
+node.synchronizing_blocks
+node.synchronizing_blocks(limit: 1)
 node.sync_progress
 node.synced?
 node.version
@@ -310,15 +341,14 @@ To run the test suite:
 
     bundle exec rspec spec
 
-To update rdoc documentation:
+To update the yard documentation:
 
-    bundle exec rake rerdoc
+    bundle exec rake yard
 
 ## License
 
 The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
 
-
 ## Buy me a nano coffee
 
 This library is totally free to use, but feel free to send some nano [my way](https://www.nanode.co/account/xrb_3c3ek3k8135f6e8qtfy8eruk9q3yzmpebes7btzncccdest8ymzhjmnr196j) if you'd like to!

data/lib/nanook.rb

@@ -19,52 +19,106 @@ Dir[File.dirname(__FILE__) + '/nanook/*.rb'].each {|file| require file }
 #   Nanook.new("http://ip6-localhost.com:7076", timeout: 600)
 class Nanook
 
-  # ==== Arguments
-  #
-  # * +uri+ - RPC host to connect to (default is "http://localhost:7076")
-  # * +timeout:+ - Connection timeout in number of seconds (default is 500)
-  #
-  # ==== Examples
-  #
-  #   Nanook.new # Connect to http://localhost:7076 with 500s timeout
+  UNITS = [:raw, :nano]
+  DEFAULT_UNIT = :nano
+
+  # @return [Nanook::Rpc]
+  attr_reader :rpc
+
+  # @return [Symbol] the default unit for amounts to be in.
+  #   will return {DEFAULT_UNIT} unless you define a new constant Nanook::UNIT
+  #   (which must be one of {UNITS})
+  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 600s:
+  #   Nanook.new
+  # Setting a custom timeout:
   #   Nanook.new(timeout: 600)
+  # Connecting to a custom RPC host and setting a timeout:
   #   Nanook.new("http://ip6-localhost.com:7076", timeout: 600)
+  #
+  # @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)
     @rpc = Nanook::Rpc.new(uri, timeout: timeout)
   end
 
-  ##
-  # Returns a Nanook::Account instance.
+  # Returns a new instance of {Nanook::Account}.
   #
-  #   nanook = Nanook.new
+  # ==== Example:
+  #   account = Nanook.new.account("xrb_3e3j5tkog48pnny9dmfzj1r16pg8t1e76dz5tmac6iq689wyjfpi00000000")
   #
-  #   account = nanook.account
-  #   account = nanook.account("xrb_3e3j5tkog48pnny9dmfzj1r16pg8t1e76dz5tmac6iq689wyjfpi00000000")
-  def account(account=nil)
+  # @param account [String] the id of the account you want to work with
+  # @return [Nanook::Account]
+  def account(account)
     Nanook::Account.new(@rpc, account)
   end
 
-  def block(block=nil)
+  # Returns a new instance of {Nanook::Block}.
+  #
+  # ==== Example:
+  #   block = Nanook.new.block("FBF8B0E6623A31AB528EBD839EEAA91CAFD25C12294C46754E45FD017F7939EB")
+  #
+  # @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)
   end
 
-  def inspect # :nodoc
+  # @return [String]
+  def inspect
     "#{self.class.name}(rpc: #{@rpc.inspect}, object_id: \"#{"0x00%x" % (object_id << 1)}\")"
   end
 
+  # Returns a new instance of {Nanook::Key}.
+  #
+  # ==== Example:
+  #   key = Nanook.new.key("3068BB1CA04525BB0E416C485FE6A67FD52540227D267CC8B6E8DA958A7FA039")
+  #
+  # @param key [String] a private key
+  # @return [Nanook::Key]
   def key(key=nil)
     Nanook::Key.new(@rpc, key)
   end
 
+  # Returns a new instance of {Nanook::Node}.
+  #
+  # ==== Example:
+  #   node = Nanook.new.node
+  #
+  # @return [Nanook::Node]
   def node
     Nanook::Node.new(@rpc)
   end
 
+  # Returns a new instance of {Nanook::Wallet}.
+  #
+  # ==== Example:
+  #   wallet = Nanook.new.wallet("000D1BAEC8EC208142C99059B393051BAC8380F9B5A2E6B2489A277D81789F3F")
+  #
+  # @param wallet [String] the id of the wallet you want to work with
+  # @return [Nanook::Wallet]
   def wallet(wallet=nil)
     Nanook::Wallet.new(@rpc, wallet)
   end
 
+  # Returns a new instance of {Nanook::WorkPeer}.
+  #
+  # ==== Example:
+  #   work_peers = Nanook.new.work_peers
+  #
+  # @return [Nanook::WorkPeer]
   def work_peers
     Nanook::WorkPeer.new(@rpc)
   end

data/lib/nanook/account.rb

@@ -5,7 +5,7 @@ class Nanook
   #
   # === Initializing
   #
-  # Initialize this class through the convenient Nanook#account method:
+  # Initialize this class through the convenient {Nanook#account} method:
   #
   #   nanook = Nanook.new
   #   account = nanook.account("xrb_...")
@@ -21,107 +21,143 @@ class Nanook
       @account = account
     end
 
-    # ==== Example response
+    # Returns information about this account's delegators.
+    # === Example response:
     #   {
-    #     "xrb_13bqhi1cdqq8yb9szneoc38qk899d58i5rcrgdk5mkdm86hekpoez3zxw5sd": "500000000000000000000000000000000000",
-    #     "xrb_17k6ug685154an8gri9whhe5kb5z1mf5w6y39gokc1657sh95fegm8ht1zpn": "961647970820730000000000000000000000"
+    #     :xrb_13bqhi1cdqq8yb9szneoc38qk899d58i5rcrgdk5mkdm86hekpoez3zxw5sd=>500000000000000000000000000000000000,
+    #     :xrb_17k6ug685154an8gri9whhe5kb5z1mf5w6y39gokc1657sh95fegm8ht1zpn=>961647970820730000000000000000000000
     #   }
+    #
+    # @return [Hash{Symbol=>String}] Delegators
     def delegators
-      account_required!
       rpc(:delegators)[:delegators]
     end
 
-    # Returns a boolean indicating if account is known. Note, the
-    # reliability of the check depends on the node host having
+    # Returns a boolean indicating if the account exists.
+    #
+    # Existence is determined by if the account has an _open_ block.
+    # An _open_ block is a special kind of block that gets published when
+    # an account receives a payment for the first time.
+    #
+    # The reliability of this check depends on the node host having
     # synchronized itself with most of the blocks on the nano network,
-    # otherwise you may get a false +false+. You can check if a node's
-    # synchronization is particular low using Nanook::Node#sync_progress.
+    # otherwise you may get +false+ when the account does exist.
+    # You can check if a node's  synchronization is particular low
+    # using {Nanook::Node#sync_progress}.
     #
-    # ==== Example response
-    #   true
+    # @return [Boolean] Indicates if this account exists in the nano network
     def exists?
-      account_required!
-      response = rpc(:validate_account_number)
-      !response.empty? && response[:valid] == 1
+      response = rpc(:account_info)
+      !response.empty? && !response[:open_block].nil?
     end
 
     # Returns an account's history of send and receive payments.
-    # Amounts are in {raw}[https://nano.org/en/faq#what-are-nano-units-].
-    #
-    # ==== Arguments
     #
-    # [+limit:+] Integer representing the maximum number of history
-    #            items to return (default is 1000)
-    #
-    # ==== Example
+    # ==== Example:
     #
     #   account.history
     #   account.history(limit: 1)
     #
-    # ==== Example response
+    # ==== Example response:
     #   [
     #     {
     #      :type=>"send",
     #      :account=>"xrb_1kdc5u48j3hr5r7eof9iao47szqh81ndqgq5e5hrsn1g9a3sa4hkkcotn3uq",
-    #      :amount=>200000000000000000000000000000,
+    #      :amount=>2,
     #      :hash=>"2C3C570EA8898443C0FD04A1C385A3E3A8C985AD792635FCDCEBB30ADF6A0570"
-    #     },
+    #     }
+    #   ]
+    # ==== Example:
+    #
+    #   account.history
+    #   account.history(unit: :raw)
+    #
+    # ==== Example response:
+    #   [
     #     {
-    #      :type=>"receive",
-    #      :account=>"xrb_1niabkx3gbxit5j5yyqcpas71dkffggbr6zpd3heui8rpoocm5xqbdwq44oh",
-    #      :amount=>7836413000000000000000000000000,
-    #      :hash=>"16743E8FF52F454E876E68EDD11F23094DCB96795A3B7F32F74F88563ACDDB04"
+    #      :type=>"send",
+    #      :account=>"xrb_1kdc5u48j3hr5r7eof9iao47szqh81ndqgq5e5hrsn1g9a3sa4hkkcotn3uq",
+    #      :amount=>2000000000000000000000000000000,
+    #      :hash=>"2C3C570EA8898443C0FD04A1C385A3E3A8C985AD792635FCDCEBB30ADF6A0570"
     #     }
     #   ]
-    def history(limit: 1000)
-      account_required!
-      rpc(:account_history, count: limit)[:history]
+    #
+    # @param limit [Integer] maximum number of history items to return
+    # @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
+
+      response = rpc(:account_history, count: limit)[:history]
+
+      if unit == :raw
+        return response
+      end
+
+      response.map! do |history|
+        history[:amount] = Nanook::Util.raw_to_NANO(history[:amount])
+        history
+      end
+    end
+
+    # @return [Time] last modified time of the account in UTC time zone.
+    def last_modified_at
+      response = rpc(:account_info)
+      Time.at(response[:modified_timestamp])
     end
 
     # Returns the public key belonging to an account.
     #
-    # ==== Example response
+    # ==== Example response:
     #   "3068BB1CA04525BB0E416C485FE6A67FD52540227D267CC8B6E8DA958A7FA039"
+    #
+    # @return [String] public key of this account
     def public_key
-      account_required!
       rpc(:account_key)[:key]
     end
 
-    # Returns a String of the representative account for the account.
+    # Returns the representative account for the account.
     # Representatives are accounts which cast votes in the case of a
     # fork in the network.
     #
     # ==== Example response
     #
     #   "xrb_3pczxuorp48td8645bs3m6c3xotxd3idskrenmi65rbrga5zmkemzhwkaznh"
+    #
+    # @return [String] Representative account of this account
     def representative
-      account_required!
       rpc(:account_representative)[:representative]
     end
 
-    # Returns a Hash containing the account's balance. Units are in
-    # {raw}[https://nano.org/en/faq#what-are-nano-units-].
+    # Returns a Hash containing the account's balance.
     #
-    # [+:balance+] Account balance
-    # [+:pending+] Amount pending and not yet received by the account
+    # ==== Example response:
+    #   {
+    #     balance=>2,   # Account balance
+    #     pending=>1.1  # Amount pending and not yet received by the account
+    #   }
     #
-    # ==== Arguments
+    # ==== Example balance returned in raw:
     #
-    # [+unit:+]   Symbol (default is +:nano+) Represents the unit that
-    #             the balances will be returned in.
-    #             Must be either +:nano+ or +:raw+. (Note: this method
-    #             interprets +:nano+ as NANO, which is technically Mnano
-    #             See {What are Nano's Units}[https://nano.org/en/faq#what-are-nano-units-])
+    #   account.balance(unit: :raw)
     #
-    # ===== Example response
     #   {
-    #    "balance": "2",
-    #    "pending": "1"
+    #     balance: 2000000000000000000000000000000,
+    #     pending: 1100000000000000000000000000000
     #   }
-    def balance(unit: Nanook::WalletAccount::DEFAULT_UNIT)
-      account_required!
-
-      unless Nanook::WalletAccount::UNITS.include?(unit)
+    #
+    # @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.
+    def balance(unit: Nanook.default_unit)
+      unless Nanook::UNITS.include?(unit)
         raise ArgumentError.new("Unsupported unit: #{unit}")
       end
 
@@ -133,35 +169,13 @@ class Nanook
       end
     end
 
-    # Returns the id of the account
+    # Returns the id of the account.
+    # @return [String] the id of the account
     def id
-      @block
+      @account
     end
 
-    # Returns a Hash containing the following information about an
-    # account:
-    #
-    # [+: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 {NANO}[https://nano.org/en/faq#what-are-nano-units-]
-    # [+:last_modified+] Unix timestamp
-    # [+: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
-    #
-    # ==== Arguments
-    #
-    # [+detailed:+] Boolean (default is false). When +true+, four
-    #               additional calls are made to the RPC to return more
-    #               information
+    # Returns a Hash containing information about the account.
     #
     # ==== Example 1
     #
@@ -169,6 +183,7 @@ class Nanook
     #
     # ==== Example 1 response
     #   {
+    #     :id=>"xrb_16u1uufyoig8777y6r8iqjtrw8sg8maqrm36zzcm95jmbd9i9aj5i8abr8u5"
     #     :balance=>11.439597000000001,
     #     :block_count=>4
     #     :frontier=>"2C3C570EA8898443C0FD04A1C385A3E3A8C985AD792635FCDCEBB30ADF6A0570",
@@ -183,6 +198,7 @@ class Nanook
     #
     # ==== Example 2 response
     #   {
+    #     :id=>"xrb_16u1uufyoig8777y6r8iqjtrw8sg8maqrm36zzcm95jmbd9i9aj5i8abr8u5"
     #     :balance=>11.439597000000001,
     #     :block_count=>4,
     #     :frontier=>"2C3C570EA8898443C0FD04A1C385A3E3A8C985AD792635FCDCEBB30ADF6A0570",
@@ -194,18 +210,46 @@ class Nanook
     #     :representative_block=>"C82376314C387080A753871A32AD70F4168080C317C5E67356F0A62EB5F34FF9",
     #     :weight=>0
     #   }
-    def info(detailed: false)
-      account_required!
+    #
+    # @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] 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 {NANO}[https://nano.org/en/faq#what-are-nano-units-]
+    #   [+last_modified+] Unix timestamp
+    #   [+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
 
       response = rpc(:account_info)
+      response.merge!(id: @account)
+
+      if unit == :nano
+        response[:balance] = Nanook::Util.raw_to_NANO(response[:balance])
+      end
 
       # Return the response if we don't need any more info
       return response unless detailed
 
       # Otherwise make additional calls
-      response = response.merge({
+      response.merge!({
         weight: weight,
-        pending: balance[:pending],
+        pending: balance(unit: unit)[:pending],
         representative: representative,
         public_key: public_key
       })
@@ -214,7 +258,7 @@ class Nanook
       Hash[response.sort].to_symbolized_hash
     end
 
-    def inspect # :nodoc:
+    def inspect
       "#{self.class.name}(id: \"#{id}\", object_id: \"#{"0x00%x" % (object_id << 1)}\")"
     end
 
@@ -231,7 +275,7 @@ class Nanook
     #
     # ==== Example
     #
-    #   ledger(limit: 2)
+    #   account.ledger(limit: 2)
     #
     # ==== Example response
     #   {
@@ -246,64 +290,80 @@ class Nanook
     #    :xrb_3c3ettq59kijuuad5fnaq35itc9schtr4r7r6rjhmwjbairowzq3wi5ap7h8=>{ ... }
     #  }
     def ledger(limit: 1)
-      account_required!
       rpc(:ledger, count: limit)[:accounts]
     end
 
-
-    # Returns information about pending block hashes that are waiting to
-    # be received by the account.
+    # Returns information about pending blocks (payments) that are
+    # waiting to be received by the account.
     #
-    # The default response is an Array of block hashes.
-    # With the +detailed:+ argument, the method can return a more
-    # complex Hash containing the amount in
-    # {raw}[https://nano.org/en/faq#what-are-nano-units-] of the pending
-    # block and the source account that sent it.
+    # See also the #receive method of this class for how to receive a pending payment.
     #
-    # ==== Arguments
+    # The default response is an Array of block ids.
     #
-    # [+limit:+] Number of pending blocks to return (default is 1000)
-    # [+detailed:+] Boolean to have this method return a more complex
-    #               Hash of pending block information (default is +false+)
+    # With the +detailed:+ argument, the method returns an Array of Hashes,
+    # which contain the source account id, amount pending and block id.
     #
-    # ==== Example 1
+    # ==== Example 1:
     #
-    #   pending
+    #   account.pending # => ["000D1BAEC8EC208142C99059B393051BAC8380F9B5A2E6B2489A277D81789F3F"]
     #
-    # ==== Example 1 response
-    #
-    #   ["000D1BAEC8EC208142C99059B393051BAC8380F9B5A2E6B2489A277D81789F3F"]
+    # ==== Example 2:
     #
-    # ==== Example 2
+    #   account.pending(detailed: true)
+    #   # =>
+    #   # [
+    #   #   {
+    #   #     :block=>"000D1BAEC8EC208142C99059B393051BAC8380F9B5A2E6B2489A277D81789F3F",
+    #   #     :amount=>6,
+    #   #     :source=>"xrb_3dcfozsmekr1tr9skf1oa5wbgmxt81qepfdnt7zicq5x3hk65fg4fqj58mbr"
+    #   #   },
+    #   #   { ... }
+    #   # ]
     #
-    #   pending(detailed: true)
+    # ==== Example 3:
     #
-    # ==== Example 2 response
+    #   account.pending(detailed: true, unit: raw).first[:amount] # => 6000000000000000000000000000000
+    # @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 unit (see #balance)
     #
-    #   {
-    #     "000D1BAEC8EC208142C99059B393051BAC8380F9B5A2E6B2489A277D81789F3F"=>{
-    #      "amount"=>"6000000000000000000000000000000",
-    #      "source"=>"xrb_3dcfozsmekr1tr9skf1oa5wbgmxt81qepfdnt7zicq5x3hk65fg4fqj58mbr"
-    #     }
-    #   }
-    def pending(limit: 1000, detailed: false)
-      account_required!
+    # @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
 
-      args = { count: limit }
-      args[:source] = true if detailed
+      params = { count: limit }
+      params[:source] = true if detailed
 
-      response = rpc(:pending, args)[:blocks]
-      Nanook::Util.coerce_empty_string_to_type(response, (detailed ? Hash : Array))
+      response = rpc(:pending, params)[:blocks]
+      response = Nanook::Util.coerce_empty_string_to_type(response, (detailed ? Hash : Array))
+
+      return response unless detailed
+
+      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
+      end
     end
 
-    # Returns the account's weight. Weight is determined by the
-    # account's balance, and represents the voting weight that account
-    # has on the network if it is a representative.
+    # Returns the account's weight.
     #
-    # ==== Example response
-    #   1
+    # 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.
+    #
+    # ==== Example:
+    #   account.weight # => 0
+    #
+    # @return [Integer] the account's weight
     def weight
-      account_required!
       rpc(:account_weight)[:weight]
     end
 
@@ -314,11 +374,5 @@ class Nanook
       @rpc.call(action, p.merge(params))
     end
 
-    def account_required!
-      if @account.nil?
-        raise ArgumentError.new("Account must be present")
-      end
-    end
-
   end
 end