nanook 2.3.0 → 3.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 4453793303eb12685b219bed3586cfe92f09909f
-  data.tar.gz: 0b4a3a21470ba6b7916a8fe7304234be89fd6234
+SHA256:
+  metadata.gz: 86e9dced1a4ce9942cd123c262d7ff45fad6e982ce67c6903b6495a2609c29f9
+  data.tar.gz: 11d3752a80bc33e41ba7e19c7d4e2ad54b2d4a08212b71e7fd3579092d9b8c55
 SHA512:
-  metadata.gz: 1dc885c8cf50d2773de155e3b970cdf3f400641d9cc5a378996cc544ba18b96eab0a97dfc01592a33bf027fac2df6fa3f29bdf886e8c7fecaf827f4bcc848968
-  data.tar.gz: ff5a87c994fa30e96730336a9ea5ee6c14939302ee2dd329dd83faa01a4479cbd0dfcd79dc0374a44d9c7562813e6799038d532b0c0f05c75fd30aa5c3214ebc
+  metadata.gz: c53742261c03ba53fdcc46ffbcd0c556ccfe3d1b025f593d1b3f1ee9c6f1c1fcacb387b419aac07eefab390356022373dcc2121449097e968f051ac0498d4dfc
+  data.tar.gz: d1d4e28e58f28ee5ea161232276454b5eafd8959b63685db3440a6e15e1328e31b6676f5676f94fe0d30420e6e5b0c540a9345033dfb137fbf89d56ccf0de951

data/CHANGELOG.md

@@ -4,6 +4,146 @@ 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).
 
+## 3.0.1
+
+### Fixed
+
+- Fix `Block#type` being `nil` when RPC doesn't return a `subtype`.
+
+## 3.0.0
+
+### Removed
+
+- `Nanook::Block#block_count_by_type` Removed, as the RPC no longer supports this command.
+- `Nanook::Block#history` Removed, as the RPC command is deprecated.
+- `Nanook::Block#publish` Removed, as the RPC command expects more data than what we instantiate within `Nanook::Block`.
+- Removed all RPC calls that are not recommended for production:
+  - `Nanook::Node#bootstrap_status`.
+  - `Nanook::Node#confirmation_history`.
+  - `Nanook::Node#confirmed_recently?`.
+- `Nanook::Key` Replaced by `Nanook::PrivateKey`.
+- `Nanook::Account#info` No longer accepts `detailed:` argument.
+- `Nanook::Node#synced?` As this was deprecated for removal in v3.0.
+
+### Added
+
+- Added missing `Nanook::WalletAccount#block_count` delegate.
+- Added `Nanook#network_telemetry`.
+- Added `Nanook::Rpc#test`.
+- Added `Nanook::WalletAccount#work`.
+- Added `Nanook::WalletAccount#set_work`.
+- Added `Nanook::Account#blocks`.
+- Added `Nanook::Account#delegators_count`.
+- Added `Nanook::Account#open_block`.
+- Added `Nanook::Node#change_receive_minimum`.
+- Added `Nanook::Node#confirmation_quorum`.
+- Added `Nanook::Node#keepalive`.
+- Added `Nanook::Node#receive_minimum`.
+- Added `Nanook::Node#search_pending`.
+- Added `Nanook::Wallet#history`.
+- Added `Nanook::Wallet#exists?`.
+- Added `Nanook::Wallet#ledger`.
+- Added `Nanook::Wallet#move_accounts`.
+- Added `Nanook::Wallet#remove_account`.
+- Added `Nanook::Wallet#republish_blocks`.
+- Added `Nanook::Wallet#search_pending`.
+- Added `Nanook::Wallet#work`.
+- Added `Nanook::Block#account`.
+- Added `Nanook::Block#amount`.
+- Added `Nanook::Block#balance`.
+- Added `Nanook::Block#change?`.
+- Added `Nanook::Block#confirmed?`.
+- Added `Nanook::Block#epoch?`.
+- Added `Nanook::Block#exists?`.
+- Added `Nanook::Block#height`.
+- Added `Nanook::Block#open?`.
+- Added `Nanook::Block#previous`.
+- Added `Nanook::Block#receive?`.
+- Added `Nanook::Block#representative`.
+- Added `Nanook::Block#send?`.
+- Added `Nanook::Block#signature`.
+- Added `Nanook::Block#timestamp`.
+- Added `Nanook::Block#type`.
+- Added `Nanook::Block#unconfirmed?`.
+- Added `Nanook::Block#work`.
+- Added `Nanook::PrivateKey` with methods `#create`, `#account` and `#public_key`.
+- Added `Nanook::PublicKey` with method `#account`.
+- Added equality testing methods `#==`, `#eql?` and `#hash` for:
+    - `Nanook::Account`
+    - `Nanook::Block`
+    - `Nanook::PrivateKey`
+    - `Nanook::PublicKey`
+    - `Nanook::Wallet`
+    - `Nanook::WalletAccount`
+
+### Changed
+
+- New error classes: `Nanook::ConnectionError`, `NanoUnitError`, `NodeRpcError` and `NodeRpcConfigurationError`.
+- `Nanook::Wallet#default_representative` returns a `Nanook::Account`.
+- `Nanook::Wallet#change_representative` returns a `Nanook::Account`.
+- `Nanook::Wallet#unlock` can be passed no argument (`password` will be `nil`).
+- `Nanook::Wallet#info` returns data from `wallet_info` RPC.
+- `Nanook::Block#is_valid_work?` renamed to `#valid_work?`.
+- `Nanook::Block#republish` returns an Array of `Nanook::Block`s.
+- `Nanook::Block#chain` returns an Array of `Nanook::Block`s.
+- `Nanook::Block#successors` returns an Array of `Nanook::Block`s.
+- `Nanook::Block#info`:
+  - returns balances in nano, and can optionally be passed `unit: :raw` argument.
+  - returns account values as `Nanook::Account` and block values as `Nanook::Block`.
+- `Nanook::Node#peers` returns details as a `Hash` keyed by `Nanook::Account`.
+- `Nanook::Account#pending` returns source as `Nanook::Account` and block as `Nanook::Block` when `detailed: true`.
+- `Nanook::Account#representative` returns a `Nanook::Account`.
+- `Nanook::Account#delegators` returns accounts as `Nanook::Account`s.
+- `Nanook::Account#history` returns accounts as `Nanook::Account` and blocks as `Nanook::Block`.
+- `Nanook::Account#ledger` returns accounts as `Nanook::Account` and blocks as `Nanook::Block`.
+- `Nanook::Account#public_key` returns a `Nanook::PublicKey`.
+- `Nanook::Account#weight` accepts an optional `unit:` argment.
+- `Nanook::Account#info`:
+     - returns the `frontier`, `open_block`, `representative_block` values as `Nanook::Block`s.
+     - returns the `representative` as a `Nanook::Account`.
+     - `modified_timestamp` key renamed to `last_modified_at` and value is a `Time` in UTC.
+- `Nanook::Key` has become `Nanook::PrivateKey`, `#generate` has been renamed `#create` and returns a `Nanook::PrivateKey`.
+
+### Fixed
+
+- A number of errors when node is still bootstrapping and is missing accounts from the ledger.
+- `Nanook::Node#representatives_online` accessing representative list as a `Hash` after RPC change.
+
+## 2.5.1
+
+### Fixed
+
+- undefined method 'new' for `BigDecimal:Class` (thank you @MihaiVoinea)
+
+## 2.5.0
+
+### Added
+
+- New `Nanook::Node#bootstrap_lazy` method.
+- New `Nanook::Node#bootstrap_status` method.
+- New `Nanook::Node#difficulty` method.
+- New `Nanook::Node#uptime` method.
+- New `Nanook::Wallet#lock` method.
+
+### Changed
+
+- `Nanook::Node#chain` now takes optional `offset` argument.
+- `Nanook::Node#successors` now takes optional `offset` argument.
+- `Nanook::Node#successors` now aliased as `Nanook::Node#ancestors`
+- Updated docs to use `nano_` prefixed addresses.
+
+## 2.4.0
+
+### Added
+
+- New `Nanook::Node#confirmation_history` method.
+- New `Nanook::Block#confirm` method.
+- New `Nanook::Block#confirmed_recently?` method.
+
+### Changed
+
+- `Nanook::Block#generate_work` now can take optional `use_peers` argument.
+
 ## 2.3.0
 
 ### Added

data/README.md

@@ -1,6 +1,6 @@
 # Nanook
 
-This is a Ruby library for managing a [nano currency](https://nano.org/) node, including making and receiving payments, using the [nano RPC protocol](https://github.com/nanocurrency/raiblocks/wiki/RPC-protocol). Nano is a fee-less, fast, environmentally-friendly cryptocurrency. It's awesome. See [https://nano.org](https://nano.org/).
+This is a Ruby library for managing a [nano currency](https://nano.org/) node, including making and receiving payments, using the [nano RPC protocol](https://docs.nano.org/commands/rpc-protocol). Nano is a fee-less, fast, environmentally-friendly cryptocurrency. It's awesome. See [https://nano.org](https://nano.org/).
 
 [![Gem Version](https://badge.fury.io/rb/nanook.svg)](https://badge.fury.io/rb/nanook)
 [![CircleCI](https://circleci.com/gh/lukes/nanook/tree/master.svg?style=shield)](https://circleci.com/gh/lukes/nanook/tree/master)
@@ -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', "~> 2.3"
+gem 'nanook'
 ```
 
 And then execute:
@@ -26,7 +26,7 @@ Or install it yourself as:
 
 ## Initializing
 
-Nanook will by default connect to `http://localhost:7076`.
+Nanook will by default connect to `http://[::1]:7076`.
 
 ```ruby
 nanook = Nanook.new
@@ -35,7 +35,7 @@ nanook = Nanook.new
 To connect to another host instead:
 
 ```ruby
-nanook = Nanook.new("http://ip6-localhost:7076")
+nanook = Nanook.new("http://localhost:7076")
 ```
 
 ## Basics
@@ -45,19 +45,19 @@ nanook = Nanook.new("http://ip6-localhost:7076")
 Create a wallet:
 
 ```ruby
-Nanook.new.wallet.create
+wallet = nanook.wallet.create
 ```
 
 Create an account within a wallet:
 
 ```ruby
-Nanook.new.wallet(wallet_id).account.create
+account = wallet.account.create
 ```
 
 List accounts within a wallet:
 
 ```ruby
-Nanook.new.wallet(wallet_id).accounts
+accounts = wallet.accounts
 ```
 
 ### Sending a payment
@@ -65,28 +65,28 @@ Nanook.new.wallet(wallet_id).accounts
 To send a payment from an account in a wallet:
 
 ```ruby
-account = Nanook.new.wallet(wallet_id).account(account_id)
+account = nanook.wallet(wallet_id).account(account_id)
 account.pay(to: recipient_account_id, amount: 0.2, id: unique_id)
 ```
 
 Or, a wallet:
 
 ```ruby
-wallet = Nanook.new.wallet(wallet_id)
+wallet = nanook.wallet(wallet_id)
 wallet.pay(from: your_account_id, to: recipient_account_id, amount: 0.2, id: unique_id)
 ```
 
-The `id` can be any string and needs to be unique per payment. It serves an important purpose; it allows you to make this call multiple times with the same `id` and be reassured that you will only ever send that nano payment once. From the [Nano RPC](https://github.com/nanocurrency/raiblocks/wiki/RPC-protocol#account-create):
+The `id` can be any string and needs to be unique per payment. It serves an important purpose; it allows you to make this call multiple times with the same `id` and be reassured that you will only ever send that nano payment once. From the [Nano RPC](https://docs.nano.org/commands/rpc-protocol/#send):
 
 > You can (and should) specify a unique id for each spend to provide idempotency. That means that if you [make the payment call] two times with the same id, the second request won't send any additional Nano.
 
-The unit of the `amount` is NANO (which is currently technically Mnano — see [What are Nano's Units](https://nano.org/en/faq#what-are-nano-units-)). You can pass an amount of raw instead by adding the `unit: :raw` argument:
+The unit of the `amount` is NANO (which is currently technically Mnano — see [What are Nano's Units](https://docs.nano.org/protocol-design/distribution-and-units/#unit-dividers)). You can pass an amount of raw instead by adding the `unit: :raw` argument:
 
 ```ruby
 account.pay(to: recipient_account_id, amount: 999, unit: :raw, id: unique_id)
 ```
 
-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):
+Note, there may be a delay in receiving a response due to Proof of Work being done. From the [Nano RPC](https://docs.nano.org/commands/rpc-protocol/#send):
 
 > Proof of Work is precomputed for one transaction in the background. If it has been a while since your last transaction it will send instantly, the next one will need to wait for Proof of Work to be generated.
 
@@ -95,12 +95,12 @@ Note, there may be a delay in receiving a response due to Proof of Work being do
 The simplest way to receive a payment is:
 
 ```ruby
-account = Nanook.new.wallet(wallet_id).account(account_id)
+account = nanook.wallet(wallet_id).account(account_id)
 account.receive
 
 # or:
 
-wallet = Nanook.new.wallet(wallet_id)
+wallet = nanook.wallet(wallet_id)
 wallet.receive(into: account_id)
 ```
 
@@ -109,42 +109,46 @@ The `receive` method when called as above will receive the latest pending paymen
 You can also receive a specific pending block if you know it (you may have discovered it through calling `account.pending` for example):
 
 ```ruby
-account = Nanook.new.wallet(wallet_id).account(account_id)
+account = nanook.wallet(wallet_id).account(account_id)
 account.receive(block_id)
 
 # or:
 
-wallet = Nanook.new.wallet(wallet_id)
+wallet = nanook.wallet(wallet_id)
 wallet.receive(block_id, into: account_id)
 ```
 
+## Exploring further
+
+Read the [Using Nanook](https://github.com/lukes/nanook/wiki/Using-nanook) page for some example uses of Nanook to query the network.
+
 ## All commands
 
-Below is a quick reference list of commands. See the [full Nanook documentation](https://lukes.github.io/nanook/2.3.0/) for a searchable detailed description of every class and method, what the arguments mean, and example responses (Tip: the classes are listed under 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/3.0.1/) for a searchable detailed description of every class and method, what the arguments mean, and example responses.
 
 ### Wallets
 
-See the [full documentation for Nanook::Wallet](https://lukes.github.io/nanook/2.3.0/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/3.0.1/Nanook/Wallet.html) for a detailed description of each method and example responses.
 
 #### Create wallet:
 
 ```ruby
-Nanook.new.wallet.create
+nanook.wallet.create
 ```
 #### Restoring a wallet from a seed
 
 ```ruby
-Nanook.new.wallet.restore(seed)
+nanook.wallet.restore(seed)
 ```
 Optionally also restore the wallet's accounts:
 ```ruby
-Nanook.new.wallet.restore(seed, accounts: 2)
+nanook.wallet.restore(seed, accounts: 2)
 ```
 
-#### Working with a single wallet:
+#### Working with a wallet:
 
 ```ruby
-wallet = Nanook.new.wallet(wallet_id)
+wallet = nanook.wallet(wallet_id)
 
 wallet.balance
 wallet.balance(account_break_down: true)
@@ -157,19 +161,32 @@ wallet.pending(detailed: true)
 wallet.pending(unit: :raw)
 wallet.receive(into: account_id)
 wallet.receive(pending_block_id, into: account_id)
+wallet.search_pending
 
 wallet.account.create
+wallet.account.create(5)
 wallet.accounts
 wallet.contains?(account_id)
+wallet.move_accounts(from_wallet_id, [account_1_id, account_2_id])
+wallet.remove_account(account_id)
 
 wallet.default_representative
-wallet.change_default_representative(new_representative)
+wallet.change_default_representative(representative_account_id)
+wallet.change_password(password)
+wallet.exists?
+wallet.history
+wallet.history(unit: :raw)
 wallet.info
 wallet.info(unit: :raw)
 wallet.export
+wallet.ledger
+wallet.ledger(unit: :raw)
+wallet.lock
 wallet.locked?
+wallet.republish_blocks
+wallet.republish_blocks(limit: 5)
 wallet.unlock(password)
-wallet.change_password(password)
+wallet.work
 
 wallet.destroy
 ```
@@ -178,131 +195,159 @@ wallet.destroy
 #### Create account:
 
 ```ruby
-Nanook.new.wallet(wallet_id).account.create
+nanook.wallet(wallet_id).account.create
 ```
 
 #### Create multiple accounts:
 
 ```ruby
-Nanook.new.wallet(wallet_id).account.create(5)
+nanook.wallet(wallet_id).account.create(5)
 ```
 
-#### Working with a single account:
+#### Working with an account:
 
-See the [full documentation for Nanook::WalletAccount](https://lukes.github.io/nanook/2.3.0/Nanook/WalletAccount.html) for a detailed description of each method and example responses.
+Any account on the Nano network that is known by your node can be initialized through `Nanook#account`:
 
 ```ruby
-account = Nanook.new.wallet(wallet_id).account(account_id)
+account = nanook.account(account_id)
+```
 
+See the [full documentation for Nanook::Account](https://lukes.github.io/nanook/3.0.1/Nanook/Account.html) for a detailed description of each method and example responses.
+
+```ruby
 account.balance
 account.balance(unit: :raw)
-account.pay(to: recipient_account_id, amount: 2, id: unique_id)
-account.pay(to: recipient_account_id, amount: 2, id: unique_id, unit: :raw)
 account.pending
 account.pending(limit: 1)
 account.pending(detailed: true)
 account.pending(unit: :raw)
-account.receive
-account.receive(pending_block_id)
 
+account.blocks
+account.blocks(limit: 1)
+account.blocks(sort: :desc)
+account.delegators
+account.delegators(unit: :raw)
+account.delegators_count
 account.exists?
+account.history
+account.history(limit: 1)
+account.history(unit: :raw)
+account.history(sort: :desc)
 account.info
-account.info(detailed: true)
 account.info(unit: :raw)
 account.last_modified_at
 account.ledger
 account.ledger(limit: 10)
 account.ledger(modified_since: Time.now)
 account.ledger(unit: :raw)
-account.history
-account.history(limit: 1)
-account.history(unit: :raw)
+account.ledger(sort: :desc)
+account.open_block
 account.public_key
-account.delegators
-account.delegators(unit: :raw)
 account.representative
-account.change_representative(new_representative)
 account.weight
-
-account.destroy
+account.weight(unit: :raw)
 ```
 
-#### Working with any account (not necessarily in your wallet):
+#### Working with an account created on the node:
 
-See the [full documentation for Nanook::Account](https://lukes.github.io/nanook/2.3.0/Nanook/Account.html) for a detailed description of each method and example responses.
+Accounts that have been created on your node can have
+additional methods when initialized through `Nanook::Wallet#account`:
 
 ```ruby
-account = Nanook.new.account(account_id)
+wallet = nanook.wallet(wallet_id)
+account = wallet.account(account_id)
+```
 
-account.balance
-account.balance(unit: :raw)
-account.pending
-account.pending(limit: 1)
-account.pending(detailed: true)
-account.pending(unit: :raw)
+As well as the following methods, all methods of [regular accounts](#working-with-any-account) can also be called.
 
-account.exists?
-account.info
-account.info(detailed: true)
-account.info(unit: :raw)
-account.last_modified_at
-account.ledger
-account.ledger(limit: 10)
-account.ledger(modified_since: Time.now)
-account.ledger(unit: :raw)
-account.history
-account.history(limit: 1)
-account.history(unit: :raw)
-account.public_key
-account.delegators
-account.delegators(unit: :raw)
-account.representative
-account.weight
+See the [full documentation for Nanook::WalletAccount](https://lukes.github.io/nanook/3.0.1/Nanook/WalletAccount.html) for a detailed description of each method and example responses.
+
+```ruby
+account.pay(to: recipient_account_id, amount: 2, id: unique_id)
+account.pay(to: recipient_account_id, amount: 2, id: unique_id, unit: :raw)
+account.receive
+account.receive(pending_block_id)
+account.change_representative(new_representative)
+account.set_work(work)
+account.work
+account.destroy
 ```
 
 ### Blocks
 
-See the [full documentation for Nanook::Block](https://lukes.github.io/nanook/2.3.0/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/3.0.1/Nanook/Block.html) for a detailed description of each method and example responses.
 
 ```ruby
-block = Nanook.new.block(block_id)
+block = nanook.block(block_id)
 
+block.account
+block.amount
+block.amount(unit: :raw)
+block.balance
+block.change?
+block.checked?
+block.epoch?
+block.exists?
+block.exists?(allow_unchecked: true)
+block.height
 block.info                        # Verified blocks in the ledger
 block.info(allow_unchecked: true) # Verified blocks AND unchecked synchronizing blocks
+block.info(unit: :raw)
 block.account
 block.chain
 block.chain(limit: 10)
-block.history
-block.history(limit: 10)
+block.chain(offset: 10)
+block.confirm
 block.republish
 block.republish(sources: 2)
 block.republish(destinations: 2)
+block.open?
 block.pending?
-block.publish
+block.previous
+block.receive?
+block.representative
+block.send?
+block.signature
 block.successors
 block.successors(limit: 10)
+block.successors(offset: 10)
+block.timestamp
+block.type
+block.unchecked?
+block.work
 
 block.generate_work
+block.generate_work(use_peers: true)
 block.cancel_work
-block.is_valid_work?(work_id)
+block.valid_work?(work)
 ```
 
 ### Managing your nano node
 
-See the [full documentation for Nanook::Node](https://lukes.github.io/nanook/2.3.0/Nanook/Node.html) for a detailed description of each method and example responses.
+See the [full documentation for Nanook::Node](https://lukes.github.io/nanook/3.0.1/Nanook/Node.html) for a detailed description of each method and example responses.
 
 ```ruby
-node = Nanook.new.node
+node = nanook.node
 
 node.account_count
 node.block_count
-node.block_count_by_type
-node.bootstrap_any
 node.bootstrap(address: "::ffff:138.201.94.249", port: 7075)
+node.bootstrap_any
+node.bootstrap_lazy(block_id)
+node.bootstrap_lazy(block_id, force: true)
+node.confirmation_quorum
+node.difficulty
+node.difficulty(include_trend: true)
+node.keepalive(address: "::ffff:138.201.94.249", port: 7075)
 node.peers
+node.receive_minimum
+node.receive_minimum(unit: :raw)
+node.change_receive_minimum(amount)
+node.change_receive_minimum(amount, unit: :raw)
 node.representatives
 node.representatives(unit: :raw)
 node.representatives_online
+node.search_pending
 node.synchronizing_blocks
 node.synchronizing_blocks(limit: 1)
 node.sync_progress
@@ -314,7 +359,7 @@ node.stop
 ### Work peers
 
 ```ruby
-work_peers = Nanook.new.work_peers
+work_peers = nanook.work_peers
 
 work_peers.add(address: "::ffff:172.17.0.1:7076", port: 7076)
 work_peers.clear
@@ -326,26 +371,44 @@ work_peers.list
 #### Create private public key pair:
 
 ```ruby
-Nanook.new.key.generate
-Nanook.new.key.generate(seed: seed, index: 0)
+private_key = nanook.private_key.create
+private_key = nanook.private_key.create(seed: seed, index: 0)
+private_key.public_key # => Nanook::PublicKey
 ```
 
-#### Working with a single key
+#### Working with a private key
 
 ```ruby
-key = Nanook.new.key(private_key)
+key = nanook.private_key(private_key)
+
+key.account
+key.public_key
+```
 
-key.info
+#### Working with a public key
+
+```ruby
+key = nanook.public_key(public_key)
+
+key.account
+```
+
+### Network
+
+A summarized overview of the Nano network:
+
+```ruby
+nanook.network_telemetry
 ```
 
 ## Nanook Metal
 
-You can do any call listed in the [Nano RPC](https://github.com/nanocurrency/raiblocks/wiki/RPC-protocol) directly through the `rpc` method. The first argument should match the `action` of the RPC call, and then all remaining parameters are passed in as arguments.
+You can do any call listed in the [Nano RPC](https://docs.nano.org/commands/rpc-protocol) directly through the `rpc` method. The first argument should match the `action` of the RPC call, and then all remaining parameters are passed in as arguments.
 
-E.g., the [accounts_create command](https://github.com/nanocurrency/raiblocks/wiki/RPC-protocol#accounts-create) can be called like this:
+E.g., the [accounts_create command](https://docs.nano.org/commands/rpc-protocol/#accounts_create) can be called like this:
 
 ```ruby
-Nano.new.rpc(:accounts_create, wallet: wallet_id, count: 2)
+nanook.rpc.call(:accounts_create, wallet: wallet_id, count: 2)
 ```
 
 ## Contributing
@@ -366,11 +429,11 @@ The gem is available as open source under the terms of the [MIT License](https:/
 
 ## 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!
+This library is always free to use, but feel free to send some nano [my way](https://www.nanode.co/account/nano_3c3ek3k8135f6e8qtfy8eruk9q3yzmpebes7btzncccdest8ymzhjmnr196j) if you'd like to!
 
-    xrb_3c3ek3k8135f6e8qtfy8eruk9q3yzmpebes7btzncccdest8ymzhjmnr196j
+    nano_3c3ek3k8135f6e8qtfy8eruk9q3yzmpebes7btzncccdest8ymzhjmnr196j
 
-![alt xrb_3c3ek3k8135f6e8qtfy8eruk9q3yzmpebes7btzncccdest8ymzhjmnr196j](https://raw.githubusercontent.com/lukes/nanook/master/img/qr.png)
+![alt nano_3c3ek3k8135f6e8qtfy8eruk9q3yzmpebes7btzncccdest8ymzhjmnr196j](https://raw.githubusercontent.com/lukes/nanook/master/img/qr.png)