nem-ruby 0.0.1

data/lib/nem/mixin.rb

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

data/lib/nem/mixin/assignable.rb

@@ -0,0 +1,12 @@
+module Nem
+  module Mixin
+    module Assignable
+      def initialize(attributes = {})
+        attributes.each do |k, v|
+          instance_variable_set("@#{k.to_s}", v) if respond_to?("#{k.to_s}")
+        end if attributes
+        yield self if block_given?
+      end
+    end
+  end
+end

data/lib/nem/model.rb

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

data/lib/nem/model/account.rb

@@ -0,0 +1,67 @@
+module Nem
+  module Model
+    class Account
+      include Nem::Mixin::Assignable
+
+      attr_reader :address,
+        :balance,
+        :vested_balance,
+        :importance,
+        :public_key,
+        :label,
+        :harvested_blocks,
+        :multisig_info,
+        :cosignatory_of,
+        :cosignatories,
+        :status,
+        :remote_status
+
+      def self.new_from_account_meta_data_pair(hash)
+        meta = hash[:meta]
+        account = hash[:account]
+        new(
+          address: account[:address],
+          balance: account[:balance],
+          vested_balance: account[:vestedBalance],
+          importance: account[:importance],
+          public_key: account[:publicKey],
+          label: account[:label],
+          harvested_blocks: account[:harvestedBlocks],
+          cosignatory_of: meta[:cosignatoryOf],
+          cosignatories: meta[:cosignatories],
+          status: meta[:status],
+          remote_status: meta[:remoteStatus]
+        )
+      end
+
+      def self.new_from_account_meta_data(hash)
+        cosignatory_of = hash[:cosignatoryOf].map do |account|
+          Account.new_from_account_data(account)
+        end
+        cosignatories = hash[:cosignatories].map do |account|
+          Account.new_from_account_data(account)
+        end
+        new(
+          cosignatory_of: cosignatory_of,
+          cosignatories: cosignatories,
+          status: hash[:status],
+          remote_status: hash[:remoteStatus]
+        )
+      end
+
+      def self.new_from_account_data(hash)
+        multisig_info = MultisigInfo.new_from_multisig_info(hash[:multisigInfo])
+        new(
+          address: hash[:address],
+          balance: hash[:balance],
+          vested_balance: hash[:vestedBalance],
+          importance: hash[:importance],
+          public_key: hash[:publicKey],
+          label: hash[:label],
+          harvested_blocks: hash[:harvestedBlocks],
+          multisig_info: multisig_info
+        )
+      end
+    end
+  end
+end

data/lib/nem/model/account_historical.rb

@@ -0,0 +1,19 @@
+module Nem
+  module Model
+    class AccountHistorical
+      include Nem::Mixin::Assignable
+
+      attr_reader :page_rank,
+        :address,
+        :balance,
+        :importance,
+        :vested_balance,
+        :unvested_balance,
+        :height
+
+      def self.new_from_account_historical(hash)
+        new(hash)
+      end
+    end
+  end
+end

data/lib/nem/model/block.rb

@@ -0,0 +1,33 @@
+module Nem
+  module Model
+    class Block
+      include Nem::Mixin::Assignable
+
+      attr_reader :timestamp,
+        :signature,
+        :prev_block_hash,
+        :type,
+        :transactions,
+        :version,
+        :signer,
+        :height
+
+      def self.new_from_block(hash)
+        txes = hash[:transactions].map do |tx|
+          Transaction.new_from_account_transaction(tx)
+        end
+
+        new(
+          timestamp: hash[:timeStamp],
+          signature: hash[:signature],
+          prev_block_hash: hash[:prevBlockHash][:data],
+          type: hash[:type],
+          transactions: txes,
+          version: hash[:version],
+          signer: hash[:signer],
+          height: hash[:height]
+        )
+      end
+    end
+  end
+end

data/lib/nem/model/chain.rb

@@ -0,0 +1,14 @@
+module Nem
+  module Model
+    class Chain
+      include Nem::Mixin::Assignable
+
+      attr_reader :timestamp,
+
+      def self.new_from_hash(hash)
+        new(
+        )
+      end
+    end
+  end
+end

data/lib/nem/model/connection.rb

@@ -0,0 +1,23 @@
+module Nem
+  module Model
+    class Connection
+      include Nem::Mixin::Assignable
+
+      attr_reader:path,
+        :start_time,
+        :host,
+        :elapsed_time,
+        :id
+
+      def self.new_from_connection(hash)
+        new(
+          path: hash[:path],
+          start_time: hash[:"start-time"],
+          host: hash[:host],
+          elapsed_time: hash[:"elapsed-time"],
+          id: hash[:id]
+        )
+      end
+    end
+  end
+end

data/lib/nem/model/experience.rb

@@ -0,0 +1,20 @@
+module Nem
+  module Model
+    class Experience
+      include Nem::Mixin::Assignable
+
+      attr_reader :node, :syncs, :experience
+
+      ExperienceData = Struct.new(:s, :f)
+
+      def self.new_from_experience(hash)
+        exp = hash[:experience]
+        new(
+          node: Nem::Model::Node.new_from_node(hash[:node]),
+          syncs: hash[:syncs],
+          experience: ExperienceData.new(exp[:s], exp[:f])
+        )
+      end
+    end
+  end
+end

data/lib/nem/model/explorer_block.rb

@@ -0,0 +1,21 @@
+module Nem
+  module Model
+    class ExpelorerBlock
+      include Nem::Mixin::Assignable
+
+      attr_reader :difficulty, :txes, :block, :hash
+
+      def self.new_from_explorer_block(hash)
+        txes = hash[:txes].map do |tx|
+          Transaction.new_from_transaction(tx)
+        end
+        new(
+          difficulty: hash[:difficulty],
+          txes: txes,
+          block: Block.new_from_block(hash[:block]),
+          hash: hash[:hash]
+        )
+      end
+    end
+  end
+end

data/lib/nem/model/harvest.rb

@@ -0,0 +1,23 @@
+module Nem
+  module Model
+    class Harvest
+      include Nem::Mixin::Assignable
+
+      attr_reader :timestamp,
+        :difficulty,
+        :total_fee,
+        :id,
+        :height
+
+      def self.new_from_harvest(hash)
+        new(
+          timestamp: hash[:timeStamp],
+          difficulty: hash[:difficulty],
+          total_fee: hash[:totalFee],
+          id: hash[:id],
+          height: hash[:height]
+        )
+      end
+    end
+  end
+end

data/lib/nem/model/heartbeat.rb

@@ -0,0 +1,21 @@
+module Nem
+  module Model
+    class Heartbeat
+      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/importance.rb

@@ -0,0 +1,29 @@
+module Nem
+  module Model
+    class Importance
+      include Nem::Mixin::Assignable
+
+      attr_accessor :address,
+        :score,
+        :ev,
+        :is_set,
+        :height
+
+      def self.new_from_account_importance_view_model(hash)
+        importance = hash[:importance]
+        new(
+          address: hash[:address],
+          score: importance[:score],
+          ev: importance[:ev],
+          is_set: importance[:isSet],
+          height: importance[:height]
+        )
+      end
+
+      # @return [Boolean]
+      def set?
+        @is_set == 1
+      end
+    end
+  end
+end

data/lib/nem/model/importance_transfer_transaction.rb

@@ -0,0 +1,16 @@
+module Nem
+  module Model
+    class ImportanceTransferTransaction < Transaction
+      attr_reader :mode, :remote_account
+
+      def self.new_from_transaction_meta_data_pair(hash)
+        transaction = hash[:transaction]
+        attrs = common_part_meta_data_pair(hash).merge(
+          mode: transaction[:mode],
+          remote_account: transaction[:remoteAccount]
+        )
+        new(attrs)
+      end
+    end
+  end
+end

data/lib/nem/model/keypair.rb

@@ -0,0 +1,19 @@
+module Nem
+  module Model
+    class Keypair
+      include Nem::Mixin::Assignable
+
+      attr_reader :private_key,
+        :public_key,
+        :address
+
+      def self.new_from_key_pair_view_model(hash)
+        new(
+          private_key: hash[:privateKey],
+          public_key: hash[:publicKey],
+          address: hash[:address]
+        )
+      end
+    end
+  end
+end

data/lib/nem/model/message.rb

@@ -0,0 +1,91 @@
+module Nem
+  module Model
+    # @attr [String] value
+    # @attr [Integer] type
+    # @attr [String] payload
+    # @attr [String] public_key
+    # @attr [String] private_key
+    class Message
+      TYPE_PLAIN     = 1
+      TYPE_ENCRYPTED = 2
+
+      include Nem::Mixin::Assignable
+
+      attr_reader :value, :type
+      attr_accessor :public_key, :private_key
+
+      def self.new_from_message(hash)
+        new(
+          hash[:payload],
+          type: (hash[:type] == TYPE_ENCRYPTED) ? :encrypted : :plain
+        )
+      end
+
+      def initialize(value = '', type: :plain, private_key: nil, public_key: nil)
+        @value = value
+        @type = (type == :encrypted) ? TYPE_ENCRYPTED : TYPE_PLAIN
+        @private_key = private_key
+        @public_key = public_key
+      end
+
+      def encrypt!
+        bin_sk = fix_private_key(@private_key).scan(/../).map(&:hex).reverse.pack('C*')
+        bin_pk = (public_key || @public_key).scan(/../).map(&:hex).pack('C*')
+        @value = Nem::Util::Ed25519.encrypt(bin_sk, bin_pk, value)
+        @type = TYPE_ENCRYPTED
+      end
+
+      def decrypt!
+        bin_sk = fix_private_key(@private_key).scan(/../).map(&:hex).reverse.pack('C*')
+        bin_pk = (public_key || @public_key).scan(/../).map(&:hex).pack('C*')
+        @value = Nem::Util::Ed25519.decrypt(bin_sk, bin_pk, payload)
+        @type = TYPE_PLAIN
+      end
+
+      # @return [Boolean]
+      def encrypted?
+        @type == TYPE_ENCRYPTED
+      end
+
+      # @return [Boolean]
+      def plain?
+        @type == TYPE_PLAIN
+      end
+
+      # @return [Integer]
+      def bytesize
+        payload.bytesize
+      end
+
+      # @return [Boolean]
+      def valid?
+        bytesize <= 512
+      end
+
+      # @return [Hash]
+      def to_hash
+        { payload: payload, type: @type }
+      end
+
+      # @return [String]
+      def to_s
+        @value.to_s
+      end
+
+      # @return [Boolean]
+      def ==(other)
+        @value == other.value
+      end
+
+      def payload
+        (value =~ /\Afe/ || encrypted?) ? value : value.unpack('H*').first
+      end
+
+      private
+
+      def fix_private_key(key)
+        "#{'0' * 64}#{key.sub(/^00/i, '')}"[-64, 64]
+      end
+    end
+  end
+end

data/lib/nem/model/mosaic.rb

@@ -0,0 +1,21 @@
+module Nem
+  module Model
+    class Mosaic
+      include Nem::Mixin::Assignable
+
+      extend Forwardable
+
+      def_delegators :@mosaic_id, :fqn
+
+      attr_reader :mosaic_id, :quantity
+
+      def self.new_from_mosaic(hash)
+        mosaic_id = Nem::Model::MosaicId.new_from_mosaic_id(hash[:mosaicId])
+        new(
+          quantity: hash[:quantity],
+          mosaic_id: mosaic_id
+        )
+      end
+    end
+  end
+end