nis-ruby 0.0.16 → 0.0.17

data/lib/nis/struct/transfer_transaction.rb

@@ -0,0 +1,11 @@
+class Nis::Struct
+  # @attr [String]  recipient
+  # @attr [Integer] amount
+  # @attr [Nis::Struct::Message] message
+  # @attr [Array <Nis::Struct::MosaicId>] mosaics
+  # @see https://nemproject.github.io/#version-1-transfer-transactions
+  # @see https://nemproject.github.io/#version-2-transfer-transactions
+  class TransferTransaction < Transaction
+    attr_accessor :recipient, :amount, :message, :mosaics
+  end
+end

data/lib/nis/unit/address.rb

@@ -27,6 +27,11 @@ module Nis::Unit
       @first_char == 'T'
     end
 
+    # @return [Boolean]
+    def mijin?
+      @first_char == 'M'
+    end
+
     # @return [String]
     def to_s
       @value
@@ -34,7 +39,7 @@ module Nis::Unit
 
     # @return [String]
     def to_hexadecimal
-      @value.each_byte.map { |b| b.to_s(16) }.join
+      @value.each_byte.inject('') { |memo, b| memo << b.to_s(16) }
     end
 
     # @return [Boolean]
@@ -43,14 +48,16 @@ module Nis::Unit
     end
 
     def self.from_public_key(public_key, network = :testnet)
-      bin_public_key = public_key.scan(/../).map(&:hex).pack('C*')
+      bin_public_key = Nis::Util::Convert.hex2bin(public_key)
       public_key_hash = Digest::SHA3.digest(bin_public_key, 256)
       ripe = OpenSSL::Digest::RIPEMD160.digest(public_key_hash)
 
       if network == :testnet
-        version = "\x98".force_encoding('ASCII-8BIT') + ripe
+        version = "\x98".force_encoding('ASCII-8BIT') << ripe
+      elsif network == :mijin
+        version = "\x60" << ripe
       else
-        version = "\x68" + ripe
+        version = "\x68" << ripe
       end
 
       checksum = Digest::SHA3.digest(version, 256)[0...4]

data/lib/nis/util.rb

@@ -1,4 +1,5 @@
 module Nis::Util
+  MIJIN   = 0x60000000
   TESTNET = 0x98000000 # -1744830464
   MAINNET = 0x68000000 #  1744830464
 
@@ -23,6 +24,7 @@ module Nis::Util
 
   def self.parse_network(network)
     case network
+    when :mijin then MIJIN
     when :mainnet then MAINNET
     when :testnet then TESTNET
       else TESTNET
@@ -38,7 +40,7 @@ module Nis::Util
   end
 
   def self.timestamp
-    (Time.now - NEM_EPOCH).to_i
+    (Time.now.utc - NEM_EPOCH).to_i
   end
 
   def self.error_handling(hash)

data/lib/nis/util/convert.rb

@@ -16,37 +16,47 @@ module Nis::Util
       hex.scan(/../).map(&:hex)
     end
 
-    # Convert an Uint8Array to hex
-    # @param [Uint8Array] ua - An Uint8Array
-    # @return [string]
-    def self.ua2hex(ua)
-      ua.map { |el| "#{HEX_ENCODE_ARRAY[el >> 4]}#{HEX_ENCODE_ARRAY[el & 0x0f]}" }.join
-    end
-
     # Convert hex to string
     # @param [String] hex
     # @return [String]
     def self.hex2a(hex)
-      hex.scan(/../).map { |el| el.to_i(16).chr }.join
+      hex.scan(/../).inject('') { |memo, el| memo << el.hex.chr }
+    end
+
+    # @param [Array] bin
+    # @return [String]
+    def self.hex2bin(hex)
+      hex2ua(hex).pack('C*')
+    end
+
+    # @param [Array] bin
+    # @return [String]
+    def self.hex2bin_rev(hex)
+      hex2ua_rev(hex).pack('C*')
+    end
+
+    # @param [Array] bin
+    # @return [String]
+    def self.bin2hex(bin)
+      bin.map { |v| '%02x' % v }.join
     end
 
     # Convert UTF-8 to hex
     # @param [string] str
     # @return [string]
     def self.utf8_to_hex(str)
-      rstr2utf8(str).each_byte.map { |b| b.to_s(16) }.join
+      rstr2utf8(str).bytes.inject('') { |memo, b| memo << b.to_s(16) }
     end
 
-    # // Padding helper for above function
-    # let strlpad = function(str, pad, len) {
-    #     while (str.length < len) {
-    #         str = pad + str;
-    #     }
-    #     return str;
-    # }
+    # Convert an Array to hex
+    # @param [Array] ua - An Uint8Array
+    # @return [string]
+    def self.ua2hex(ua)
+      ua.inject('') { |memo, el| memo << "#{HEX_ENCODE_ARRAY[el >> 4]}#{HEX_ENCODE_ARRAY[el & 0x0f]}" }
+    end
 
     # Convert an Uint8Array to WordArray
-    # @param [Uint8Array] ua - An Uint8Array
+    # @param [Array] ua - An Uint8Array
     # @param [number] uaLength - The Uint8Array length
     # @return [WordArray]
     def self.ua2words(ua, ua_length)
@@ -60,58 +70,41 @@ module Nis::Util
     end
 
     # Convert a wordArray to Uint8Array
-    # @param [Uint8Array] destUa - A destination Uint8Array
-    # @param [WordArray] cryptowords - A wordArray
-    # @return [Uint8Array]
+    # @param [Array] destUa - A destination Uint8Array
+    # @param [Array] cryptowords - A wordArray
+    # @return [Array]
     def self.words2ua(words)
-      words.map do |v|
+      words.inject([]) do |memo, v|
         temp = []
         v += 0x100000000 if v < 0
         temp[0] = (v >> 24)
         temp[1] = (v >> 16) & 0xff
         temp[2] = (v >> 8) & 0xff
         temp[3] = (v) & 0xff
-        temp
-      end.flatten
+        memo + temp
+      end
     end
 
     # Converts a raw javascript string into a string of single byte characters using utf8 encoding.
     # This makes it easier to perform other encoding operations on the string.
     # @param [String] str
     # @return [String]
-    def self.rstr2utf8(input)
-      input.unpack('U*').map do |c|
-        case
-        when c < 128
-          c
-        when 128 < c && c < 2048
-          [((c >> 6) | 192), ((c & 63) | 128)]
-        else
-          [((c >> 12) | 224), (((c >> 6) & 63) | 128), ((c & 63) | 128)]
+    def self.rstr2utf8(str)
+      str.unpack('U*').inject('') do |memo, c|
+        memo << case
+                when c < 128
+                  c.chr
+                when 128 < c && c < 2048
+                  (c >> 6 | 192).chr + (c & 63 | 128).chr
+          else
+                  (c >> 12 | 224).chr + (c >> 6 & 63 | 128).chr + (c & 63 | 128).chr
         end
-      end.flatten.map(&:chr).join
+      end
     end
 
     # Does the reverse of rstr2utf8.
     def utf82rstr(input)
-        # let output = "", i = 0, c = 0, c1 = 0, c2 = 0, c3 = 0;
-        # while (i < input.length) {
-        #     c = input.charCodeAt(i);
-        #     if (c < 128) {
-        #         output += String.fromCharCode(c);
-        #         i++;
-        #     } else if ((c > 191) && (c < 224)) {
-        #         c2 = input.charCodeAt(i + 1);
-        #         output += String.fromCharCode(((c & 31) << 6) | (c2 & 63));
-        #         i += 2;
-        #     } else {
-        #         c2 = input.charCodeAt(i + 1);
-        #         c3 = input.charCodeAt(i + 2);
-        #         output += String.fromCharCode(((c & 15) << 12) | ((c2 & 63) << 6) | (c3 & 63));
-        #         i += 3;
-        #     }
-        # }
-        # return output;
+      raise 'Not implemented.'
     end
   end
 end

data/lib/nis/util/deserializer.rb

@@ -5,7 +5,9 @@ module Nis::Util
     # @return [Hash]
     def self.deserialize_transaction(serialized)
       s = Nis::Util::Convert.hex2ua(serialized)
-      type = deserialize_int(s[0, 4])
+      common = s[0, 60]
+      specific = s[60, s.size]
+      type = deserialize_int(common[0, 4])
       method = case type
                when 0x0101 then method(:deserialize_transfer)
                when 0x0801 then method(:deserialize_importance_transfer)
@@ -17,143 +19,126 @@ module Nis::Util
                when 0x4002 then method(:deserialize_mosaic_supply_change)
         else raise "Not implemented entity type: #{type}"
       end
-      method.call(serialized)
+      deserialize_common(common).merge(method.call(specific))
     end
 
+    private
+
     # Deserialize a transfer transaction object
     # @param [String] serialized
     # @return [Hash]
-    def self.deserialize_transfer(serialized)
-      s = Nis::Util::Convert.hex2ua(serialized)
-      common = deserialize_common(s)
+    def self.deserialize_transfer(s)
       tx = {}
-      # s[60,4] # length of  address
-      tx[:recipient] = deserialize_a(s[64, 40])
-      tx[:amount] = deserialize_int(s[104, 8])
+      tx[:recipient] = deserialize_a(s[4, 40])
+      tx[:amount] = deserialize_int(s[44, 8])
       tx[:message] = {}
-      message_len = deserialize_int(s[112, 4])
+      message_len = deserialize_int(s[52, 4])
       if message_len > 0
-        tx[:message][:type] = deserialize_int(s[116, 4])
-        # s[120, 4] # length of payload
-        tx[:message][:payload] = deserialize_hex(s[124, s.size])
+        # s[60, 4] # length of payload
+        tx[:message] = {
+          type: deserialize_int(s[56, 4]),
+          payload: deserialize_hex(s[64, s.size])
+        }
       else
         tx[:message] = { type: 1, payload: '' }
       end
-      common.merge(tx)
+      tx
     end
 
     # Deserialize a importance transaction object
     # @param [String] serialized
     # @return [Hash]
-    def self.deserialize_importance_transfer(serialized)
-      s = Nis::Util::Convert.hex2ua(serialized)
-      common = deserialize_common(s)
-      tx = {}
-      tx[:mode] = deserialize_int(s[60, 4])
-      # s[64, 4] # Length of remote account public key byte array
-      tx[:remoteAccount] = deserialize_hex(s[68, 32])
-      common.merge(tx)
+    def self.deserialize_importance_transfer(s)
+      {
+        mode: deserialize_int(s[0, 4]),
+        remoteAccount: deserialize_hex(s[8, 32])
+      }
     end
 
     # Deserialize a multisig aggregate modification transaction object
     # @param [String] serialized
     # @return [Hash]
-    def self.deserialize_multisig_aggregate_modification(serialized)
+    def self.deserialize_multisig_aggregate_modification(s)
       raise 'Not yet implimented.'
-      s = Nis::Util::Convert.hex2ua(serialized)
-      common = deserialize_common(s)
-      tx = {}
       # TODO: deserializing
-      common.merge(tx)
+      tx = {}
+      tx
     end
 
     # Deserialize a multisig signature transaction object
     # @param [String] serialized
     # @return [Hash]
-    def self.deserialize_multisig_signature(serialized)
-      s = Nis::Util::Convert.hex2ua(serialized)
-      common = deserialize_common(s)
-      tx = {}
-      tx[:otherHash] = { data: deserialize_hex(s[68, 32]) }
-      tx[:otherAccount] = deserialize_a(s[104, 40])
-      common.merge(tx)
+    def self.deserialize_multisig_signature(s)
+      {
+        otherHash: { data: deserialize_hex(s[8, 32]) },
+        otherAccount: deserialize_a(s[44, 40])
+      }
     end
 
     # Deserialize a multisig transfer transaction object
     # @param [String] serialized
     # @return [Hash]
-    def self.deserialize_multisig(serialized)
+    def self.deserialize_multisig(s)
       raise 'Not yet implimented.'
-      s = Nis::Util::Convert.hex2ua(serialized)
-      common = deserialize_common(s)
-      tx = {}
       # TODO: deserializing
-      common.merge(tx)
+      tx = {}
+      tx
     end
 
     # Deserialize a provision namespace transaction object
     # @param [String] serialized
     # @return [Hash]
-    def self.deserialize_provision_namespace(serialized)
-      s = Nis::Util::Convert.hex2ua(serialized)
-      common = deserialize_common(s)
+    def self.deserialize_provision_namespace(s)
       tx = {}
-      # s[60, 4] # Length of rental fee sink's public key byte array (always 32): 4 bytes
-      tx[:rentalFeeSink] = deserialize_a(s[64, 40]) # Public key bytes of rental fee sink
-      tx[:rentalFee] = deserialize_int(s[104, 8]) # Fental fee: 8 bytes
-      newpart_len = deserialize_int(s[112, 4]) # Length of new part string: 4 bytes
-      tx[:newPart] = deserialize_a(s[116, newpart_len]) # New part string: UTF8 encoded string.
-      parent_len = deserialize_int(s[116 + newpart_len, 4]) # Length of parent string: 4 bytes
-      parent = s[116 + newpart_len, parent_len]
+      tx[:rentalFeeSink] = deserialize_a(s[4, 40])
+      tx[:rentalFee] = deserialize_int(s[44, 8])
+      newpart_len = deserialize_int(s[52, 4])
+      tx[:newPart] = deserialize_a(s[56, newpart_len])
+      parent_len = deserialize_int(s[56 + newpart_len, 4])
+      parent = s[56 + newpart_len, parent_len]
       unless parent.all? { |val| val == 0xff }
-        tx[:parent] = deserialize_a(parent) # Parent string: UTF8 encoded string
+        tx[:parent] = deserialize_a(parent)
       end
-      common.merge(tx)
+      tx
     end
 
     # Deserialize a mosaic definition creation transaction object
     # @param [String] serialized
     # @return [Hash]
-    def self.deserialize_mosaic_definition_creation(serialized)
+    def self.deserialize_mosaic_definition_creation(s)
       raise 'Not yet implimented.'
-      s = Nis::Util::Convert.hex2ua(serialized)
-      common = deserialize_common(s)
-      tx = {}
       # TODO: deserializing
-      common.merge(tx)
+      tx = {}
+      tx
     end
 
     # Deserialize a mosaic supply change transaction object
     # @param [String] serialized
     # @return [Hash]
-    def self.deserialize_mosaic_supply_change(serialized)
-      s = Nis::Util::Convert.hex2ua(serialized)
-      common = deserialize_common(s)
+    def self.deserialize_mosaic_supply_change(s)
       tx = {}
-      # s[60, 4] # Length of mosaic id structure
-      ns_len = deserialize_int(s[64, 4]) # Length of namespace id string
-      mo_len = deserialize_int(s[68 + ns_len, 4]) # Length of mosaic name string
+      # s[0, 4] # Length of mosaic id structure
+      ns_len = deserialize_int(s[4, 4])
+      mo_len = deserialize_int(s[8 + ns_len, 4])
       tx[:mosaicId] = {
-        namespaceId: deserialize_a(s[68, ns_len]),
-        name: deserialize_a(s[68 + ns_len + mo_len, mo_len])
+        namespaceId: deserialize_a(s[8, ns_len]),
+        name: deserialize_a(s[8 + ns_len + mo_len, mo_len])
       }
-      tx[:supplyType] = deserialize_int(s[68 + ns_len + 4 + mo_len, 4]) # Supply type
-      tx[:delta] = deserialize_int(s[68 + ns_len + 4 + mo_len + 4, 8]) # Delta (change in supply)
-      common.merge(tx)
+      tx[:supplyType] = deserialize_int(s[8 + ns_len + 4 + mo_len, 4])
+      tx[:delta] = deserialize_int(s[8 + ns_len + 4 + mo_len + 4, 8])
+      tx
     end
 
-    private
-
     def self.deserialize_common(s)
-      tx = {}
-      tx[:type] = deserialize_int(s[0, 4])
-      tx[:version] = deserialize_int(s[4, 4])
-      tx[:timeStamp] = deserialize_int(s[8, 4])
-      # s[12,4] # length of public key
-      tx[:signer] = deserialize_hex(s[16, 32])
-      tx[:fee] = deserialize_int(s[48, 8])
-      tx[:deadline] = deserialize_int(s[56, 4])
-      tx
+      {
+        type: deserialize_int(s[0, 4]),
+        version: deserialize_int(s[4, 4]),
+        timeStamp: deserialize_int(s[8, 4]),
+        # s[12,4] # length of public key,
+        signer: deserialize_hex(s[16, 32]),
+        fee: deserialize_int(s[48, 8]),
+        deadline: deserialize_int(s[56, 4])
+      }
     end
 
     def self.deserialize_int(ua)

data/lib/nis/util/ed25519.rb

@@ -15,7 +15,7 @@ module Nis::Util
       end
 
       def intlist2bytes(l)
-        l.map { |c| c.chr }.join
+        l.inject('') { |memo, c| memo << c.chr }
       end
 
       # standard implement
@@ -29,7 +29,7 @@ module Nis::Util
 
       def pow2(x, p)
         while p > 0 do
-          x = x * x % @@q
+          x = x.to_bn.mod_exp(2, @@q).to_i
           p -= 1
         end
         x
@@ -112,7 +112,7 @@ module Nis::Util
 
       def make_Bpow
         _P = @@B
-        (0...253).each do |_|
+        253.times do
           @@Bpow << _P
           _P = edwards_double(_P)
         end
@@ -123,7 +123,7 @@ module Nis::Util
         # scalarmult(B, l) is the identity
         e = e % @@l
         _P = @@ident
-        (0...253).each do |i|
+        253.times do |i|
           _P = edwards_add(_P, @@Bpow[i]) if e & 1 == 1
           e = e / 2
         end
@@ -132,7 +132,7 @@ module Nis::Util
 
       def encodeint(y)
         bits = (0...@@b).map { |i| (y >> i) & 1 }
-        (0...@@b / 8).map { |i| int2byte((0...8).inject(0) { |sum, j| sum + (bits[i * 8 + j] << j) }) }.join
+        (0...@@b / 8).inject('') { |memo, i| memo << int2byte((0...8).inject(0) { |sum, j| sum + (bits[i * 8 + j] << j) }) }
       end
 
       def encodepoint(_P)
@@ -141,7 +141,7 @@ module Nis::Util
         x = (x * zi) % @@q
         y = (y * zi) % @@q
         bits = (0...@@b - 1).map { |i| (y >> i) & 1 } + [x & 1]
-        (0...@@b / 8).map { |i| int2byte((0...8).inject(0) { |sum, j| sum + (bits[i * 8 + j] << j) }) }.join
+        (0...@@b / 8).inject('') { |memo, i| memo << int2byte((0...8).inject(0) { |sum, j| sum + (bits[i * 8 + j] << j) }) }
       end
 
       def bit(h, i)
@@ -169,15 +169,13 @@ module Nis::Util
         bin_g = encodepoint(scalarmult(_A, a))
 
         bin_iv = SecureRandom.random_bytes(16)
-        # bin_iv = [133, 235, 90, 141, 29, 234, 234, 20, 115, 237, 164, 88, 224, 87, 29, 82].pack('C*')
-        hex_iv = bin_iv.unpack('H*').join
+        hex_iv = bin_iv.unpack('H*').first
 
         bin_salt = SecureRandom.random_bytes(32)
-        # bin_salt = [35, 150, 208, 176, 6, 179, 135, 220, 197, 253, 164, 147, 164, 177, 228, 43, 143, 146, 245, 255, 226, 71, 44, 94, 218, 169, 117, 88, 98, 241, 115, 79].pack('C*')
-        hex_salt = bin_salt.unpack('H*').join
+        hex_salt = bin_salt.unpack('H*').first
 
         ua_salt = Nis::Util::Convert.hex2ua(hex_salt)
-        ua_g = Nis::Util::Convert.hex2ua(bin_g.unpack('H*').join)
+        ua_g = Nis::Util::Convert.hex2ua(bin_g.unpack('H*').first)
 
         c = []
         ua_salt.each_with_index { |el, idx| c << (el ^ ua_g[idx]) }
@@ -188,7 +186,7 @@ module Nis::Util
         cipher.key = bin_key
         cipher.iv = bin_iv
         encrypted_data = cipher.update(data.bytes.pack('C*')) + cipher.final
-        hex_salt + hex_iv + encrypted_data.unpack('H*').join
+        hex_salt + hex_iv + encrypted_data.unpack('H*').first
       end
 
       def decrypt(sk, pk, data)