iota-ruby 1.1.8-java

data/lib/iota/crypto/bundle.rb

@@ -0,0 +1,163 @@
+module IOTA
+  module Crypto
+    class Bundle
+      attr_reader :bundle
+
+      def initialize(bundle = [])
+        bundle = bundle.map do |b|
+          if b.class != IOTA::Models::Transaction
+            IOTA::Models::Transaction.new(b)
+          else
+            b
+          end
+        end
+
+        @bundle = bundle
+      end
+
+      def addEntry(signatureMessageLength, address, value, tag, timestamp)
+        (0...signatureMessageLength).step(1) do |i|
+          transactionObject = IOTA::Models::Transaction.new(
+            address: address,
+            value: i==0 ? value : 0,
+            obsoleteTag: tag,
+            tag: tag,
+            timestamp: timestamp
+          )
+
+          @bundle << transactionObject
+        end
+      end
+
+      def addTrytes(signatureFragments)
+        emptySignatureFragment = ''
+        emptyHash = '9' * 81
+        emptyTag = '9' * 27
+        emptyTimestamp = '9' * 9
+
+        while emptySignatureFragment.length < 2187
+          emptySignatureFragment += '9'
+        end
+
+        (0...@bundle.length).step(1) do |i|
+          # Fill empty signatureMessageFragment
+          @bundle[i].signatureMessageFragment = signatureFragments[i] ? signatureFragments[i] : emptySignatureFragment
+
+          # Fill empty trunkTransaction
+          @bundle[i].trunkTransaction = emptyHash
+
+          # Fill empty branchTransaction
+          @bundle[i].branchTransaction = emptyHash
+
+          @bundle[i].attachmentTimestamp = emptyTimestamp
+          @bundle[i].attachmentTimestampLowerBound = emptyTimestamp
+          @bundle[i].attachmentTimestampUpperBound = emptyTimestamp
+
+          # Fill empty nonce
+          @bundle[i].nonce = emptyTag
+        end
+      end
+
+      def finalize
+        validBundle = false
+
+        while !validBundle
+
+          kerl = Kerl.new
+
+          (0...@bundle.length).step(1) do |i|
+            valueTrits = Converter.trits(@bundle[i].value)
+            while valueTrits.length < 81
+              valueTrits << 0
+            end
+
+            timestampTrits = Converter.trits(@bundle[i].timestamp)
+            while timestampTrits.length < 27
+              timestampTrits << 0
+            end
+
+            @bundle[i].currentIndex = i
+            currentIndexTrits = Converter.trits(@bundle[i].currentIndex)
+            while currentIndexTrits.length < 27
+              currentIndexTrits << 0
+            end
+
+            @bundle[i].lastIndex = @bundle.length - 1
+            lastIndexTrits = Converter.trits(@bundle[i].lastIndex)
+            while lastIndexTrits.length < 27
+              lastIndexTrits << 0
+            end
+
+            bundleEssence = Converter.trits(@bundle[i].address + Converter.trytes(valueTrits) + @bundle[i].obsoleteTag + Converter.trytes(timestampTrits) + Converter.trytes(currentIndexTrits) + Converter.trytes(lastIndexTrits))
+            kerl.absorb(bundleEssence, 0, bundleEssence.length)
+          end
+
+          hash = []
+          kerl.squeeze(hash, 0, Kerl::HASH_LENGTH)
+          hash = Converter.trytes(hash)
+
+          (0...@bundle.length).step(1) do |i|
+            @bundle[i].bundle = hash
+          end
+
+          normalizedHash = normalizedBundle(hash)
+          if !normalizedHash.index(13).nil?
+            # Insecure bundle. Increment Tag and recompute bundle hash.
+            increasedTagTrits = Converter.trits(@bundle[0].obsoleteTag)
+
+            # Adder implementation with 1 round
+            (0...increasedTagTrits.length).step(1) do |j|
+              increasedTagTrits[j] += 1
+
+              if increasedTagTrits[j] > 1
+                increasedTagTrits[j] = -1
+              else
+                break
+              end
+            end
+
+            @bundle[0].obsoleteTag = Converter.trytes(increasedTagTrits)
+          else
+            validBundle = true
+          end
+        end
+      end
+
+      def normalizedBundle(bundleHash)
+        normalizedBundleArr = []
+
+        (0...3).step(1) do |i|
+          sum = 0
+          (0...27).step(1) do |j|
+            normalizedBundleArr[i * 27 + j] = Converter.value(Converter.trits(bundleHash[i * 27 + j]))
+            sum += normalizedBundleArr[i * 27 + j]
+          end
+
+          if sum >= 0
+            while sum > 0
+              sum -= 1
+              (0...27).step(1) do |j|
+                if normalizedBundleArr[i * 27 + j] > -13
+                  normalizedBundleArr[i * 27 + j] -= 1
+                  break
+                end
+              end
+            end
+          else
+            while sum < 0
+              sum += 1
+              (0...27).step(1) do |j|
+                if normalizedBundleArr[i * 27 + j] < 13
+                  normalizedBundleArr[i * 27 + j] += 1
+                  break
+                end
+              end
+            end
+          end
+        end
+
+        normalizedBundleArr
+      end
+    end
+  end
+end

data/lib/iota/crypto/converter.rb

@@ -0,0 +1,244 @@
+module IOTA
+  module Crypto
+    class Converter
+      RADIX = 3
+      RADIX_BYTES = 256
+      MAX_TRIT_VALUE = 1
+      MIN_TRIT_VALUE = -1
+      BYTE_HASH_LENGTH = 48
+      HASH_LENGTH = Curl::HASH_LENGTH
+
+      # All possible tryte values
+      TRYTES_ALPHABET = "9ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+
+      TRYTE_TRITS = [
+        [ 0,  0,  0],
+        [ 1,  0,  0],
+        [-1,  1,  0],
+        [ 0,  1,  0],
+        [ 1,  1,  0],
+        [-1, -1,  1],
+        [ 0, -1,  1],
+        [ 1, -1,  1],
+        [-1,  0,  1],
+        [ 0,  0,  1],
+        [ 1,  0,  1],
+        [-1,  1,  1],
+        [ 0,  1,  1],
+        [ 1,  1,  1],
+        [-1, -1, -1],
+        [ 0, -1, -1],
+        [ 1, -1, -1],
+        [-1,  0, -1],
+        [ 0,  0, -1],
+        [ 1,  0, -1],
+        [-1,  1, -1],
+        [ 0,  1, -1],
+        [ 1,  1, -1],
+        [-1, -1,  0],
+        [ 0, -1,  0],
+        [ 1, -1,  0],
+        [-1,  0,  0]
+      ]
+
+      class << self
+        def trits(input, state = [])
+          trits = state
+
+          if input.is_a? Integer
+            absoluteValue = input < 0 ? -input : input
+
+            while absoluteValue > 0
+              remainder = absoluteValue % 3
+              absoluteValue = (absoluteValue / 3).floor
+
+              if remainder > 1
+                remainder = -1
+                absoluteValue += 1
+              end
+
+              trits[trits.length] = remainder
+            end
+
+            if input < 0
+              (0... trits.length).step(1) do |i|
+                trits[i] = -trits[i]
+              end
+            end
+          else
+            (0... input.length).step(1) do |i|
+              index = TRYTES_ALPHABET.index(input[i])
+              tmp = i * 3
+              trits[tmp...tmp+3] = TRYTE_TRITS[index]
+            end
+          end
+
+          trits
+        end
+
+        def trytes(trits)
+          trytes = ""
+
+          (0...trits.length).step(3) do |i|
+            chunk = trits[i...i+3]
+            index = TRYTE_TRITS.index(chunk)
+            if !index.nil?
+              trytes += TRYTES_ALPHABET[index]
+            end
+          end
+
+          trytes
+        end
+
+        def value(trits)
+          returnValue = 0
+
+          range = (trits.length..0)
+
+          range.first.downto(range.last).each do |i|
+            returnValue = returnValue * 3 + trits[i].to_i
+          end
+
+          returnValue
+        end
+
+        def fromValue(value)
+          destination = []
+          absoluteValue = value < 0 ? -value : value
+          i = 0
+
+          while absoluteValue > 0
+            remainder = absoluteValue % RADIX
+            absoluteValue = (absoluteValue / RADIX).floor
+
+            if remainder > MAX_TRIT_VALUE
+              remainder = MIN_TRIT_VALUE
+              absoluteValue += 1
+            end
+            destination[i] = remainder
+            i += 1
+          end
+
+          if value < 0
+            (0...destination.length).step(1) do |j|
+              # switch values
+              destination[j] = destination[j] == 0 ? 0 : -destination[j]
+            end
+          end
+
+          destination
+        end
+
+        ### ADOPTED FROM PYTHON LIBRARY
+        # Word to tryte & trytes to words conversion
+        def convertToBytes(trits)
+          bigInt = convertBaseToBigInt(trits, 3)
+          bytes_k = convertBigIntToBytes(bigInt)
+          bytes_k
+        end
+
+        def convertToTrits(bytes)
+          bigInt = convertBytesToBigInt(bytes)
+          trits = convertBigIntToBase(bigInt, 3, HASH_LENGTH)
+          trits
+        end
+
+        # Convert between signed and unsigned bytes
+        def convertSign(byte)
+          if byte < 0
+            return 256 + byte
+          elsif byte > 127
+            return -256 + byte
+          end
+          byte
+        end
+
+        def convertBaseToBigInt(array, base)
+          bigint = 0
+          (0...array.length).step(1) do |i|
+            bigint += array[i] * (base ** i)
+          end
+          bigint
+        end
+
+        def convertBigIntToBase(bigInt, base, length)
+          result = []
+
+          isNegative = bigInt < 0
+          quotient = bigInt.abs
+
+          max, _ = (isNegative ? base : base-1).divmod(2)
+
+          length.times do
+            quotient, remainder = quotient.divmod(base)
+
+            if remainder > max
+              # Lend 1 to the next place so we can make this digit negative.
+              quotient += 1
+              remainder -= base
+            end
+
+            remainder = -remainder if isNegative
+
+            result << remainder
+          end
+
+          result
+        end
+
+        def convertBigIntToBytes(big)
+          bytesArrayTemp = []
+
+          (0...48).step(1) do |pos|
+            bytesArrayTemp << (big.abs >> pos * 8) % (1 << 8)
+          end
+
+          # big endian and balanced
+          bytesArray = bytesArrayTemp.reverse.map { |x| x <= 0x7F ? x : x - 0x100 }
+
+          if big < 0
+            # 1-compliment
+            bytesArray = bytesArray.map { |x| ~x }
+
+            # add1
+            (0...bytesArray.length).reverse_each do |pos|
+              add = (bytesArray[pos] & 0xFF) + 1
+              bytesArray[pos] = add <= 0x7F ? add : add - 0x100
+              break if bytesArray[pos] != 0
+            end
+          end
+
+          bytesArray
+        end
+
+        def convertBytesToBigInt(array)
+          # copy of array
+          bytesArray = array.map { |x| x }
+
+          # number sign in MSB
+          signum = bytesArray[0] >= 0 ? 1 : -1
+
+          if signum == -1
+            # sub1
+            (0...bytesArray.length).reverse_each do |pos|
+              sub = (bytesArray[pos] & 0xFF) - 1
+              bytesArray[pos] = sub <= 0x7F ? sub : sub - 0x100
+              break if bytesArray[pos] != -1
+            end
+
+            # 1-compliment
+            bytesArray = bytesArray.map { |x| ~x }
+          end
+
+          # sum magnitudes and set sign
+          sum = 0
+          bytesArray.reverse.each_with_index do |v, pos|
+            sum += (v & 0xFF) << pos * 8
+          end
+
+          sum * signum
+        end
+      end
+    end
+  end
+end

data/lib/iota/crypto/curl.rb

@@ -0,0 +1,18 @@
+if RUBY_PLATFORM =~ /java/
+  require "iota/crypto/curl_java"
+  BaseCurl = IOTA::Crypto::JCurl
+else
+  require "iota/crypto/curl_c"
+  BaseCurl = IOTA::Crypto::CCurl
+end
+
+module IOTA
+  module Crypto
+    class Curl < BaseCurl
+      def initialize(rounds = nil)
+        rounds ||= NUMBER_OF_ROUNDS
+        super(rounds)
+      end
+    end
+  end
+end

data/lib/iota/crypto/curl_c.rb

@@ -0,0 +1,17 @@
+module IOTA
+  module Crypto
+    class CCurl
+      NUMBER_OF_ROUNDS = 81
+      HASH_LENGTH = 243
+      STATE_LENGTH = 3 * HASH_LENGTH
+
+      unless RUBY_PLATFORM =~ /java/
+        require "ccurl"
+      end
+
+      def version
+        "C"
+      end
+    end
+  end
+end

data/lib/iota/crypto/curl_java.rb

@@ -0,0 +1,18 @@
+module IOTA
+  module Crypto
+    class JCurl
+      NUMBER_OF_ROUNDS = 81
+      HASH_LENGTH = 243
+      STATE_LENGTH = 3 * HASH_LENGTH
+
+      if RUBY_PLATFORM =~ /java/
+        require 'jcurl'
+        com.vmarakana.JCurlService.new.basicLoad(JRuby.runtime)
+      end
+
+      def version
+        "Java"
+      end
+    end
+  end
+end