nanook 2.5.0 → 4.0.0

data/lib/nanook/private_key.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require_relative 'util'
+
+class Nanook
+  # The <tt>Nanook::PrivateKey</tt> class lets you manage your node's keys.
+  class PrivateKey
+    include Nanook::Util
+
+    def initialize(rpc, key = nil)
+      @rpc = rpc
+      @key = key.to_s if key
+    end
+
+    def id
+      @key
+    end
+
+    # @param other [Nanook::PrivateKey] private key to compare
+    # @return [Boolean] true if keys are equal
+    def ==(other)
+      other.class == self.class &&
+        other.id == id
+    end
+    alias eql? ==
+
+    # The hash value is used along with #eql? by the Hash class to determine if two objects
+    # reference the same hash key.
+    #
+    # @return [Integer]
+    def hash
+      id.hash
+    end
+
+    # Generate a new private public key pair. Returns the new {Nanook::PrivateKey}.
+    # The public key can be retrieved by calling `#public_key` on the private key.
+    #
+    # ==== Examples:
+    #
+    #   private_key = nanook.private_key.create
+    #   private_key.public_key # => Nanook::PublicKey pair for the private key
+    #
+    #   deterministic_private_key = nanook.private_key.create(seed: seed, index: 0)
+    #
+    # @param seed [String] optional seed to generate a deterministic private key.
+    # @param index [Integer] optional (but required if +seed+ is given) index to generate a deterministic private key.
+    # @return Nanook::PrivateKey
+    def create(seed: nil, index: nil)
+      skip_key_required!
+
+      params = {
+        _access: :private,
+        _coerce: Hash
+      }
+
+      @key = if seed.nil?
+               rpc(:key_create, params)
+             else
+               raise ArgumentError, 'index argument is required when seed is given' if index.nil?
+
+               rpc(:deterministic_key, params.merge(seed: seed, index: index))
+             end
+
+      self
+    end
+
+    # Returns the {Nanook::Account} that matches this private key. The
+    # account may not exist yet in the ledger.
+    #
+    # @return Nanook::Account
+    def account
+      as_account(memoized_key_expand[:account])
+    end
+
+    # Returns the {Nanook::PublicKey} pair for this private key.
+    #
+    # @return Nanook::PublicKey
+    def public_key
+      as_public_key(memoized_key_expand[:public])
+    end
+
+    # @return [String]
+    def to_s
+      "#{self.class.name}(id: \"#{short_id}\")"
+    end
+    alias inspect to_s
+
+    private
+
+    def memoized_key_expand
+      @memoized_key_expand ||= rpc(:key_expand, _coerce: Hash)
+    end
+
+    def rpc(action, params = {})
+      check_key_required!
+
+      p = { key: @key }.compact
+      @rpc.call(action, p.merge(params)).tap { reset_skip_key_required! }
+    end
+
+    def skip_key_required!
+      @skip_key_required_check = true
+    end
+
+    def reset_skip_key_required!
+      @skip_key_required_check = false
+    end
+
+    def check_key_required!
+      return if @key || @skip_key_required_check
+
+      raise ArgumentError, 'Key must be present'
+    end
+  end
+end

data/lib/nanook/public_key.rb

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

data/lib/nanook/rpc.rb

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

data/lib/nanook/util.rb

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