nem-ruby 0.0.1

data/examples/transaction/multisig_transfer.rb

@@ -0,0 +1,35 @@
+require 'pp'
+require 'nem'
+
+# Library configuration
+Nem.configure do |conf|
+  # conf.logger = Logger.new('./nem-ruby.log')
+  # conf.logger.level = Logger::DEBUG
+  # you can set deadline(sec)
+  # conf.deadline = 7200
+  # set :mainnet if you'd like to use on mainnet!
+  # conf.default_network = :mainnet # use on mainnet!
+end
+
+# multisig
+M_PUBLIC_KEY  = '6d72b57d2bc199d328e7ea3e24775f7f614760bc18f3f8501cd3daa9870cc40c'
+
+# cosignatory
+A_PRIVATE_KEY = '4ce5c8f9fce571db0d9ac1adf00b8d3ba0f078ed40835fd3d730a2f24b834214'
+
+# recipient
+B_ADDRESS = 'TA4TX6U5HG2MROAESH2JE5524T4ZOY2EQKQ6ELHF'
+
+kp = Nem::Keypair.new(A_PRIVATE_KEY)
+node = Nem::Node.new
+tx_endpoint = Nem::Endpoint::Transaction.new(node)
+
+ttx = Nem::Transaction::Transfer.new(B_ADDRESS, 1, 'Good luck!')
+tx = Nem::Transaction::Multisig.new(ttx, M_PUBLIC_KEY)
+pp "Fee: #{tx.fee.to_i}"
+
+req = Nem::Request::Announce.new(tx, kp)
+res = tx_endpoint.prepare_announce(req)
+
+pp "Message: #{res.message}"
+pp "TransactionHash: #{res.transaction_hash}"

data/examples/transaction/provision_namespace.rb

@@ -0,0 +1,20 @@
+require 'pp'
+require 'nem'
+
+Nem.logger.level = Logger::DEBUG
+
+# namespace creator
+A_PRIVATE_KEY = '4ce5c8f9fce571db0d9ac1adf00b8d3ba0f078ed40835fd3d730a2f24b834214'
+
+kp = Nem::Keypair.new(A_PRIVATE_KEY)
+node = Nem::Node.new(host: '104.128.226.60')
+tx_endpoint = Nem::Endpoint::Transaction.new(node)
+
+tx = Nem::Transaction::ProvisionNamespace.new('sushi')
+pp "Fee: #{tx.fee.to_i}"
+
+req = Nem::Request::Announce.new(tx, kp)
+res = tx_endpoint.announce(req)
+
+pp "Message: #{res.message}"
+pp "TransactionHash: #{res.transaction_hash}"

data/examples/transaction/transfer.rb

@@ -0,0 +1,32 @@
+require 'pp'
+require 'nem'
+
+# Library configuration
+Nem.configure do |conf|
+  conf.logger = Logger.new('./nem-ruby.log')
+  conf.logger.level = Logger::DEBUG
+  # you can set deadline(sec)
+  # conf.deadline = 7200
+  # set :mainnet if you'd like to use on mainnet!
+  # conf.default_network = :mainnet # use on mainnet!
+end
+
+# sender
+A_PRIVATE_KEY = '4ce5c8f9fce571db0d9ac1adf00b8d3ba0f078ed40835fd3d730a2f24b834214'
+
+# recipient
+B_ADDRESS = 'TA4TX6U5HG2MROAESH2JE5524T4ZOY2EQKQ6ELHF'
+
+kp = Nem::Keypair.new(A_PRIVATE_KEY)
+node = Nem::Node.new(host: '104.128.226.60')
+tx_endpoint = Nem::Endpoint::Transaction.new(node)
+
+# with plain message
+tx = Nem::Transaction::Transfer.new(B_ADDRESS, 1, 'Good luck!')
+pp "Fee: #{tx.fee.to_i}"
+
+req = Nem::Request::Announce.new(tx, kp)
+res = tx_endpoint.announce(req)
+
+pp "Message: #{res.message}"
+pp "TransactionHash: #{res.transaction_hash}"

data/examples/transaction/transfer_mosaic.rb

@@ -0,0 +1,72 @@
+require 'pp'
+require 'nem'
+
+Nem.logger.level = Logger::DEBUG
+
+# sender
+A_PRIVATE_KEY = '4ce5c8f9fce571db0d9ac1adf00b8d3ba0f078ed40835fd3d730a2f24b834214'
+
+# recipient
+B_ADDRESS = 'TA4TX6U5HG2MROAESH2JE5524T4ZOY2EQKQ6ELHF'
+
+kp = Nem::Keypair.new(A_PRIVATE_KEY)
+node = Nem::Node.new(host: '104.128.226.60')
+tx_endpoint = Nem::Endpoint::Transaction.new(node)
+# ns_endpoint = Nem::Endpoint::Namespace.new(node)
+
+# TODO:
+
+# fetch mosaic definition
+# mo_dmdps = ns_endpoint.mosaic_definition('kon')
+# mo_def = mo_dmdps.first.mosaic
+
+# define custom mosaic attachment
+# class MyMosaic < Nem::Model::MosaicAttachment
+#   def initialize(quantity)
+#     # set values what you defined
+#     mosaic_id = Nem::Model::MosaicId.new(
+#       namespace_id: 'my',
+#       name: 'mosaic'
+#     )
+#     # set values what you defined
+#     properties = Nem::Model::MosaicProperties.new(
+#       divisibility: 3,
+#       initial_supply: 123_456_789
+#     )
+#     super(
+#       mosaic_id: mosaic_id,
+#       properties: properties,
+#       quantity: quantity
+#     )
+#   end
+# end
+
+# define custom mosaic attachment
+class KonHeart < Nem::Model::MosaicAttachment
+  def initialize(quantity)
+    mosaic_id = Nem::Model::MosaicId.new(
+      namespace_id: 'kon',
+      name: 'heart'
+    )
+    properties = Nem::Model::MosaicProperties.new(
+      divisibility: 3,
+      initial_supply: 100_000_000
+    )
+    super(
+      mosaic_id: mosaic_id,
+      properties: properties,
+      quantity: quantity
+    )
+  end
+end
+
+tx = Nem::Transaction::Transfer.new(B_ADDRESS, 1, 'Good luck!')
+tx.mosaics << Nem::Mosaic::Xem.new(1)
+tx.mosaics << KonHeart.new(1)
+pp "Fee: #{tx.fee.to_i}"
+
+req = Nem::Request::Announce.new(tx, kp)
+res = tx_endpoint.announce(req)
+
+pp "Message: #{res.message}"
+pp "TransactionHash: #{res.transaction_hash}"

data/examples/transaction/transfer_with_encrypted_message.rb

@@ -0,0 +1,40 @@
+require 'pp'
+require 'nem'
+
+# Library configuration
+Nem.configure do |conf|
+  conf.logger = Logger.new('./nem-ruby.log')
+  conf.logger.level = Logger::DEBUG
+  # you can set deadline(sec)
+  # conf.deadline = 7200
+  # set :mainnet if you'd like to use on mainnet!
+  # conf.default_network = :mainnet
+end
+
+# sender
+A_PRIVATE_KEY = '4ce5c8f9fce571db0d9ac1adf00b8d3ba0f078ed40835fd3d730a2f24b834214'
+
+# recipient
+B_ADDRESS = 'TA4TX6U5HG2MROAESH2JE5524T4ZOY2EQKQ6ELHF'
+B_PUBLIC_KEY = '9e7ab2924cd1a3482df784db190614cfc8a33671f5d80a5b15a9c9e8b4d13933'
+
+kp = Nem::Keypair.new(A_PRIVATE_KEY)
+node = Nem::Node.new(host: '104.128.226.60')
+tx_endpoint = Nem::Endpoint::Transaction.new(node)
+
+# with encrypted message
+message = Nem::Model::Message.new('Good luck!',
+  type: :encrypted,
+  private_key: kp.private,
+  public_key: B_PUBLIC_KEY
+)
+message.encrypt!
+
+tx = Nem::Transaction::Transfer.new(B_ADDRESS, 1, message, {})
+pp "Fee: #{tx.fee.to_i}"
+
+req = Nem::Request::Announce.new(tx, kp)
+res = tx_endpoint.announce(req)
+
+pp "Message: #{res.message}"
+pp "TransactionHash: #{res.transaction_hash}"

data/examples/transaction/transfer_with_local.rb

@@ -0,0 +1,34 @@
+require 'pp'
+require 'nem'
+
+# Library configuration
+Nem.configure do |conf|
+  conf.logger = Logger.new('./nem-ruby.log')
+  conf.logger.level = Logger::DEBUG
+  # you can set deadline(sec)
+  # conf.deadline = 7200
+  # set :mainnet if you'd like to use on mainnet!
+  # conf.default_network = :mainnet # use on mainnet!
+end
+
+# sender
+A_PRIVATE_KEY = '4ce5c8f9fce571db0d9ac1adf00b8d3ba0f078ed40835fd3d730a2f24b834214'
+
+# recipient
+B_ADDRESS = 'TA4TX6U5HG2MROAESH2JE5524T4ZOY2EQKQ6ELHF'
+
+kp = Nem::Keypair.new(A_PRIVATE_KEY)
+# connect localhost if no params
+node = Nem::Node.new
+tx_endpoint = Nem::Endpoint::Transaction.new(node)
+
+# with plain message
+tx = Nem::Transaction::Transfer.new(B_ADDRESS, 1, 'Good luck!')
+pp "Fee: #{tx.fee.to_i}"
+
+req = Nem::Request::Announce.new(tx, kp)
+# use #prepare method for local node without signature
+res = tx_endpoint.prepare_announce(req)
+
+pp "Message: #{res.message}"
+pp "TransactionHash: #{res.transaction_hash}"

data/lib/nem.rb

@@ -0,0 +1,21 @@
+require 'nem/version'
+require 'nem/error'
+require 'nem/configuration'
+require 'nem/util'
+require 'nem/fee'
+require 'nem/mixin'
+require 'nem/transaction'
+require 'nem/request'
+require 'nem/endpoint'
+require 'nem/model'
+require 'nem/keypair'
+require 'nem/node'
+require 'nem/node_pool'
+require 'nem/client'
+require 'nem/apostille'
+require 'nem/apostille_audit'
+require 'nem/mosaic'
+
+module Nem
+  extend Nem::Configuration
+end

data/lib/nem/apostille.rb

@@ -0,0 +1,104 @@
+require 'digest/md5'
+require 'digest/sha1'
+require 'digest/sha2'
+require 'digest/sha3'
+
+class Nem::Apostille
+  CHECKSUM = 'fe4e5459'.freeze
+
+  # @param [Nem::Keypair] keypair
+  # @param [string] file - The file
+  # @param [symbol] hashing - An hashing type (md5, sha1, sha256, sha3-256, sha3-512)
+  # @param [boolean] multisig - true if transaction is multisig, false otherwise
+  # @param [boolean] private - true if apostille is private / transferable / updateable, false if public
+  def initialize(keypair, file, hashing = :sha256, multisig: false, private: false, network: nil)
+    @keypair = keypair
+    @file = file
+    @hashing = hashing
+    @multisig = multisig
+    @private = private
+    @network = network || Nem.default_network
+  end
+
+  def private?
+    @private
+  end
+
+  def multisig?
+    @multisig
+  end
+
+  def transaction
+    if private?
+      raise 'Not implemented private apostille.'
+    else
+      dedicated_address = apostille[:sink]
+      apostille_hash = calc_hash
+    end
+
+    Nem::Transaction::Transfer.new(dedicated_address, 0, apostille_hash)
+  end
+
+  def apostille_format(transaction_hash)
+    ext = File.extname(@file.path)
+    name = File.basename(@file.path, ext)
+    date = Date.today.strftime('%Y-%m-%d')
+    '%s -- Apostille TX %s -- Date %s%s' % [
+      name,
+      transaction_hash,
+      date,
+      ext
+    ]
+  end
+
+  private
+
+  def calc_hash
+    checksum = "#{CHECKSUM}#{hex_type}"
+    hashed = case @hashing
+             when /\Amd5\z/      then Digest::MD5.file(@file)
+             when /\Asha1\z/     then Digest::SHA1.file(@file)
+             when /\Asha256\z/   then Digest::SHA256.file(@file)
+             when /\Asha3-256\z/ then Digest::SHA3.file(@file, 256)
+      else Digest::SHA3.file(@file, 512)
+    end
+    checksum << hashed.hexdigest
+  end
+
+  def algo
+    case @hashing
+    when /\Amd5\z/      then 0x01
+    when /\Asha1\z/     then 0x02
+    when /\Asha256\z/   then 0x03
+    when /\Asha3-256\z/ then 0x08
+    when /\Asha3-512\z/ then 0x09
+      else raise "Undefined hashing: #{@hashing}"
+    end
+  end
+
+  def version
+    private? ? 0x80 : 0x00
+  end
+
+  def hex_type
+    '%02x' % (algo | version)
+  end
+
+  def apostille
+    if @network == :mainnet
+      if private?
+        raise 'Not implemented private apostille.'
+      else
+        { private_key: nil,
+          sink: 'NCZSJHLTIMESERVBVKOW6US64YDZG2PFGQCSV23J' }
+      end
+    else
+      if private?
+        raise 'Not implemented private apostille.'
+      else
+        { private_key: nil,
+          sink: 'TC7MCY5AGJQXZQ4BN3BOPNXUVIGDJCOHBPGUM2GE' }
+      end
+    end
+  end
+end

data/lib/nem/apostille_audit.rb

@@ -0,0 +1,47 @@
+require 'digest/md5'
+require 'digest/sha1'
+require 'digest/sha2'
+require 'digest/sha3'
+
+class Nem::ApostilleAudit
+  CHECKSUM = 'fe4e5459'.freeze
+
+  # @param [File] file
+  # @param [apostille_hash] Apostille formatted hash
+  def initialize(file, apostille_hash)
+    @file = file
+    @apostille_hash = apostille_hash
+    @checksum, @version, @algo, @hash = split_apostille_hash
+  end
+
+  def valid?
+    raise 'Not implemented private apostille' if private?
+    raise "Invalid checksum: #{@checksum}" unless @checksum == CHECKSUM
+    @hash == calc_hash
+  end
+
+  def private?
+    @version == 0x80
+  end
+
+  def split_apostille_hash
+    [ @apostille_hash[0, 8],
+      @apostille_hash[8, 1].to_i,
+      @apostille_hash[9, 1].to_i,
+      @apostille_hash[10, @apostille_hash.size] ]
+  end
+
+  private
+
+  def calc_hash
+    hashed = case @algo
+             when 0x01 then Digest::MD5.file(@file)
+             when 0x02 then Digest::SHA1.file(@file)
+             when 0x03 then Digest::SHA256.file(@file)
+             when 0x08 then Digest::SHA3.file(@file, 256)
+             when 0x09 then Digest::SHA3.file(@file, 512)
+      else raise "Undefined alog #{@algo}"
+    end
+    hashed.hexdigest
+  end
+end

data/lib/nem/client.rb

@@ -0,0 +1,170 @@
+require 'faraday'
+require 'faraday_middleware'
+require 'uri'
+require 'json'
+require 'time'
+
+# @attr [Hash] options connection options
+class Nem::Client
+  DEFAULTS = {
+    url:     -> { ENV['NEM_URL'] },
+    scheme:  'http',
+    host:    '127.0.0.1',
+    port:    7890,
+    timeout: 5
+  }.freeze
+
+  LOCAL_ONLY_PATHES = [
+    '/account/generate',
+    '/local/account/transfers/incoming',
+    '/local/account/transfers/outgoing',
+    '/local/account/transfers/all',
+    '/node/boot',
+    '/transaction/prepare-announce',
+    '/shutdown'
+  ]
+
+  attr_reader :options
+
+  # @param [hash] options HTTP Client connection information
+  # @option options [Symbol] :url URL
+  # @option options [Symbol] :scheme default http (http only)
+  # @option options [Symbol] :host default 127.0.0.1
+  # @option options [Symbol] :port default 7890
+  # @option options [Symbol] :timeout default 5
+  def initialize(options = {})
+    @options = parse_options(options)
+  end
+
+  # @param [Symbol] method HTTP Method(GET or POST)
+  # @param [String] path API Path
+  # @param [Hash] params API Parameters
+  # @return [Hash] Hash converted API Response
+  def request(method, path, params = {})
+    log(method, path, params)
+    if connection.remote? && local_only?(path)
+      raise Nem::Error, "The request (#{method} #{path}) is only permitted to local NIS."
+    end
+    if params.is_a?(Hash) && !params.empty?
+      params.reject! { |_, value| value.nil? }
+    end
+
+    res = connection.send(method, path, params)
+    # begin
+    # rescue Faraday::ConnectionFailed => err
+    #   error(method, path, params, err.message)
+    #   retry
+    # end
+
+    body = res.body
+    hash = parse_body(body) unless body.empty?
+    block_given? ? yield(hash) : hash
+  end
+
+  # @param [Symbol] method HTTP Method(GET or POST)
+  # @param [String] path API Path
+  # @param [Hash] params API Parameters
+  # @return [Hash] Hash converted API Response
+  # @raise [Nem::Error] NIS error
+  def request!(method, path, params = {})
+    hash = request(method, path, params)
+    raise error_handling(hash) if hash && hash.key?(:error)
+    block_given? ? yield(hash) : hash
+  end
+
+  private
+
+  def error_handling(hash)
+    error_klass = case hash[:error]
+                  when 'Not Found' then Nem::NotFoundError
+                  when 'Bad Request' then Nem::BadRequestError
+                  when 'Internal Server Error' then Nem::InternalServerError
+                  else Nem::Error
+    end
+    error_klass.new(hash[:message])
+  end
+
+  def local_only?(path)
+    LOCAL_ONLY_PATHES.include?(path)
+  end
+
+  def connection
+    @connection ||= Faraday.new(url: @options[:url]) do |f|
+      f.options[:timeout] = @options[:timeout]
+      f.request :json
+      # f.response :logger do | logger |
+      #   logger.filter(/(privateKey=)(\w+)/,'\1[FILTERED]')
+      # end
+      f.adapter Faraday.default_adapter
+    end.tap { |c| c.extend(Local) }
+  end
+
+  def parse_body(body)
+    JSON.parse(body, symbolize_names: true)
+  end
+
+  def parse_options(options = {})
+    defaults = DEFAULTS.dup
+    options  = options.dup
+
+    defaults[:url] = defaults[:url].call if defaults[:url].respond_to?(:call)
+
+    defaults.keys.each do |key|
+      options[key] = options[key.to_s] if options.key?(key.to_s)
+    end
+
+    url = options[:url] || defaults[:url]
+
+    if url
+      uri = URI(url)
+      if uri.scheme == 'http'
+        defaults[:scheme] = uri.scheme
+        defaults[:host]   = uri.host
+        defaults[:port]   = uri.port
+      else
+        raise ArgumentError, "invalid URI scheme '#{uri.scheme}'"
+      end
+    end
+
+    defaults.keys.each do |key|
+      options[key] = defaults[key] if options[key].nil?
+    end
+
+    options[:url] = URI::Generic.build(
+      scheme: options[:scheme],
+      host:   options[:host],
+      port:   options[:port]
+    ).to_s
+
+    options
+  end
+
+  def log(method, path, params)
+    Nem.logger.debug "host:%s\tmethod:%s\tpath:%s\tparams:%s" % [
+      connection.url_prefix,
+      method,
+      path,
+      params.to_hash
+    ]
+  end
+
+  def error(method, path, params, message)
+    Nem.logger.debug "host:%s\tmethod:%s\tpath:%s\tparams:%s\tmessage:%s" % [
+      connection.url_prefix,
+      method,
+      path,
+      params.to_hash,
+      message
+    ]
+  end
+
+  module Local
+    def local?
+      host == '127.0.0.1' || host == 'localhost'
+    end
+
+    def remote?
+      !local?
+    end
+  end
+end