nanocurrency 0.1.0

data/lib/nano/account.rb

@@ -0,0 +1,59 @@
+module Nano
+  ##
+  # The Account class is used to simplify conversion from account to
+  # public key
+  class Account
+
+    # @return [String] The base32 encoded account address
+    attr_reader :address
+
+    # @return [String] The public key for the account encoded in hexadecimal
+    attr_reader :public_key
+
+    ##
+    # The Account intiailizer.
+    # @param value [Hash] This hash can contain the keys `:account` and
+    #   `:public_key` which will be stored within the object
+    def initialize(val)
+      if val[:address]
+        @address = val[:address]
+      end
+
+      if val[:public_key]
+        @public_key = val[:public_key]
+      end
+    end
+
+    ##
+    # A class initializer to create an Account object from the account
+    # base32 address.
+    #
+    # @param input [String] The base32 account address
+    #
+    # @return [Account] Returns a created account given a valid account address
+    def self.from_address(input)
+      return nil unless input.is_a? String
+
+      prefix_length = nil
+
+      if input.start_with? "nano_"
+        prefix_length = 5
+      elsif input.start_with? "xrb_"
+        prefix_length = 4
+      end
+
+      return nil if prefix_length.nil?
+
+      public_key_bytes = Nano::Base32.decode(input[prefix_length, 52])
+      checksum = Nano::Base32.decode(input[(prefix_length + 52)..-1])
+      public_key_bin = Nano::Utils.hex_to_bin public_key_bytes
+      computed_check = Blake2b.hex(
+        public_key_bin, Blake2b::Key.none, 5
+      ).reverse.upcase
+
+      return nil if computed_check == checksum
+
+      Account.new(:address => input, :public_key => public_key_bytes)
+    end
+  end
+end

data/lib/nano/base32.rb

@@ -0,0 +1,87 @@
+require_relative './utils'
+
+module Nano
+  ##
+  # This module performs encoding and decoding of Base32 as specified by
+  # the Nano protocol.
+  module Base32
+    extend self
+
+    ##
+    # The Base32 alphabet of characters.
+    ALPHABET = "13456789abcdefghijkmnopqrstuwxyz".freeze
+
+    ##
+    # Encode an array of bytes into Base32 string.
+    #
+    # @param bytes [Array<Int8>] The byte array to encode.
+    # 
+    # @return [String] The base32 encoded representation of the bytes
+    def encode(bytes)
+      length = bytes.length
+      leftover = (length * 8) % 5
+      offset = leftover == 0 ? 0 : 5 - leftover
+      value = 0
+      output = ""
+      bits = 0
+
+      length.times do |i|
+        value = (value << 8) | bytes[i]
+        bits += 8
+
+        while bits >= 5
+          output += ALPHABET[(value >> bits + offset - 5) & 31]
+          bits -= 5
+        end
+      end
+
+      if bits > 0
+        output += ALPHABET[(value << (5 - (bits + offset))) & 31]
+      end
+
+      output
+    end
+
+    ##
+    # Decodes a Base32 encoded string into a hex string
+    #
+    # @param str [String] The base32 encoded string
+    #
+    # @returns [String] The hexadecimal decoded base32 string
+    def decode(str)
+      length = str.length
+      leftover = (length * 5) % 8
+      offset = leftover == 0 ? 0 : 8 - leftover
+
+      bits = 0
+      value = 0
+
+      output = Array.new
+
+      length.times do |i|
+        value = (value << 5) | read_char(str[i])
+        bits += 5
+
+        if bits >= 8
+          output.push((value >> (bits + offset - 8)) & 255)
+          bits -= 8
+        end
+      end
+
+      if bits > 0
+        output.push((value << (bits + offset - 8)) & 255)
+      end
+
+      output = output.drop(1) unless leftover == 0
+      Nano::Utils.bytes_to_hex(output)
+    end
+
+    def read_char(chr)
+      idx = ALPHABET.index(chr)
+      raise ArgumentError, "Character #{chr} not base32 compliant" if idx.nil? 
+      idx
+    end
+
+    module_function :read_char
+  end
+end

data/lib/nano/block.rb

@@ -0,0 +1,142 @@
+require_relative "./hash"
+require_relative "./work"
+require_relative "./check"
+require "nanocurrency_ext"
+
+module Nano
+  ##
+  # A class representing a state block in the Nano network.
+  # Can be initialized as an existing block, with a work and signature
+  # or as an incomplete block.
+  class Block
+
+    # @return [String] The type of the block, locked to 'state' currently
+    attr_reader :type
+
+    # @return [String] The account associated with the block.
+    attr_reader :account
+
+    # @return [String] The account representative as set by the block
+    attr_reader :representative
+
+    # @return [String] The previous block to this block
+    attr_reader :previous
+
+    # @return [String] The link for this block
+    attr_reader :link
+
+    # @return [String] The balance for the account at this block
+    attr_reader :balance
+
+    # @return [String?] The proof of work computed for this block
+    attr_reader :work
+
+    # @return [String?] The signature for the block
+    attr_reader :signature
+
+    ##
+    # The block initializer, requires certain parameters to be valid.
+    # @param params [Hash] The block parameters to construct the block with.
+    #   `:previous` - The previous block hash as a string
+    #   `:account` - The associated account address as a string
+    #   `:representative` - The account representative as a string
+    #   `:balance` - The account balance after this block in raw unit
+    #   `:link` - The link hash associated with this block.
+    #   `:work` - The proof of work for the block (optional)
+    #   `:signature` - The signature for this block (optional)
+    def initialize(params)
+      @type = "state"
+
+      @previous = params[:previous]
+
+      raise ArgumentError, "Missing data for previous" if @previous.nil?
+      raise(
+        ArgumentError, "Invalid previous hash #{@previous}"
+      ) unless Nano::Check.is_valid_hash? @previous
+
+      @account = params[:account]
+      raise ArgumentError, "Missing data for account" if @account.nil?
+      raise(
+        ArgumentError, "Invalid account #{@account}"
+      ) unless Nano::Check.is_valid_account? @account
+
+      @representative = params[:representative]
+      raise(
+        ArgumentError, "Missing data for representative"
+      ) if @representative.nil?
+      raise(
+        ArgumentError, "Invalid representative #{@representative}"
+      ) unless Nano::Check.is_valid_account? @representative
+
+      @balance = params[:balance]
+      raise(
+        ArgumentError, "Missing data for balance"
+      ) if @balance.nil?
+      raise(
+        ArgumentError, "Invalid balance #{@balance}"
+      ) unless Nano::Check.is_balance_valid? @balance
+
+      @link = params[:link]
+      raise(
+        ArgumentError, "Missing data for link"
+      ) if @link.nil?
+      raise(
+        ArgumentError, "Invalid link #{@link}"
+      ) unless Nano::Check.is_hash_valid? @link
+
+      @work = params[:work]
+      @signature = params[:signature]
+    end
+
+    # @return The link for the account converted to an address. 
+    #   May not be valid in the case the link is a block hash
+    def link_as_account
+      Nano::Key.derive_address(@link)
+    end
+
+    ##
+    # This method signs the block using the secret key given. This method
+    # will fail if the key is incorrect. If this method succeeds, the block
+    # may still be invalid if the key does not belong to the block account.
+    # This method modifies the block's existing signature.
+    #
+    # @param secret_key [String] The hexidecimal representation of the 
+    #   secret key. Should match the account but does not perform a check,
+    #   currently.
+    #
+    # @return [String] Returns the signature for the block, whilst also
+    #   setting the signature internally.
+    def sign!(secret_key)
+      throw ArgumentError, "Invalid key" unless Nano::Check.is_key?(secret_key)
+
+      hash_bin = Nano::Utils.hex_to_bin(hash)
+      secret_bin = Nano::Utils.hex_to_bin(secret_key)
+
+      @signature = Nano::Utils.bin_to_hex(
+        NanocurrencyExt.sign(hash_bin, secret_bin)
+      ).upcase
+
+      @signature
+    end
+
+    ##
+    # Computes the proof of work for the block, setting the internal work
+    # value and overwriting the existing value. The method uses a native
+    # extension to improve the performance.
+    #
+    # @return [String] The computed work value, also setting it internally.
+    def compute_work!
+      base_prev = "".rjust(64, "0")
+      is_first = previous == base_prev
+      hash = is_first ? Nano::Key.derive_public_key(@account) : previous
+      @work = Nano::Work.compute_work(hash)
+      @work
+    end
+
+    ##
+    # @return [String] The computed hash for the block.
+    def hash
+      Nano::Hash.hash_block(self)
+    end
+  end
+end

data/lib/nano/check.rb

@@ -0,0 +1,65 @@
+module Nano
+  ##
+  # The Check module contains some basic sanity and type checks to ensure
+  # robustness throughout the Gem.
+  module Check
+
+    MIN_INDEX = 0
+    MAX_INDEX = 2 ** 32 - 1
+
+    extend self
+
+    def is_valid_hex?(value)
+      value.is_a?(String) && value.match?(/^[0-9a-fA-F]{32}$/)
+    end
+
+    def is_valid_hash?(value)
+      is_hash_valid?(value)
+    end
+
+    def is_hex_valid?(value)
+      is_valid_hex?(value)
+    end
+
+    def is_numerical?(value)
+      return false unless value.is_a?(String)
+      return false if value.start_with?(".")
+      return false if value.end_with?(".")
+
+      number_without_dot = value.sub(".", "")
+
+      # More than one '.' in the number.
+      return false unless number_without_dot.count(".") == 0
+
+      is_balance_valid?(number_without_dot)
+    end
+
+    def is_balance_valid?(value)
+      value.match?(/^[0-9]*$/)
+    end
+
+    def is_seed_valid?(seed)
+      seed.is_a?(String) && seed.match?(/^[0-9a-fA-F]{64}$/)
+    end
+
+    def is_index_valid?(index)
+      index.is_a?(Integer) && index >= MIN_INDEX && index <= MAX_INDEX
+    end
+
+    def is_key?(input)
+      input.is_a?(String) && input.match?(/^[0-9a-fA-F]{64}$/)
+    end
+
+    def is_hash_valid?(hash)
+      is_seed_valid?(hash)
+    end
+
+    def is_work_valid?(input)
+      input.is_a?(String) && input.match?(/^[0-9a-fA-F]{16}$/)
+    end
+
+    def is_valid_account?(input)
+      !Nano::Account.from_address(input).nil?
+    end
+  end
+end

data/lib/nano/conversion.rb

@@ -0,0 +1,102 @@
+require "set"
+require "bigdecimal"
+require_relative "./check"
+
+module Nano
+
+  ##
+  # The Unit module provides utilities to allow conversion for the different
+  # unit types referenced in the Nano protocol.
+  module Unit
+    extend self
+
+    # A set of unit symbols found in the Nano protocol.
+    UNIT_SET = [
+      :hex, :raw, :nano, :knano, :Nano, :NANO, :KNano, :MNano
+    ].to_set.freeze
+
+    # A hash of the unit types and number of zeros the unit is offset by.
+    UNIT_ZEROS = {
+      :hex => 0,
+      :raw => 0,
+      :nano => 20,
+      :knano => 24,
+      :Nano => 30,
+      :NANO => 30,
+      :KNano => 33,
+      :MNano => 36
+    }.freeze
+
+    ##
+    # @return [Boolean] True if the unit is contained within the unit set.
+    def valid_unit?(unit)
+      UNIT_SET === unit
+    end
+
+    ##
+    # Converts the value in a unit type into another representation
+    #
+    # @param value [String] A number string of the value in the base unit
+    # @param from [Symbol] A valid unit which denotes the base unit
+    # @param to [Symbol] The unit type to convert the value into.
+    # @return [String] The converted value as the unit from to
+    def convert(value, from, to)
+      raise ArgumentError, "Invalid from unit type" unless Unit.valid_unit?(from)
+      raise ArgumentError, "Invalid to unit type" unless Unit.valid_unit?(to)
+
+      from_zeros = zeros_for_unit(from)
+      to_zeros = zeros_for_unit(to)
+
+      raise ArgumentError, "Value must be a string" unless value.is_a? String
+
+      if from == :hex
+        is_hex = Nano::Check.is_valid_hex? value
+        raise ArgumentError, "Invalid hex value string" unless is_hex
+      else
+        is_number = Nano::Check.is_numerical? value
+        raise ArgumentError, "Invalid number value string" unless is_number
+      end
+
+      zero_difference = from_zeros - to_zeros
+
+      big_number = 0
+      if from == :hex
+        big_number = BigDecimal.new(value.to_i(16))
+      else
+        big_number = BigDecimal.new(value)
+      end
+
+      is_increase = zero_difference > 0
+      zero_difference.abs.times do |i|
+        if is_increase
+          big_number = big_number * 10
+        else
+          big_number = big_number / 10
+        end
+      end
+
+      if to == :hex
+        big_number.to_i.to_s(16).rjust(32, "0")
+      else
+        if big_number.to_i == big_number
+          big_number.to_i.to_s
+        else
+          big_number.to_s("F")
+        end
+      end
+    end
+
+
+    # @return [Hash] The unit zeros constant
+    def unit_zeros
+      UNIT_ZEROS
+    end
+
+    # @param [Symbol] The unit type
+    # @return [Integer] The number of zeros for a unit type
+    def zeros_for_unit(unit)
+      raise ArgumentError, "Invalid unit" unless valid_unit? unit
+      UNIT_ZEROS[unit]
+    end
+  end
+end