nem-ruby 0.0.1

data/lib/nem/transaction.rb

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

data/lib/nem/transaction/base.rb

@@ -0,0 +1,45 @@
+module Nem
+  module Transaction
+    class Base
+      attr_reader :type, :fee,
+        :timestamp, :deadline, :signer, :signature
+      # :version, :network
+
+      {
+        transfer: 0x0101,
+        importance_transfer: 0x0801,
+        multisig_aggregate_modification: 0x1001,
+        multisig_signature: 0x1002,
+        multisig: 0x1004,
+        provision_namespace: 0x2001,
+        mosaic_definition_creation: 0x4001,
+        mosaic_supply_change: 0x4002,
+      }.each do |k, v|
+        define_method("#{k}?") { @type == v }
+      end
+
+      NETWORK = {
+        testnet: 0x98 << 24,
+        mainnet: 0x68 << 24,
+        mijin: 0x60 << 24
+      }
+
+      NETWORK.each do |k, _|
+        define_method("#{k}?") { @network == k }
+      end
+
+      def network(hex: false)
+        hex ? NETWORK[@network] : @network
+      end
+
+      # it can be override by child class
+      def version
+        network(hex: true) + 1
+      end
+
+      def to_hash
+        raise 'it must be implemented by child class.'
+      end
+    end
+  end
+end

data/lib/nem/transaction/importance_transfer.rb

@@ -0,0 +1,42 @@
+module Nem
+  module Transaction
+    # @attr [String] remote_account
+    # @attr [Symbol] mode
+    # @see https://nemproject.github.io/#importanceTransferTransaction
+    class ImportanceTransfer < Nem::Transaction::Base
+      TYPE = 0x0801 # 2049 (importance transfer transaction)
+
+      ACTIVATE   = 0x0001
+      DEACTIVATE = 0x0002
+
+      attr_reader :mode, :remote_account
+
+      def initialize(remote_account, mode, network: nil)
+        @remote_account = remote_account
+        @mode = mode
+
+        @network = network || Nem.default_network
+        @type = TYPE
+        @fee = Nem::Fee::ImportanceTransfer.new(self)
+      end
+
+      # attributes must be CAMEL CASE for NIS params
+      def to_hash
+        {
+          mode: parse_mode,
+          remoteAccount: remote_account
+        }
+      end
+
+      private
+
+      def parse_mode
+        case mode
+        when :activate   then ACTIVATE
+        when :deactivate then DEACTIVATE
+          else raise "Not implemented mode: #{mode}"
+        end
+      end
+    end
+  end
+end

data/lib/nem/transaction/mosaic_definition_creation.rb

@@ -0,0 +1,45 @@
+module Nem
+  module Transaction
+    # @attr [Nem::Model::MosaicDefinition] mosaic_definition
+    # @attr [Integer] creation_fee
+    # @attr [Integer] creation_fee_sink
+    # @see https://nemproject.github.io/#mosaicDefinitionCreationTransaction
+    class MosaicDefinitionCreation < Nem::Transaction::Base
+      TYPE = 0x4001 # 16385 (mosaic definition creation transaction)
+
+      attr_reader :mosaic_definition, :creation_fee, :creation_fee_sink
+
+      def initialize(mosaic_definition, network: nil)
+        @mosaic_definition = mosaic_definition
+        @creation_fee = creation[:fee]
+        @creation_fee_sink = creation[:sink]
+
+        @network = network || Nem.default_network
+        @type = TYPE
+        @fee = Nem::Fee::MosaicDefinitionCreation.new(self)
+      end
+
+      # attributes must be CAMEL CASE for NIS params
+      def to_hash
+        {
+          mosaicDefinition: mosaic_definition.to_hash,
+          creationFee: creation_fee,
+          creationFeeSink: creation_fee_sink,
+        }
+      end
+
+      private
+
+      # @see http://www.nem.ninja/docs/#mosaics
+      def creation
+        if @network == :mainnet
+          { sink: 'NBMOSAICOD4F54EE5CDMR23CCBGOAM2XSIUX6TRS',
+            fee: 20 * 1_000_000 }
+        else
+          { sink: 'TBMOSAICOD4F54EE5CDMR23CCBGOAM2XSJBR5OLC',
+            fee: 20 * 1_000_000 }
+        end
+      end
+    end
+  end
+end

data/lib/nem/transaction/mosaic_supply_change.rb

@@ -0,0 +1,45 @@
+module Nem
+  module Transaction
+    # @attr [Nem::Model::MosaicId] mosaic_id
+    # @attr [Symbol] supply_type
+    # @attr [Integer] delta
+    # @see https://nemproject.github.io/#mosaicSupplyChangeTransaction
+    class MosaicSupplyChange < Nem::Transaction::Base
+      TYPE = 0x4002 # 16386 (mosaic supply change transaction)
+
+      INCREASE = 0x0001
+      DECREASE = 0x0002
+
+      attr_accessor :mosaic_id, :supply_type, :delta
+
+      def initialize(mosaic_id, type, delta, network: nil)
+        @mosaic_id = mosaic_id
+        @supply_type = type
+        @delta = delta
+
+        @network = network || Nem.default_network
+        @type = TYPE
+        @fee = Nem::Fee::MosaicSupplyChangeTransfer.new(self)
+      end
+
+      # attributes must be CAMEL CASE for NIS params
+      def to_hash
+        {
+          mosaicId: mosaic_id.to_hash,
+          supplyType: parse_type,
+          delta: delta,
+        }
+      end
+
+      private
+
+      def parse_type
+        case type
+        when :increase  then INCREASE
+        when :descrease then DECREASE
+          else raise "Not implemented type: #{type}"
+        end
+      end
+    end
+  end
+end

data/lib/nem/transaction/multisig.rb

@@ -0,0 +1,29 @@
+module Nem
+  module Transaction
+    # @attr [Nem::Transaction::*] other_trans
+    # @attr [String] signer
+    # @see https://nemproject.github.io/#multisigTransaction
+    class Multisig < Nem::Transaction::Base
+      TYPE = 0x1004 # 4100 (multisig transaction)
+
+      attr_reader :other_trans, :signer
+
+      def initialize(trans, signer, network: nil)
+        @other_trans = trans
+        @signer = signer
+
+        @network = network || Nem.default_network
+        @type = TYPE
+        @fee = Nem::Fee::Multisig.new(self)
+      end
+
+      # attributes must be CAMEL CASE for NIS params
+      def to_hash
+        {
+          otherTrans: other_trans.to_hash,
+          signer: signer
+        }
+      end
+    end
+  end
+end

data/lib/nem/transaction/multisig_aggregate_modification.rb

@@ -0,0 +1,30 @@
+module Nem
+  module Transaction
+    # @attr [Array <Nem::Model::MultisigCosignatoryModification>] modifications
+    # @attr [Interger] relative_change
+    class MultisigAggregateModification < Nem::Transaction::Base
+      TYPE = 0x1001 # 4097 (multisig aggregate modification transfer transaction)
+
+      attr_reader :modifications, :relative_change, :min_cosignatories
+
+      def initialize(modifications, relative_change, network: nil)
+        @modifications = modifications
+        @relative_change = relative_change
+
+        @network = network || Nem.default_network
+        @type = TYPE
+        @fee = Nem::Fee::MultisigAggregateModification.new(self)
+      end
+
+      # attributes must be CAMEL CASE for NIS params
+      def to_hash
+        {
+          modifications: modifications.map(&:to_hash),
+          minCosignatories: {
+            relativeChange: relative_change
+          }
+        }
+      end
+    end
+  end
+end

data/lib/nem/transaction/multisig_cosignatory_modification.rb

@@ -0,0 +1,33 @@
+module Nem
+  module Transaction
+    class MultisigCosignatoryModification
+      attr_reader :modification_type, :cosignatory_account
+
+      TYPE_ADD = 0x001
+      TYPE_REMOVE = 0x002
+
+      def initialize(type, public_key)
+        @modification_type = type
+        @cosignatory_account = public_key
+      end
+
+      # attributes must be CAMEL CASE for NIS params
+      def to_hash
+        {
+          modificationType: parse_type,
+          cosignatoryAccount: cosignatory_account
+        }
+      end
+
+      private
+
+      def parse_type
+        case modification_type
+        when :add then TYPE_ADD
+        when :remove then TYPE_REMOVE
+          else raise "Not implemented mode: #{modification_type}"
+        end
+      end
+    end
+  end
+end

data/lib/nem/transaction/multisig_signature.rb

@@ -0,0 +1,31 @@
+module Nem
+  module Transaction
+    # @attr [String] other_hash
+    # @attr [String] other_account
+    # @attr [String] signer
+    class MultisigSignature < Nem::Transaction::Base
+      TYPE = 0x1002 # 4098 (multisig signature transaction)
+
+      attr_reader :other_hash, :other_account, :signer
+
+      def initialize(other_hash, other_account, signer, network: nil)
+        @other_hash = other_hash
+        @other_account = other_account
+        @signer = signer
+
+        @network = network || Nem.default_network
+        @type = TYPE
+        @fee = Nem::Fee::Multisig.new(self)
+      end
+
+      # attributes must be CAMEL CASE for NIS params
+      def to_hash
+        {
+          otherHash: { data: other_hash },
+          otherAccount: other_account,
+          signer: signer
+        }
+      end
+    end
+  end
+end

data/lib/nem/transaction/provision_namespace.rb

@@ -0,0 +1,65 @@
+module Nem
+  module Transaction
+    class ProvisionNamespace < Nem::Transaction::Base
+      TYPE = 0x2001 # 8193 (provision namespace transaction)
+
+      attr_reader :new_part, :parent, :rental_fee_sink, :rental_fee
+
+      # @attr [String] new_part
+      # @attr [String] parent
+      # @attr [String] rental_fee_sink
+      # @attr [Integer] rental_fee
+      def initialize(new_part, parent = nil, network: nil)
+        @new_part = new_part
+        @parent = parent
+        @rental_fee = rental[:fee]
+        @rental_fee_sink = rental[:sink]
+
+        @network = network || Nem.default_network
+        @type = TYPE
+        @fee = Nem::Fee::ProvisionNamespace.new(self)
+      end
+
+      def root?
+        !!(@parent == nil)
+      end
+
+      def sub?
+        !!(@parent && @new_part)
+      end
+
+      # attributes must be CAMEL CASE for NIS params
+      def to_hash
+        {
+          newPart: new_part,
+          parent: parent,
+          rentalFeeSink: rental_fee_sink,
+          rentalFee: rental_fee
+        }
+      end
+
+      private
+
+      # @see http://www.nem.ninja/docs/#namespaces
+      def rental
+        if @network == :mainnet
+          if root?
+            { fee: 100 * 1_000_000,
+              sink: 'NAMESPACEWH4MKFMBCVFERDPOOP4FK7MTBXDPZZA' }
+          else
+            { fee: 10 * 1_000_000,
+              sink: 'NAMESPACEWH4MKFMBCVFERDPOOP4FK7MTBXDPZZA' }
+          end
+        else
+          if root?
+            { fee: 100 * 1_000_000,
+              sink: 'TAMESPACEWH4MKFMBCVFERDPOOP4FK7MTDJEYP35' }
+          else
+            { fee: 10 * 1_000_000,
+              sink: 'TAMESPACEWH4MKFMBCVFERDPOOP4FK7MTDJEYP35' }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/nem/transaction/transfer.rb

@@ -0,0 +1,63 @@
+module Nem
+  module Transaction
+    # @attr [Integer] amount
+    # @attr [String] recipient
+    # @attr [Nem::Model::Message] message
+    # @attr [Array <Nem::Model::MosaicId>] mosaics
+    # @see https://nemproject.github.io/#transferTransaction
+    # @see https://nemproject.github.io/#initiating-a-transfer-transaction
+    # @see https://nemproject.github.io/#version-1-transfer-transactions
+    # @see https://nemproject.github.io/#version-2-transfer-transactions
+    class Transfer < Nem::Transaction::Base
+      TYPE = 0x0101 # 257 (transfer transaction)
+
+      attr_reader :amount, :recipient, :message, :mosaics
+
+      def initialize(recipient, amount, message = '', mosaics: [], network: nil)
+        @amount = amount
+        @recipient = recipient
+        @message = message.is_a?(Nem::Model::Message) ?
+          message :
+          Nem::Model::Message.new(message.to_s)
+        @mosaics = mosaics
+
+        @network = network || Nem.default_network
+        @type = TYPE
+        @fee = Nem::Fee::Transfer.new(self)
+      end
+
+      def has_message?
+        @message.bytesize > 0
+      end
+
+      def has_mosaics?
+        @mosaics.size > 0
+      end
+
+      def version
+        network(hex: true) + (has_mosaics? ? 2 : 1)
+      end
+
+      # attributes must be CAMEL CASE for NIS params
+      def to_hash
+        tmp = {
+          amount: amount * 1_000_000,
+          recipient: recipient,
+          message: message.to_hash
+        }
+        unless mosaics.empty?
+          tmp[:mosaics] = mosaics.map do |moa|
+            {
+              mosaicId: {
+                namespaceId: moa.mosaic_id.namespace_id,
+                name: moa.mosaic_id.name,
+              },
+              quantity: moa.amount
+            }
+          end
+        end
+        tmp
+      end
+    end
+  end
+end

data/lib/nem/util.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+module Nem::Util
+  NEM_EPOCH = Time.utc(2015, 3, 29, 0, 6, 25, 0)
+
+  TESTNET = 0x98000000 # -1744830464
+  MAINNET = 0x68000000 #  1744830464
+  MIJIN   = 0x60000000
+
+  VERSION_1 = 0x00000001 # 1
+  VERSION_2 = 0x00000002 # 2
+
+  TESTNET_VERSION_1 = TESTNET | VERSION_1 # 0x98000001 = -1744830463
+  TESTNET_VERSION_2 = TESTNET | VERSION_2 # 0x98000002 = -1744830462
+  MAINNET_VERSION_1 = MAINNET | VERSION_1 # 0x68000001 =  1744830465
+  MAINNET_VERSION_2 = MAINNET | VERSION_2 # 0x68000002 =  1744830466
+
+  def self.parse_version(network, version)
+    parse_network(network) | version
+  end
+
+  def self.parse_network(network)
+    case network
+    when :testnet then TESTNET
+    when :mainnet then MAINNET
+    when :mijin then MIJIN
+      else TESTNET
+    end
+  end
+
+  def self.parse_nemtime(nemtime)
+    NEM_EPOCH + nemtime
+  end
+
+  def self.deadline(seconds = 3600)
+    timestamp + seconds
+  end
+
+  def self.timestamp
+    # escape FAILURE_TIMESTAMP_TOO_FAR_IN_FUTURE
+    (Time.now.utc - NEM_EPOCH).to_i - 30
+  end
+end
+
+Dir.glob(File.expand_path('util/*.rb', __dir__)).each { |f| require f }