nem-ruby 0.0.1

data/lib/nem/model/mosaic_attachment.rb

@@ -0,0 +1,22 @@
+module Nem
+  module Model
+    class MosaicAttachment
+      include Nem::Mixin::Assignable
+
+      extend Forwardable
+
+      def_delegators :@mosaic_id, :fqn
+      def_delegators :@properties,
+        :divisibility,
+        :initial_supply,
+        :supply_mutable,
+        :transferable
+
+      attr_reader :mosaic_id, :properties, :quantity
+
+      def amount
+        return quantity * (10**properties.divisibility)
+      end
+    end
+  end
+end

data/lib/nem/model/mosaic_definition.rb

@@ -0,0 +1,65 @@
+module Nem
+  module Model
+    class MosaicDefinition
+      include Nem::Mixin::Assignable
+
+      extend Forwardable
+
+      def_delegators :@properties,
+        :divisibility,
+        :initial_supply,
+        :supply_mutable,
+        :transferable
+
+      attr_reader :creator,
+        :id,
+        :description,
+        :properties,
+        :levy,
+        :meta_id
+
+      def self.new_from_mosaic_definition(hash)
+        id = Nem::Model::MosaicId.new_from_mosaic_id(hash[:id])
+        props = Nem::Model::MosaicProperties.new_from_mosaic_properties(hash[:properties])
+        levy = Nem::Model::MosaicLevy.new_from_mosaic_levy(hash[:levy])
+        new(
+          creator: hash[:creator],
+          description: hash[:description],
+          id: id,
+          properties: props,
+          levy: levy
+        )
+      end
+
+      def self.new_from_mosaic_definition_meta_data_pair(hash)
+        meta = hash[:meta]
+        mosaic = hash[:mosaic]
+        id = Nem::Model::MosaicId.new_from_mosaic_id(mosaic[:id])
+        props = Nem::Model::MosaicProperties.new_from_mosaic_properties(mosaic[:properties])
+        levy = Nem::Model::MosaicLevy.new_from_mosaic_levy(mosaic[:levy])
+        new(
+          meta_id: meta[:id],
+          creator: hash[:creator],
+          description: hash[:description],
+          id: id,
+          properties: props,
+          levy: levy
+        )
+      end
+
+      def has_levy?
+        ! @levy.empty?
+      end
+
+      def to_hash
+        {
+          creator: creator,
+          id: id.to_hash,
+          description: description,
+          properties: properties.to_hash,
+          levy: levy.to_hash
+        }
+      end
+    end
+  end
+end

data/lib/nem/model/mosaic_definition_creation_transaction.rb

@@ -0,0 +1,18 @@
+module Nem
+  module Model
+    class MosaicDefinitionCreationTransaction < Transaction
+      attr_reader :creation_fee, :creation_fee_sink, :mosaic_definition
+
+      def self.new_from_transaction_meta_data_pair(hash)
+        transaction = hash[:transaction]
+        mo_def = MosaicDefinition.new_from_mosaic_definition(transaction[:mosaicDefinition])
+        attrs = common_part_meta_data_pair(hash).merge(
+          creation_fee: transaction[:creationFee],
+          creation_fee_sink: transaction[:creationFeeSink],
+          mosaic_definition: mo_def
+        )
+        new(attrs)
+      end
+    end
+  end
+end

data/lib/nem/model/mosaic_id.rb

@@ -0,0 +1,27 @@
+module Nem
+  module Model
+    class MosaicId
+      include Nem::Mixin::Assignable
+
+      attr_reader :namespace_id, :name
+
+      def self.new_from_mosaic_id(hash)
+        new(
+          namespace_id: hash[:namespaceId],
+          name: hash[:name]
+        )
+      end
+
+      def fqn
+        @fqn ||= "#{@namespace_id}:#{@name}"
+      end
+
+      def to_hash
+        {
+          namespaceId: namespace_id,
+          name: name
+        }
+      end
+    end
+  end
+end

data/lib/nem/model/mosaic_levy.rb

@@ -0,0 +1,32 @@
+module Nem
+  module Model
+    class MosaicLevy
+      include Nem::Mixin::Assignable
+
+      attr_reader :fee,
+        :recipient,
+        :type,
+        :mosaic_id
+
+      def self.new_from_mosaic_levy(hash)
+        return nil if hash.empty?
+        mosaic_id = Nem::Model::MosaicId.new_from_mosaic_id(hash[:mosaicId])
+        new(
+          fee: hash[:fee],
+          recipient: hash[:recipient],
+          type: hash[:type],
+          mosaic_id: mosaic_id
+        )
+      end
+
+      def to_hash
+        {
+          fee: fee,
+          recipient: recipient,
+          type: type,
+          mosaicId: mosaic_id.to_hash
+        }
+      end
+    end
+  end
+end

data/lib/nem/model/mosaic_owned.rb

@@ -0,0 +1,22 @@
+module Nem
+  module Model
+    class MosaicOwned
+      include Nem::Mixin::Assignable
+
+      attr_reader :mosaics
+
+      def self.new_from_mosaic_owned(hash)
+        mosaics = hash[:data].inject({}) do |memo, mos|
+          mosaic = Nem::Model::Mosaic.new_from_mosaic(mos)
+          memo[mosaic.fqn] = mosaic
+          memo
+        end
+        new(mosaics: mosaics)
+      end
+
+      def find(fqn)
+        mosaics[fqn]
+      end
+    end
+  end
+end

data/lib/nem/model/mosaic_properties.rb

@@ -0,0 +1,44 @@
+module Nem
+  module Model
+    class MosaicProperties
+      include Nem::Mixin::Assignable
+
+      attr_reader :divisibility,
+        :initial_supply,
+        :supply_mutable,
+        :transferable
+
+      def self.new_from_mosaic_properties(hash)
+        props = hash.inject({}) do |memo, prop|
+          memo[prop[:name]] = case prop[:name]
+                              when 'divisibility'  then prop[:value].to_i
+                              when 'initialSupply' then prop[:value].to_i
+                              when 'supplyMutable' then prop[:value] == 'true' ? true : false
+                              when 'transferable'  then prop[:value] == 'true' ? true : false
+            else prop[:value]
+          end
+          memo
+        end
+        new(
+          divisibility: props['divisibility'],
+          initial_supply: props['initialSupply'],
+          supply_mutable: props['supplyMutable'],
+          transferable: props['transferable']
+        )
+      end
+
+      def to_a
+        [
+          { name: 'divisibility', value: divisibility.to_s },
+          { name: 'initialSupply', value: initial_supply.to_s },
+          { name: 'supplyMutable', value: supply_mutable ? 'true' : 'false' },
+          { name: 'transferable', value: transferable ? 'true' : 'false' }
+        ]
+      end
+
+      def to_hash
+        to_a
+      end
+    end
+  end
+end

data/lib/nem/model/mosaic_supply.rb

@@ -0,0 +1,21 @@
+module Nem
+  module Model
+    class MosaicSupply
+      include Nem::Mixin::Assignable
+
+      extend Forwardable
+
+      def_delegators :@id, :namespace_id, :name
+
+      attr_reader :id, :supply
+
+      def self.new_from_mosaic_supply(hash)
+        id = Nem::Model::MosaicId.new_from_mosaic_id(hash[:mosaicId])
+        new(
+          id: id,
+          supply: hash[:supply]
+        )
+      end
+    end
+  end
+end

data/lib/nem/model/mosaic_supply_change_transaction.rb

@@ -0,0 +1,18 @@
+module Nem
+  module Model
+    class MosaicSupplyChangeTransaction < Transaction
+      attr_reader :supply_type, :delta, :mosaic_id
+
+      def self.new_from_transaction_meta_data_pair(hash)
+        transaction = hash[:transaction]
+        mo_id = MosaicId.new_from_mosaic_id(transaction[:mosaicId])
+        attrs = common_part_meta_data_pair(hash).merge(
+          supply_type: transaction[:supplyType],
+          delta: transaction[:delta],
+          mosaic_id: mo_id
+        )
+        new(attrs)
+      end
+    end
+  end
+end

data/lib/nem/model/multisig_aggregate_modification_transaction.rb

@@ -0,0 +1,21 @@
+module Nem
+  module Model
+    class MultisigAggregateModificationTransaction < Transaction
+      attr_reader :min_cosignatories, :relative_change, :modifications
+
+      Modification = Struct.new(:modification_type, :cosignatory_account)
+      def self.new_from_transaction_meta_data_pair(hash)
+        transaction = hash[:transaction]
+        modifications = transaction[:modifications].map do |mod|
+          Modification.new(mod[:modificationType], mod[:cosignatoryAccount])
+        end
+        attrs = common_part_meta_data_pair(hash).merge(
+          # TODO: check
+          # relative_change: transaction[:minCosignatories][:relativeChange],
+          modifications: modifications
+        )
+        new(attrs)
+      end
+    end
+  end
+end

data/lib/nem/model/multisig_info.rb

@@ -0,0 +1,16 @@
+module Nem
+  module Model
+    class MultisigInfo
+      include Nem::Mixin::Assignable
+
+      attr_reader :cosignatories_count, :min_cosignatories
+
+      def self.new_from_multisig_info(hash)
+        new(
+          cosignatories_count: hash[:cosignatoriesCount],
+          min_cosignatories: hash[:minCosignatories]
+        )
+      end
+    end
+  end
+end

data/lib/nem/model/multisig_signature_transaction.rb

@@ -0,0 +1,17 @@
+module Nem
+  module Model
+    class MultisigSignatureTransaction < Transaction
+      include Nem::Mixin::Assignable
+
+      attr_reader :other_hash, :other_account
+
+      def self.new_from_multisig_signature(hash)
+        attrs = common_part(hash).merge(
+          other_hash: hash[:otherHash][:data],
+          other_account: hash[:otherAccount]
+        )
+        new(attrs)
+      end
+    end
+  end
+end

data/lib/nem/model/multisig_transaction.rb

@@ -0,0 +1,21 @@
+module Nem
+  module Model
+    class MultisigTransaction < Transaction
+      attr_reader :other_trans, :signatures
+
+      def self.new_from_transaction_meta_data_pair(hash)
+        transaction = hash[:transaction]
+        signs = transaction[:signatures].map do |sign|
+          MultisigSignatureTransaction.new_from_multisig_signature(sign)
+        end
+        other = transaction[:otherTrans]
+        other_trans = new_from_account_transaction(other)
+        attrs = common_part_meta_data_pair(hash).merge(
+          signatures: signs,
+          other_trans: other_trans
+        )
+        new(attrs)
+      end
+    end
+  end
+end

data/lib/nem/model/namespace.rb

@@ -0,0 +1,24 @@
+module Nem
+  module Model
+    class Namespace
+      include Nem::Mixin::Assignable
+
+      attr_reader :id, :fqn, :owner, :height
+
+      def self.new_from_namespace_meta_data_pair(hash)
+        meta = hash[:meta]
+        ns = hash[:namespace]
+        new(
+          id: meta[:id],
+          fqn: ns[:fqn],
+          owner: ns[:owner],
+          height: ns[:height]
+        )
+      end
+
+      def self.new_from_namespace(hash)
+        new(hash)
+      end
+    end
+  end
+end

data/lib/nem/model/nem_announce_result.rb

@@ -0,0 +1,19 @@
+module Nem
+  module Model
+    class NemAnnounceResult
+      include Nem::Mixin::Assignable
+
+      attr_reader :type, :code, :message, :transaction_hash, :inner_transaction_hash
+
+      def self.new_from_nem_announce_result(hash)
+        new(
+          type: hash[:type],
+          code: hash[:code],
+          message: hash[:message],
+          transaction_hash: hash[:transactionHash][:data],
+          inner_transaction_hash: hash[:innerTransactionHash][:data]
+        )
+      end
+    end
+  end
+end

data/lib/nem/model/network_time.rb

@@ -0,0 +1,16 @@
+module Nem
+  module Model
+    class NetworkTime
+      include Nem::Mixin::Assignable
+
+      attr_reader :send_timestamp, :receive_timestamp
+
+      def self.new_from_network_time(hash)
+        new(
+          send_timestamp: hash[:sendTimeStamp],
+          receive_timestamp: hash[:receiveTimeStamp]
+        )
+      end
+    end
+  end
+end

data/lib/nem/model/nis_node_info.rb

@@ -0,0 +1,26 @@
+module Nem
+  module Model
+    class NisInfo
+      include Nem::Mixin::Assignable
+
+      attr_reader :current_time,
+        :application,
+        :start_time,
+        :version,
+        :signer
+    end
+
+    class NisNodeInfo
+      include Nem::Mixin::Assignable
+
+      attr_reader :node, :nis_info
+
+      def self.new_from_nis_node_info(hash)
+        new(
+          node: Node.new_from_node(hash[:node]),
+          nis_info: NisInfo.new(hash[:nisInfo])
+        )
+      end
+    end
+  end
+end