nanook 0.6.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 96226472bd51f8f70ef9462fa26ddf6b6f16da85
+  data.tar.gz: 014690cf0466ed78b0aa95a92ad9dd2f15a7581b
+SHA512:
+  metadata.gz: 5571c48e4ce49a3e75487d7632d51ed4b7b5edc5ccb3aed14e3c7e18f92cd18c582606e2152ea4eb21bca238a077068a48b12db1036a43043d924c29e112fff2
+  data.tar.gz: cf515b77fe27f4cb882a36a04b8c109943388cdcd33db3c34a018f586a7c41f8c0a8dc406a048048dcfad21edde62bbae6e468d0131efa96202990f45eb170f1

data/.circleci/config.yml

@@ -0,0 +1,56 @@
+# Ruby CircleCI 2.0 configuration file
+#
+# Check https://circleci.com/docs/2.0/language-ruby/ for more details
+#
+version: 2
+jobs:
+  build:
+    docker:
+      # specify the version you desire here
+       - image: circleci/ruby:2.4.1-node-browsers
+
+      # Specify service dependencies here if necessary
+      # CircleCI maintains a library of pre-built images
+      # documented at https://circleci.com/docs/2.0/circleci-images/
+      # - image: circleci/postgres:9.4
+
+    working_directory: ~/repo
+
+    steps:
+      - checkout
+
+      # Download and cache dependencies
+      - restore_cache:
+          keys:
+          - v1-dependencies-{{ checksum "Gemfile.lock" }}
+          # fallback to using the latest cache if no exact match is found
+          - v1-dependencies-
+
+      - run:
+          name: install dependencies
+          command: |
+            bundle install --jobs=4 --retry=3 --path vendor/bundle
+
+      - save_cache:
+          paths:
+            - ./vendor/bundle
+          key: v1-dependencies-{{ checksum "Gemfile.lock" }}
+
+      # Database setup
+      # - run: bundle exec rake db:create
+      # - run: bundle exec rake db:schema:load
+
+      # run tests!
+      - run:
+          name: run tests
+          command: |
+            mkdir /tmp/test-results
+
+            bundle exec rspec spec --format progress --out /tmp/test-results/rspec.xml
+
+      # collect reports
+      - store_test_results:
+          path: /tmp/test-results
+      - store_artifacts:
+          path: /tmp/test-results
+          destination: test-results

data/.gitignore

@@ -0,0 +1,8 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in nanook.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,49 @@
+PATH
+  remote: .
+  specs:
+    nanook (0.6.0)
+      symbolized
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    addressable (2.5.2)
+      public_suffix (>= 2.0.2, < 4.0)
+    crack (0.4.3)
+      safe_yaml (~> 1.0.0)
+    diff-lcs (1.3)
+    hashdiff (0.3.7)
+    public_suffix (3.0.2)
+    rake (10.5.0)
+    rspec (3.7.0)
+      rspec-core (~> 3.7.0)
+      rspec-expectations (~> 3.7.0)
+      rspec-mocks (~> 3.7.0)
+    rspec-core (3.7.1)
+      rspec-support (~> 3.7.0)
+    rspec-expectations (3.7.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.7.0)
+    rspec-mocks (3.7.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.7.0)
+    rspec-support (3.7.1)
+    safe_yaml (1.0.4)
+    symbolized (0.0.1)
+    webmock (3.3.0)
+      addressable (>= 2.3.6)
+      crack (>= 0.3.2)
+      hashdiff
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.16)
+  nanook!
+  rake (~> 10.0)
+  rspec (~> 3.2)
+  webmock (~> 3.3)
+
+BUNDLED WITH
+   1.16.0

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Luke Duncalfe
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,304 @@
+# 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/).
+
+[![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)
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'nanook'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install nanook
+
+# Getting Started
+
+## Initializing
+
+Nanook will by default connect to `http://localhost:7076`. If you're using Nanook from the nano node itself this will generally work fine.
+
+```ruby
+nanook = Nanook.new
+```
+
+To connect to another host instead:
+
+```ruby
+nanook = Nanook.new("http://example.com:7076")
+```
+
+## Basics
+
+### Working with wallets and accounts
+
+Create a wallet:
+
+```ruby
+Nanook.new.wallet.create
+```
+
+Create an account within a wallet:
+
+```ruby
+Nanook.new.wallet(wallet_id).account.create
+```
+
+List accounts within a wallet:
+
+```ruby
+Nanook.new.wallet(wallet_id).accounts
+```
+
+### Sending a payment
+
+You can send a payment from an account in a wallet:
+
+```ruby
+account = Nanook.new.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.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):
+
+> 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 1Mnano — see [What are Nano's Units](https://nano.org/en/faq#what-are-nano-units-)).
+
+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):
+
+> 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.
+
+### Receiving a payment
+
+The simplest way to receive a payment is:
+
+```ruby
+account = Nanook.new.wallet(wallet_id).account(account_id)
+account.receive
+
+# or:
+
+wallet = Nanook.new.wallet(wallet_id)
+wallet.receive(into: account_id)
+```
+
+The `receive` method when called as above will receive the latest pending payment for an account in a wallet. It will either return a RPC response containing the block if a payment was received, or `false` if there were no pending payments to receive.
+
+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.receive(block_id)
+
+# or:
+
+wallet = Nanook.new.wallet(wallet_id)
+wallet.receive(block_id, into: account_id)
+```
+
+## All commands
+
+### Wallets
+
+#### Create wallet:
+
+```ruby
+Nanook.new.wallet.create
+```
+
+#### Working with a single wallet:
+
+```ruby
+wallet = Nanook.new.wallet(wallet_id)
+
+wallet.export
+wallet.locked?
+wallet.unlock(password)
+wallet.change_password(password)
+
+wallet.balance
+wallet.balance(account_break_down: true)
+wallet.pay(from: your_account_id, to: recipient_account_id, amount: 0.2, id: unique_id)
+wallet.receive(into: account_id)
+wallet.receive(pending_block_id, into: account_id)
+
+wallet.account.create
+wallet.accounts
+wallet.contains?(account_id)
+
+wallet.destroy
+```
+### Accounts
+
+#### Create account:
+
+```ruby
+Nanook.new.wallet(wallet_id).account.create
+```
+
+#### Working with a single account:
+
+```ruby
+account = Nanook.new.wallet(wallet_id).account(account_id)
+
+account.exists?
+account.info
+account.ledger
+account.ledger(limit: 10)
+account.history
+account.history(limit: 1)
+account.public_key
+account.delegators
+account.representative
+account.weight
+
+account.balance
+account.pay(to: recipient_account_id, amount: 0.2, id: unique_id)
+account.pending
+account.pending(limit: 1)
+account.receive
+account.receive(pending_block_id)
+
+account.destroy
+```
+
+#### Working with any account (not necessarily in your wallet):
+
+```ruby
+account = Nanook.new.account(account_id)
+
+account.exists?
+account.info
+account.ledger
+account.ledger(limit: 10)
+account.history
+account.history(limit: 1)
+account.public_key
+account.delegators
+account.representative
+account.weight
+
+account.balance
+account.pending
+account.pending(limit: 1)
+```
+
+### Blocks
+
+```ruby
+block = Nanook.new.block(block_id)
+
+block.info                        # Verified blocks in the ledger
+block.info(allow_unchecked: true) # Verified blocks AND unchecked synchronizing blocks
+block.account
+block.chain
+block.chain(limit: 10)
+block.history
+block.history(limit: 10)
+block.republish
+block.republish(sources: 2)
+block.republish(destinations: 2)
+block.pending?
+block.process
+block.successors
+block.successors(limit: 10)
+
+block.generate_work
+block.cancel_work
+block.is_valid_work?(work_id)
+```
+
+### Managing your nano node
+
+```ruby
+node = Nanook.new.node
+
+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.stop
+node.version
+```
+
+### Work peers
+
+```ruby
+work_peers = Nanook.new.work_peers
+
+work_peers.add(address: "::ffff:172.17.0.1:7076", port: 7076)
+work_peers.clear
+work_peers.list
+```
+
+### Keys
+
+#### Create private public key pair:
+
+```ruby
+Nanook.new.key.generate
+Nanook.new.key.generate(seed: seed, index: 0)
+```
+
+#### Working with a single key
+
+```ruby
+key = Nanook.new.key(private_key)
+
+key.info
+```
+
+## 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.
+
+E.g., the [accounts_create command](https://github.com/nanocurrency/raiblocks/wiki/RPC-protocol#accounts-create) can be called like this:
+
+```ruby
+Nano.new.rpc(:accounts_create, wallet: wallet_id, count: 2)
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome. Pull requests with passing tests are even better.
+
+To run the test suite:
+
+    bundle exec rspec spec
+
+## 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!
+
+    xrb_3c3ek3k8135f6e8qtfy8eruk9q3yzmpebes7btzncccdest8ymzhjmnr196j
+
+![alt xrb_3c3ek3k8135f6e8qtfy8eruk9q3yzmpebes7btzncccdest8ymzhjmnr196j](https://raw.githubusercontent.com/lukes/nanook/master/img/qr.png)
+
+
+

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+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.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/nanook.rb

@@ -0,0 +1,46 @@
+require 'net/http'
+require 'uri'
+
+require 'nanook/account'
+require 'nanook/block'
+require 'nanook/error'
+require 'nanook/key'
+require 'nanook/node'
+require 'nanook/rpc'
+require 'nanook/util'
+require 'nanook/version'
+require 'nanook/wallet_account'
+require 'nanook/wallet'
+require 'nanook/work_peer'
+
+class Nanook
+
+  def initialize(uri=Nanook::Rpc::DEFAULT_URI, timeout:Nanook::Rpc::DEFAULT_URI)
+    @rpc = Nanook::Rpc.new(uri, timeout: timeout)
+  end
+
+  def account(account=nil)
+    Nanook::Account.new(account, @rpc)
+  end
+
+  def block(block=nil)
+    Nanook::Block.new(block, @rpc)
+  end
+
+  def key(key=nil)
+    Nanook::Key.new(key, @rpc)
+  end
+
+  def node
+    Nanook::Node.new(@rpc)
+  end
+
+  def wallet(wallet=nil)
+    Nanook::Wallet.new(wallet, @rpc)
+  end
+
+  def work_peers
+    Nanook::WorkPeer.new(@rpc)
+  end
+
+end

data/lib/nanook/account.rb

@@ -0,0 +1,74 @@
+class Nanook
+  class Account
+
+    def initialize(account, rpc)
+      @account = account
+      @rpc = rpc
+    end
+
+    def delegators
+      account_required!
+      rpc(:delegators)
+    end
+
+    def exists?
+      account_required!
+      response = rpc(:validate_account_number)
+      !response.empty? && response[:valid] == 1
+    end
+
+    def history(limit: 1000)
+      account_required!
+      rpc(:account_history, count: limit)
+    end
+
+    def public_key
+      account_required!
+      rpc(:account_key)
+    end
+
+    def representative
+      account_required!
+      rpc(:account_representative)
+    end
+
+    def balance
+      account_required!
+      rpc(:account_balance)
+    end
+
+    def info
+      account_required!
+      rpc(:account_info)
+    end
+
+    def ledger(limit: 1)
+      account_required!
+      rpc(:ledger, count: limit)
+    end
+
+    def pending(limit: 1000)
+      account_required!
+      rpc(:pending, count: limit)
+    end
+
+    def weight
+      account_required!
+      rpc(:account_weight)
+    end
+
+    private
+
+    def rpc(action, params={})
+      p = @account.nil? ? {} : { account: @account }
+      @rpc.call(action, p.merge(params))
+    end
+
+    def account_required!
+      if @account.nil?
+        raise ArgumentError.new("Account must be present")
+      end
+    end
+
+  end
+end

data/lib/nanook/block.rb

@@ -0,0 +1,97 @@
+class Nanook
+  class Block
+
+    def initialize(block, rpc)
+      @block = block
+      @rpc = rpc
+      block_required! # All methods expect a block
+    end
+
+    def account
+      rpc(:block_account, :hash)
+    end
+
+    def cancel_work
+      rpc(:work_cancel, :hash)
+    end
+
+    def chain(limit: 1000)
+      rpc(:chain, :block, count: limit)
+    end
+
+    def generate_work
+      rpc(:work_generate, :hash)
+    end
+
+    def history(limit: 1000)
+      rpc(:history, :hash, count: limit)
+    end
+
+    def info(allow_unchecked: false)
+      if allow_unchecked
+        # TODO not actually sure what this response looks like when it's not an unchecked block, assuming its blank
+        response = rpc(:unchecked_get, :hash)
+        return response unless response[:error] == "Block not found"
+        # Continue on falling backto checked block
+      end
+
+      response = rpc(:block, :hash)
+
+      # The contents is a stringified JSON
+      if response[:contents]
+        response[:contents] = JSON.parse(response[:contents])
+      end
+
+      response
+    end
+
+    def is_valid_work?(work)
+      response = rpc(:work_validate, :hash, work: work)
+      !response.empty? && response[:valid] == 1
+    end
+
+    def republish(destinations:nil, sources:nil)
+      if !destinations.nil? && !sources.nil?
+        raise ArgumentError.new("You must provide either destinations or sources but not both")
+      end
+
+      # Add in optional arguments
+      params = {}
+      params[:destinations] = destinations unless destinations.nil?
+      params[:sources] = sources unless sources.nil?
+      params[:count] = 1 unless params.empty?
+
+      rpc(:republish, :hash, params)
+    end
+
+    def pending?
+      response = rpc(:pending_exists, :hash)
+      !response.empty? && response[:exists] == 1
+    end
+
+    def process
+      rpc(:process, :block)
+    end
+
+    def successors(limit: 1000)
+      rpc(:successors, :block, count: limit)
+    end
+
+    private
+
+    # Some RPC calls expect the param that represents the block to be named
+    # "hash", and others "block".
+    # The param_name argument allows us to specify which it should be for this call.
+    def rpc(action, param_name, params={})
+      p = @block.nil? ? {} : { param_name.to_sym => @block }
+      @rpc.call(action, p.merge(params))
+    end
+
+    def block_required!
+      if @block.nil?
+        raise ArgumentError.new("Block must be present")
+      end
+    end
+
+  end
+end

data/lib/nanook/error.rb

@@ -0,0 +1,4 @@
+class Nanook
+  class Error < StandardError
+  end
+end

data/lib/nanook/key.rb

@@ -0,0 +1,38 @@
+class Nanook
+  class Key
+
+    def initialize(key=nil, rpc)
+      @key = key
+      @rpc = rpc
+    end
+
+    def generate(seed: nil, index: nil)
+      if seed.nil? && index.nil?
+        rpc(:key_create)
+      elsif !seed.nil? && !index.nil?
+        rpc(:deterministic_key, seed: seed, index: index)
+      else
+        raise ArgumentError.new("This method must be called with either seed AND index params given or no params")
+      end
+    end
+
+    def info
+      key_required!
+      rpc(:key_expand)
+    end
+
+    private
+
+    def rpc(action, params={})
+      p = @key.nil? ? {} : { key: @key }
+      @rpc.call(action, p.merge(params))
+    end
+
+    def key_required!
+      if @key.nil?
+        raise ArgumentError.new("Key must be present")
+      end
+    end
+
+  end
+end

data/lib/nanook/node.rb

@@ -0,0 +1,51 @@
+class Nanook
+  class Node
+
+    def initialize(rpc)
+      @rpc = rpc
+    end
+
+    def block_count
+      rpc(:block_count)
+    end
+
+    def block_count_type
+      rpc(:block_count_type)
+    end
+
+    def bootstrap(address:, port:)
+      rpc(:bootstrap, address: address, port: port)
+    end
+
+    def bootstrap_any
+      rpc(:bootstrap_any)
+    end
+
+    def frontier_count
+      rpc(:frontier_count)
+    end
+
+    def peers
+      rpc(:peers)
+    end
+
+    def representatives
+      rpc(:representatives)
+    end
+
+    def stop
+      rpc(:stop)
+    end
+
+    def version
+      rpc(:version)
+    end
+
+    private
+
+    def rpc(action, params={})
+      @rpc.call(action, params)
+    end
+
+  end
+end

data/lib/nanook/rpc.rb

@@ -0,0 +1,72 @@
+require 'json'
+require 'symbolized'
+
+require 'nanook/error'
+
+class Nanook
+  class Rpc
+
+    DEFAULT_URI = "http://localhost:7076"
+    DEFAULT_TIMEOUT = 500 # seconds
+
+    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}")
+      end
+
+      @http = Net::HTTP.new(rpc_server.host, 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"
+    end
+
+    def call(action, params={})
+      # Stringify param values
+      params = Hash[params.map {|k, v| [k, v.to_s] }]
+
+      @request.body = { action: action }.merge(params).to_json
+
+      response = @http.request(@request)
+
+      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
+    end
+
+    private
+
+    # Convert Strings of primitives to primitives
+    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]
+      end
+
+      Hash[new_hash].to_symbolized_hash
+    end
+
+    def parse_value(v)
+      return v.to_i if v.match(/^\d+\Z/)
+      return true if v == "true"
+      return false if v == "false"
+      v
+    end
+
+  end
+end

data/lib/nanook/util.rb

@@ -0,0 +1,9 @@
+class Nanook
+  class Util
+
+    def self.NANO_to_raw(nano)
+      nano * (10**30)
+    end
+
+  end
+end

data/lib/nanook/version.rb

@@ -0,0 +1,3 @@
+class Nanook
+  VERSION = "0.6.0"
+end

data/lib/nanook/wallet.rb

@@ -0,0 +1,92 @@
+class Nanook
+  class Wallet
+
+    def initialize(wallet, rpc)
+      @wallet = wallet
+      @rpc = rpc
+    end
+
+    def account(account=nil)
+      Nanook::WalletAccount.new(@wallet, account, @rpc)
+    end
+
+    def accounts
+      wallet_required!
+      rpc(:account_list)
+    end
+
+    def balance(account_break_down: false)
+      wallet_required!
+      if account_break_down
+        rpc(:wallet_balances)
+      else
+        rpc(:wallet_balance_total)
+      end
+    end
+
+    def create
+      rpc(:wallet_create)
+    end
+
+    def destroy
+      wallet_required!
+      rpc(:wallet_destroy)
+    end
+
+    def export
+      wallet_required!
+      rpc(:wallet_export)
+    end
+
+    def contains?(account)
+      wallet_required!
+      response = rpc(:wallet_contains, account: account)
+      !response.empty? && response[:exists] == 1
+    end
+
+    def pay(from:, to:, amount:, id:)
+      wallet_required!
+      account(from).pay(to: to, amount: amount, id: id)
+    end
+
+    def receive(block=nil, into:)
+      wallet_required!
+      account(into).receive(block)
+    end
+
+    def locked?
+      wallet_required!
+      response = rpc(:wallet_locked)
+      !response.empty? && response[:locked] != 0
+    end
+
+    def unlock(password)
+      wallet_required!
+      rpc(:password_enter, password: password)
+    end
+
+    def change_password(password)
+      wallet_required!
+      rpc(:password_change, password: password)
+    end
+
+    def all
+      wallet_required!
+      rpc(:account_list)
+    end
+
+    private
+
+    def rpc(action, params={})
+      p = @wallet.nil? ? {} : { wallet: @wallet }
+      @rpc.call(action, p.merge(params))
+    end
+
+    def wallet_required!
+      if @wallet.nil?
+        raise ArgumentError.new("Wallet must be present")
+      end
+    end
+
+  end
+end

data/lib/nanook/wallet_account.rb

@@ -0,0 +1,104 @@
+class Nanook
+  class WalletAccount
+
+    def initialize(wallet, account, rpc)
+      @wallet = wallet
+      @account = account
+      @rpc = rpc
+
+      # An object to delegate account methods that don't
+      # expect a wallet param in the RPC call, to allow this
+      # class to support all methods that can be called on Nanook::Account
+      @nanook_account_instance = Nanook::Account.new(account, rpc)
+    end
+
+    def create
+      wallet_required!
+      rpc(:account_create)
+    end
+
+    def destroy
+      wallet_required!
+      account_required!
+      rpc(:account_remove)
+    end
+
+    def pay(to:, amount:, id:)
+      wallet_required!
+      account_required!
+
+      raw = Nanook::Util.NANO_to_raw(amount)
+
+      # account is called source, so don't use the normal rpc method
+      p = {
+        wallet: @wallet,
+        source: @account,
+        destination: to,
+        amount: raw,
+        id: id
+      }
+
+      @rpc.call(:send, p)
+    end
+
+    def receive(block=nil)
+      wallet_required!
+      account_required!
+
+      if block.nil?
+        _receive_without_block
+      else
+        _receive_with_block(block)
+      end
+    end
+
+    # Any method of Nanook::Account can be called on this class too
+    def method_missing(m, *args, &block)
+      if @nanook_account_instance.respond_to?(m)
+        @nanook_account_instance.send(m, *args, &block)
+      else
+        super(m, *args, &block)
+      end
+    end
+
+    private
+
+    def _receive_without_block
+      # Discover the first pending block
+      pending_blocks = @rpc.call(:pending, { account: @account, count: 1 })
+
+      if pending_blocks[:blocks].empty?
+        return false
+      end
+
+      # Then call receive_with_block as normal
+      block = pending_blocks[:blocks][0]
+      _receive_with_block(block)
+    end
+
+    def _receive_with_block(block)
+      rpc(:receive, block: block)
+    end
+
+    def rpc(action, params={})
+      p = {}
+      p[:wallet] = @wallet unless @wallet.nil?
+      p[:account] = @account unless @account.nil?
+
+      @rpc.call(action, p.merge(params))
+    end
+
+    def wallet_required!
+      if @wallet.nil?
+        raise ArgumentError.new("Wallet must be present")
+      end
+    end
+
+    def account_required!
+      if @account.nil?
+        raise ArgumentError.new("Account must be present")
+      end
+    end
+
+  end
+end

data/lib/nanook/work_peer.rb

@@ -0,0 +1,27 @@
+class Nanook
+  class WorkPeer
+
+    def initialize(rpc)
+      @rpc = rpc
+    end
+
+    def add(address:, port:)
+      rpc(:work_peer_add, address: address, port: port)
+    end
+
+    def clear
+      rpc(:work_peers_clear)
+    end
+
+    def list
+      rpc(:work_peers)
+    end
+
+    private
+
+    def rpc(action, params={})
+      @rpc.call(action, params)
+    end
+
+  end
+end

data/nanook.gemspec

@@ -0,0 +1,30 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "nanook/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "nanook"
+  spec.version       = Nanook::VERSION
+  spec.authors       = ["Luke Duncalfe"]
+  spec.email         = ["lduncalfe@eml.cc"]
+
+  spec.summary       = "Ruby library for managing a nano currency node, including making and receiving payments, using the nano RPC protocol"
+  spec.description   = "Ruby library for managing a nano currency node, including making and receiving payments, using the nano RPC protocol"
+  spec.homepage      = "https://github.com/lukes/nanook"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.16"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.2"
+  spec.add_development_dependency "webmock", "~> 3.3"
+
+  spec.add_dependency "symbolized"
+end

metadata

@@ -0,0 +1,139 @@
+--- !ruby/object:Gem::Specification
+name: nanook
+version: !ruby/object:Gem::Version
+  version: 0.6.0
+platform: ruby
+authors:
+- Luke Duncalfe
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2018-03-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+- !ruby/object:Gem::Dependency
+  name: symbolized
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Ruby library for managing a nano currency node, including making and
+  receiving payments, using the nano RPC protocol
+email:
+- lduncalfe@eml.cc
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".circleci/config.yml"
+- ".gitignore"
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- img/qr.png
+- lib/nanook.rb
+- lib/nanook/account.rb
+- lib/nanook/block.rb
+- lib/nanook/error.rb
+- lib/nanook/key.rb
+- lib/nanook/node.rb
+- lib/nanook/rpc.rb
+- lib/nanook/util.rb
+- lib/nanook/version.rb
+- lib/nanook/wallet.rb
+- lib/nanook/wallet_account.rb
+- lib/nanook/work_peer.rb
+- nanook.gemspec
+homepage: https://github.com/lukes/nanook
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Ruby library for managing a nano currency node, including making and receiving
+  payments, using the nano RPC protocol
+test_files: []