nem-ruby 0.0.1

data/lib/nem/model/node.rb

@@ -0,0 +1,41 @@
+module Nem
+  module Model
+    class NodeMetadata
+      include Nem::Mixin::Assignable
+
+      attr_reader :features,
+        :network,
+        :application,
+        :version,
+        :platform
+    end
+
+    class NodeEndpoint
+      include Nem::Mixin::Assignable
+
+      attr_reader :protocol, :port, :host
+    end
+
+    class NodeIdentity
+      include Nem::Mixin::Assignable
+
+      attr_reader :name, :public_key
+    end
+
+    class Node
+      include Nem::Mixin::Assignable
+
+      attr_reader :metadata,
+        :endpoint,
+        :identity
+
+      def self.new_from_node(hash)
+        new(
+          metadata: NodeMetadata.new(hash[:metaData]),
+          endpoint: NodeEndpoint.new(hash[:endpoint]),
+          identity: NodeIdentity.new(hash[:identity])
+        )
+      end
+    end
+  end
+end

data/lib/nem/model/provision_namespace_transaction.rb

@@ -0,0 +1,18 @@
+module Nem
+  module Model
+    class ProvisionNamespaceTransaction < Transaction
+      attr_reader :rental_fee, :rental_fee_sink, :parent, :new_part
+
+      def self.new_from_transaction_meta_data_pair(hash)
+        transaction = hash[:transaction]
+        attrs = common_part_meta_data_pair(hash).merge(
+          rental_fee: transaction[:rentalFee],
+          rental_fee_sink: transaction[:rentalFeeSink],
+          parent: transaction[:parent],
+          new_part: transaction[:newPart]
+        )
+        new(attrs)
+      end
+    end
+  end
+end

data/lib/nem/model/status.rb

@@ -0,0 +1,21 @@
+module Nem
+  module Model
+    class Status
+      include Nem::Mixin::Assignable
+
+      attr_reader :code,
+        :type,
+        :message
+
+      # 0: Unknown status.
+      # 1: NIS is stopped.
+      # 2: NIS is starting.
+      # 3: NIS is running.
+      # 4: NIS is booting the local node (implies NIS is running).
+      # 5: The local node is booted (implies NIS is running).
+      # 6: The local node is synchronized (implies NIS is running and the local node is booted).
+      # 7: NIS local node does not see any remote NIS node (implies running and booted).
+      # 8: NIS is currently loading the block chain from the database. In this state NIS cannot serve any requests.
+    end
+  end
+end

data/lib/nem/model/timer.rb

@@ -0,0 +1,31 @@
+module Nem
+  module Model
+    class Timer
+      include Nem::Mixin::Assignable
+
+      attr_reader :last_delay_time,
+        :executions,
+        :failures,
+        :successes,
+        :last_operation_start_time,
+        :is_executing,
+        :name,
+        :average_operation_time,
+        :operation_time
+
+      def self.new_from_timer(hash)
+        new(
+          last_delay_time: hash[:'last-delay-time'],
+          executions: hash[:executions],
+          failures: hash[:failures],
+          successes: hash[:successes],
+          last_operation_start_time: hash[:'last-operation-start-time'],
+          is_executing: hash[:'is-executing'],
+          name: hash[:name],
+          average_operation_time: hash[:'average-operation-time'],
+          operation_time: hash[:'operation-time']
+        )
+      end
+    end
+  end
+end

data/lib/nem/model/timesync.rb

@@ -0,0 +1,19 @@
+module Nem
+  module Model
+    class Timesync
+      include Nem::Mixin::Assignable
+
+      attr_reader :datetime,
+        :current_time_offset,
+        :change
+
+      def self.new_from_timer(hash)
+        new(
+          datetime: hash[:datetime],
+          current_time_offset: hash[:current_time_offset],
+          change: hash[:change]
+        )
+      end
+    end
+  end
+end

data/lib/nem/model/transaction.rb

@@ -0,0 +1,71 @@
+module Nem
+  module Model
+    class Transaction
+      include Nem::Mixin::Assignable
+
+      attr_reader :timestamp,
+        :version,
+        :type,
+        :signer,
+        :fee,
+        :deadline,
+        :id,
+        :hash,
+        :height
+
+      def version?(num)
+        num == 1 ? true : false  # TODO: version
+      end
+
+      def self.new_from_account_transaction(hash)
+        new_from_account_transaction_meta_data_pair(
+          meta: { data: nil },
+          transaction: hash
+        )
+      end
+
+      def self.new_from_account_transaction_meta_data_pair(hash)
+        type = hash[:transaction][:type]
+        klass = case type
+                when 0x0101 then TransferTransaction
+                when 0x0801 then ImportanceTransferTransaction
+                when 0x1001 then MultisigAggregateModificationTransaction
+                when 0x1002 then MultisigSignatureTransaction
+                when 0x1004 then MultisigTransaction
+                when 0x2001 then ProvisionNamespaceTransaction
+                when 0x4001 then MosaicDefinitionCreationTransaction
+                when 0x4002 then MosaicSupplyChangeTransaction
+          else raise "Undefined transaction type: #{type}"
+        end
+        klass.new_from_transaction_meta_data_pair(hash)
+      end
+
+      def self.common_part(hash)
+        {
+          timestamp: hash[:timeStamp],
+          version: hash[:version],
+          type: hash[:type],
+          signer: hash[:signer],
+          fee: hash[:fee],
+          deadline: hash[:deadline]
+        }
+      end
+
+      def self.common_part_meta_data_pair(hash)
+        meta = hash[:meta]
+        transaction = hash[:transaction]
+        {
+          id: meta[:id],
+          hash: meta[:hash] ? meta[:hash][:data] : meta[:data],
+          height: meta[:height],
+          timestamp: transaction[:timeStamp],
+          version: transaction[:version],
+          type: transaction[:type],
+          signer: transaction[:signer],
+          fee: transaction[:fee],
+          deadline: transaction[:deadline]
+        }
+      end
+    end
+  end
+end

data/lib/nem/model/transfer_transaction.rb

@@ -0,0 +1,24 @@
+module Nem
+  module Model
+    class TransferTransaction < Transaction
+      attr_reader :recipient, :amount, :message, :mosaics
+
+      def self.new_from_transaction_meta_data_pair(hash)
+        transaction = hash[:transaction]
+        attrs = common_part_meta_data_pair(hash).merge(
+          recipient: transaction[:recipient],
+          amount: transaction[:amount],
+        )
+        unless transaction[:message].empty?
+          attrs[:message] = Nem::Model::Message.new_from_message(transaction[:message])
+        end
+        if transaction[:mosaics]
+          attrs[:mosaics] = transaction[:mosaics].map do |mo|
+            Mosaic.new(mo)
+          end
+        end
+        new(attrs)
+      end
+    end
+  end
+end

data/lib/nem/model/unlocked_info.rb

@@ -0,0 +1,24 @@
+module Nem
+  module Model
+    class UnlockedInfo
+      include Nem::Mixin::Assignable
+
+      attr_reader :max_unlocked, :num_unlocked
+
+      def self.new_from_unlocked_info(hash)
+        new(
+          max_unlocked: hash[:'max-unlocked'],
+          num_unlocked: hash[:'num-unlocked']
+        )
+      end
+
+      def has_freeslot?
+        ! @max_unlocked == @num_unlocked
+      end
+
+      def freeslot
+        @max_unlocked - @num_unlocked
+      end
+    end
+  end
+end

data/lib/nem/mosaic.rb

@@ -0,0 +1,2 @@
+# frozen_string_literal: true
+Dir.glob(File.expand_path('mosaic/*.rb', __dir__)).each { |f| require f }

data/lib/nem/mosaic/dim_coin.rb

@@ -0,0 +1,21 @@
+module Nem
+  module Mosaic
+    class DimCoin < Nem::Model::MosaicAttachment
+      def initialize(quantity)
+        mosaic_id = Nem::Model::MosaicId.new(
+          namespace_id: 'dim',
+          name: 'coin'
+        )
+        properties = Nem::Model::MosaicProperties.new(
+          divisibility: 6,
+          initial_supply: 900_000_000
+        )
+        super(
+          mosaic_id: mosaic_id,
+          properties: properties,
+          quantity: quantity
+        )
+      end
+    end
+  end
+end

data/lib/nem/mosaic/dim_token.rb

@@ -0,0 +1,21 @@
+module Nem
+  module Mosaic
+    class DimToken < Nem::Model::MosaicAttachment
+      def initialize(quantity)
+        mosaic_id = Nem::Model::MosaicId.new(
+          namespace_id: 'dim',
+          name: 'token'
+        )
+        properties = Nem::Model::MosaicProperties.new(
+          divisibility: 6,
+          initial_supply: 1_000_000
+        )
+        super(
+          mosaic_id: mosaic_id,
+          properties: properties,
+          quantity: quantity
+        )
+      end
+    end
+  end
+end

data/lib/nem/mosaic/ecobit_eco.rb

@@ -0,0 +1,21 @@
+module Nem
+  module Mosaic
+    class EcobitEco < Nem::Model::MosaicAttachment
+      def initialize(quantity)
+        mosaic_id = Nem::Model::MosaicId.new(
+          namespace_id: 'ecobit',
+          name: 'eco'
+        )
+        properties = Nem::Model::MosaicProperties.new(
+          divisibility: 0,
+          initial_supply: 888_888_888
+        )
+        super(
+          mosaic_id: mosaic_id,
+          properties: properties,
+          quantity: quantity
+        )
+      end
+    end
+  end
+end

data/lib/nem/mosaic/xem.rb

@@ -0,0 +1,21 @@
+module Nem
+  module Mosaic
+    class Xem < Nem::Model::MosaicAttachment
+      def initialize(quantity)
+        mosaic_id = Nem::Model::MosaicId.new(
+          namespace_id: 'nem',
+          name: 'xem'
+        )
+        properties = Nem::Model::MosaicProperties.new(
+          divisibility: 6,
+          initial_supply: 8_999_999_999
+        )
+        super(
+          mosaic_id: mosaic_id,
+          properties: properties,
+          quantity: quantity
+        )
+      end
+    end
+  end
+end

data/lib/nem/node.rb

@@ -0,0 +1,29 @@
+module Nem
+  class Node
+    extend Forwardable
+
+    def_delegators :@client, :request, :request!
+
+    # @param [hash] options HTTP Client connection information
+    # @option options [String] :url URL
+    # @option options [String] :scheme default http
+    # @option options [Symbol] :host default 127.0.0.1
+    # @option options [Integer] :port default 7890
+    # @option options [Integer] :timeout default 5
+    def initialize(options = {})
+      @client = Nem::Client.new(options)
+    end
+
+    def heartbeat
+      Nem::Model::Heartbeat.new request!(:get, '/heartbeat')
+    end
+
+    def status
+      Nem::Model::Status.new request!(:get, '/status')
+    end
+
+    def shutdown
+      request!(:get, '/shutdown')
+    end
+  end
+end

data/lib/nem/node_pool.rb

@@ -0,0 +1,31 @@
+module Nem
+  class NodePool
+    extend Forwardable
+
+    def_delegators :@nodes, :first, :last, :length
+
+    attr_reader :nodes, :failed
+
+    def self.from_hash(definitions)
+      new(definitions.map { |d| Nem::Node.new(d) })
+    end
+
+    def initialize(nodes)
+      @nodes = nodes
+      @failed = []
+    end
+
+    def current
+      @nodes.first
+    end
+
+    def next!
+      @failed << @nodes.shift
+      raise 'Exhausted node pool' if length.zero?
+    end
+
+    def <<(definitioin)
+      @nodes << Nem::Node.new(definitioin)
+    end
+  end
+end

data/lib/nem/request.rb

@@ -0,0 +1,2 @@
+# frozen_string_literal: true
+Dir.glob(File.expand_path('request/*.rb', __dir__)).each { |f| require f }

data/lib/nem/request/announce.rb

@@ -0,0 +1,76 @@
+module Nem
+  module Request
+    # @attr [Nem::Struct::Transaction] transaction
+    # @attr [Nem::Keypair] keypair
+    # @attr [String] data
+    # @attr [String] signature
+    # @see https://nemproject.github.io/#requestAnnounce
+    # @see https://nemproject.github.io/#requestPrepareAnnounce
+    class Announce
+      attr_reader :transaction, :keypair, :data, :signature
+
+      def initialize(transaction, keypair)
+        @transaction = transaction
+        @keypair = keypair
+      end
+
+      # @return [Hash] Attribute and value pairs
+      def to_entity(state = nil)
+        entity = prepare_entity
+        if state == :prepare
+          { transaction: entity,
+            privateKey: keypair.private }
+        else
+          serialized = serialize(entity)
+          hex_serialized = Nem::Util::Convert.ua2hex(serialized)
+          { data: Nem::Util::Convert.ua2hex(serialized),
+            signature: signature(hex_serialized) }
+        end
+      end
+
+      private
+
+      def prepare_entity
+        specify = if transaction.multisig?
+          prepare_multisig(transaction)
+        else
+          transaction.to_hash
+        end
+        set_common(specify)
+      end
+
+      def prepare_multisig(tx)
+        other_trans = tx.other_trans.to_hash.merge(
+          type: tx.other_trans.type,
+          fee: tx.other_trans.fee.to_i,
+          timeStamp: Nem::Util.timestamp,
+          deadline: Nem::Util.deadline(Nem.deadline),
+          signer: tx.signer,
+          version: tx.other_trans.version
+        )
+        tx.to_hash.merge(
+          otherTrans: other_trans
+        )
+      end
+
+      def set_common(hash)
+        hash.merge(
+          type: transaction.type,
+          fee: transaction.fee.to_i,
+          timeStamp: Nem::Util.timestamp,
+          deadline: Nem::Util.deadline(Nem.deadline),
+          signer: keypair.public,
+          version: transaction.version
+        )
+      end
+
+      def serialize(hash)
+        Nem::Util::Serializer.serialize_transaction(hash)
+      end
+
+      def signature(serialized)
+        keypair.sign(serialized)
+      end
+    end
+  end
+end