iota-ruby 1.1.8-java

data/lib/iota/models/base.rb

@@ -0,0 +1,13 @@
+module IOTA
+  module Models
+    class Base
+      def inspect
+        self.to_s
+      end
+
+      def symbolize_keys(hash)
+        hash.inject({}){ |h,(k,v)| h[k.to_sym] = v; h }
+      end
+    end
+  end
+end

data/lib/iota/models/bundle.rb

@@ -0,0 +1,87 @@
+module IOTA
+  module Models
+    class Bundle < Base
+      attr_reader :transactions, :persistence, :attachmentTimestamp
+
+      def initialize(transactions)
+        if transactions.class != Array
+          raise StandardError, "Invalid transactions array"
+        end
+
+        @transactions = []
+        transactions.each do |trx|
+          trx = Transaction.new(trx) if trx.class != IOTA::Models::Transaction
+          @transactions << trx
+        end
+
+        @persistence = @transactions.first.persistence
+        @attachmentTimestamp = @transactions.first.attachmentTimestamp
+      end
+
+      def extractJSON
+        utils = IOTA::Utils::Utils.new
+
+        # Sanity check: if the first tryte pair is not opening bracket, it's not a message
+        firstTrytePair = transactions[0].signatureMessageFragment[0] + transactions[0].signatureMessageFragment[1]
+
+        return nil if firstTrytePair != "OD"
+
+        index = 0
+        notEnded = true
+        trytesChunk = ''
+        trytesChecked = 0
+        preliminaryStop = false
+        finalJson = ''
+
+        while index < transactions.length && notEnded
+          messageChunk = transactions[index].signatureMessageFragment
+
+          # We iterate over the message chunk, reading 9 trytes at a time
+          (0...messageChunk.length).step(9) do |i|
+            # get 9 trytes
+            trytes = messageChunk.slice(i, 9)
+            trytesChunk += trytes
+
+            # Get the upper limit of the tytes that need to be checked
+            # because we only check 2 trytes at a time, there is sometimes a leftover
+            upperLimit = trytesChunk.length - trytesChunk.length % 2
+
+            trytesToCheck = trytesChunk[trytesChecked...upperLimit]
+
+            # We read 2 trytes at a time and check if it equals the closing bracket character
+            (0...trytesToCheck.length).step(2) do |j|
+              trytePair = trytesToCheck[j] + trytesToCheck[j + 1]
+
+              # If closing bracket char was found, and there are only trailing 9's
+              # we quit and remove the 9's from the trytesChunk.
+              if preliminaryStop && trytePair == '99'
+                notEnded = false
+                break
+              end
+
+              finalJson += utils.fromTrytes(trytePair)
+
+              # If tryte pair equals closing bracket char, we set a preliminary stop
+              # the preliminaryStop is useful when we have a nested JSON object
+              if trytePair === "QD"
+                preliminaryStop = true
+              end
+            end
+
+            break if !notEnded
+
+            trytesChecked += trytesToCheck.length;
+          end
+
+          # If we have not reached the end of the message yet, we continue with the next transaction in the bundle
+          index += 1
+        end
+
+        # If we did not find any JSON, return nil
+        return nil if notEnded
+
+        finalJson
+      end
+    end
+  end
+end

data/lib/iota/models/input.rb

@@ -0,0 +1,38 @@
+module IOTA
+  module Models
+    class Input < Base
+      attr_accessor :address, :keyIndex, :security, :balance
+
+      def initialize(options)
+        utils = IOTA::Utils::Utils.new
+        options = symbolize_keys(options)
+
+        @address = options[:address] || nil
+        if @address.nil?
+          raise StandardError, "address not provided for transfer"
+        end
+
+        if @address.length == 90 && !utils.isValidChecksum(@address)
+          raise StandardError, "Invalid checksum: #{thisTransfer[:address]}"
+        end
+
+        @address = utils.noChecksum(@address) if @address.length == 90
+
+        @keyIndex = options[:keyIndex]
+        @security = options[:security]
+        @balance = options[:balance]
+      end
+
+      def valid?
+        keysToValidate = [
+          { key: 'address', validator: :isAddress, args: nil },
+          { key: 'security', validator: :isValue, args: nil },
+          { key: 'keyIndex', validator: :isValue, args: nil }
+        ]
+
+        validator = IOTA::Utils::ObjectValidator.new(keysToValidate)
+        validator.valid?(self)
+      end
+    end
+  end
+end

data/lib/iota/models/seed.rb

@@ -0,0 +1,33 @@
+module IOTA
+  module Models
+    class Seed < Base
+      def initialize(seed)
+        @utils = IOTA::Utils::Utils.new
+
+        # Check if correct seed
+        if seed.class == String && !@utils.validator.isTrytes(seed)
+          raise StandardError, "Invalid seed provided"
+        end
+
+        seed += "9" * (81 - seed.length) if seed.length < 81
+
+        @seed = seed
+      end
+
+      def getAddress(index, security, checksum)
+        pk = IOTA::Crypto::PrivateKey.new(self.as_trits, index, security)
+        address_trits = IOTA::Crypto::Signing.address(pk.digests)
+        address = IOTA::Crypto::Converter.trytes(address_trits)
+
+        address = @utils.addChecksum(address) if checksum
+
+        address
+      end
+
+      # Converter methods
+      def as_trits
+        IOTA::Crypto::Converter.trits(@seed)
+      end
+    end
+  end
+end

data/lib/iota/models/transaction.rb

@@ -0,0 +1,52 @@
+module IOTA
+  module Models
+    class Transaction < Base
+      attr_accessor :hash, :signatureMessageFragment, :address, :value, :obsoleteTag, :timestamp, :currentIndex, :lastIndex, :bundle, :trunkTransaction, :branchTransaction, :tag, :attachmentTimestamp, :attachmentTimestampLowerBound, :attachmentTimestampUpperBound, :nonce, :persistence
+
+      def initialize(options)
+        options = symbolize_keys(options)
+        @hash = options[:hash]
+        @signatureMessageFragment = options[:signatureMessageFragment]
+        @address = options[:address]
+        @value = options[:value]
+        @obsoleteTag = options[:obsoleteTag]
+        @timestamp = options[:timestamp]
+        @currentIndex = options[:currentIndex]
+        @lastIndex = options[:lastIndex]
+        @bundle = options[:bundle]
+        @trunkTransaction = options[:trunkTransaction]
+        @branchTransaction = options[:branchTransaction]
+        @tag = options[:tag]
+        @attachmentTimestamp = options[:attachmentTimestamp]
+        @attachmentTimestampLowerBound = options[:attachmentTimestampLowerBound]
+        @attachmentTimestampUpperBound = options[:attachmentTimestampUpperBound]
+        @nonce = options[:nonce]
+        @persistence = nil
+      end
+
+      def valid?
+        keysToValidate = [
+          { key: 'hash', validator: :isHash, args: nil},
+          { key: 'signatureMessageFragment', validator: :isTrytes, args: 2187 },
+          { key: 'address', validator: :isHash, args: nil },
+          { key: 'value', validator: :isValue, args: nil },
+          { key: 'obsoleteTag', validator: :isTrytes, args: 27 },
+          { key: 'timestamp', validator: :isValue, args: nil },
+          { key: 'currentIndex', validator: :isValue, args: nil },
+          { key: 'lastIndex', validator: :isValue, args: nil },
+          { key: 'bundle', validator: :isHash, args: nil },
+          { key: 'trunkTransaction', validator: :isHash, args: nil },
+          { key: 'branchTransaction', validator: :isHash, args: nil },
+          { key: 'tag', validator: :isTrytes, args: 27 },
+          { key: 'attachmentTimestamp', validator: :isValue, args: nil },
+          { key: 'attachmentTimestampLowerBound', validator: :isValue, args: nil },
+          { key: 'attachmentTimestampUpperBound', validator: :isValue, args: nil },
+          { key: 'nonce', validator: :isTrytes, args: 27 }
+        ]
+
+        validator = IOTA::Utils::ObjectValidator.new(keysToValidate)
+        validator.valid?(self)
+      end
+    end
+  end
+end

data/lib/iota/models/transfer.rb

@@ -0,0 +1,44 @@
+module IOTA
+  module Models
+    class Transfer < Base
+      attr_accessor :address, :message, :obsoleteTag, :value, :hmacKey
+
+      def initialize(options)
+        @utils = IOTA::Utils::Utils.new
+
+        options = symbolize_keys(options)
+        @address = options[:address] || nil
+        if @address.nil?
+          raise StandardError, "address not provided for transfer"
+        end
+
+        if @address.length == 90 && !@utils.isValidChecksum(@address)
+          raise StandardError, "Invalid checksum: #{thisTransfer[:address]}"
+        end
+
+        @address = @utils.noChecksum(@address)
+
+        @message = options[:message] || ''
+        @obsoleteTag = options[:tag] || options[:obsoleteTag] || ''
+        @value = options[:value]
+        @hmacKey = options[:hmacKey] || nil
+
+        if @hmacKey
+          @message = ('9'*244) + @message
+        end
+      end
+
+      def valid?
+        keysToValidate = [
+          { key: 'address', validator: :isAddress, args: nil },
+          { key: 'value', validator: :isValue, args: nil },
+          { key: 'message', validator: :isTrytes, args: nil },
+          { key: 'obsoleteTag', validator: :isTrytes, args: '0,27' }
+        ]
+
+        validator = IOTA::Utils::ObjectValidator.new(keysToValidate)
+        validator.valid?(self)
+      end
+    end
+  end
+end

data/lib/iota/multisig/address.rb

@@ -0,0 +1,41 @@
+module IOTA
+  module Multisig
+    class Address
+      def initialize(digests = nil)
+        # Initialize kerl instance
+        @kerl = IOTA::Crypto::Kerl.new
+
+        # Add digests if passed
+        absorb(digests) if digests
+      end
+
+      def absorb(digest)
+        # Construct array
+        digests = digest.class == Array ? digest : [digest]
+
+        # Add digests
+        digests.each do |d|
+          # Get trits of digest
+          digestTrits = IOTA::Crypto::Converter.trits(d)
+
+          # Absorb
+          @kerl.absorb(digestTrits, 0, digestTrits.length)
+        end
+
+        self
+      end
+
+      def finalize(digest = nil)
+        # Absorb last digest if passed
+        absorb(digest) if digest
+
+        # Squeeze the address trits
+        addressTrits = []
+        @kerl.squeeze(addressTrits, 0, IOTA::Crypto::Kerl::HASH_LENGTH)
+
+        # Convert trits into trytes and return the address
+        IOTA::Crypto::Converter.trytes(addressTrits)
+      end
+    end
+  end
+end

data/lib/iota/multisig/multisig.rb

@@ -0,0 +1,244 @@
+module IOTA
+  module Multisig
+    class Multisig
+      def initialize(client)
+        @api = client.api
+        @utils = client.utils
+        @validator = client.validator
+        @converter = IOTA::Crypto::Converter
+        @signing = IOTA::Crypto::Signing
+      end
+
+      def getKey(seed, index, security)
+        pk = getPrivateKey(seed, index, security)
+        @converter.trytes(pk.key)
+      end
+
+      def getDigest(seed, index, security)
+        pk = getPrivateKey(seed, index, security)
+        @converter.trytes(pk.digests)
+      end
+
+      def validateAddress(multisigAddress, digests)
+        kerl = IOTA::Crypto::Kerl.new
+
+        # Absorb all key digests
+        digests.each do |digest|
+          trits = @converter.trits(digest)
+          kerl.absorb(@converter.trits(digest), 0, trits.length)
+        end
+
+        # Squeeze address trits
+        addressTrits = []
+        kerl.squeeze(addressTrits, 0, IOTA::Crypto::Kerl::HASH_LENGTH)
+
+        # Convert trits into trytes and return the address
+        @converter.trytes(addressTrits) === multisigAddress
+      end
+
+      def initiateTransfer(input, remainderAddress = nil, transfers)
+        input = IOTA::Models::Input.new(input) if input.class != IOTA::Models::Input
+
+        # If message or tag is not supplied, provide it
+        # Also remove the checksum of the address if it's there
+        (0...transfers.length).step(1) do |i|
+          transfers[i] = IOTA::Models::Transfer.new(transfers[i]) if transfers[i].class != IOTA::Models::Transfer
+        end
+
+        # Input validation of transfers object
+        raise StandardError, "Invalid transfers provided" if !@validator.isTransfersArray(transfers)
+
+        # check if int
+        raise StandardError, "Invalid inputs provided" if !@validator.isValue(input.security)
+
+        # validate input address
+        raise StandardError, "Invalid input address provided" if !@validator.isAddress(input.address)
+
+        # validate remainder address
+        raise StandardError, "Invalid remainder address provided" if remainderAddress && !@validator.isAddress(remainderAddress)
+
+        remainderAddress = @utils.noChecksum(remainderAddress) if remainderAddress && remainderAddress.length == 90
+
+        # Create a new bundle
+        bundle = IOTA::Crypto::Bundle.new
+
+        totalValue = 0
+        signatureFragments = []
+        tag = nil
+
+        # Iterate over all transfers, get totalValue and prepare the signatureFragments, message and tag
+        (0...transfers.length).step(1) do |i|
+          signatureMessageLength = 1
+
+          # If message longer than 2187 trytes, increase signatureMessageLength (add multiple transactions)
+          if transfers[i].message.length > 2187
+            # Get total length, message / maxLength (2187 trytes)
+            signatureMessageLength += (transfers[i].message.length / 2187).floor
+
+            msgCopy = transfers[i].message
+
+            # While there is still a message, copy it
+            while msgCopy
+              fragment = msgCopy.slice(0, 2187)
+              msgCopy = msgCopy.slice(2187, msgCopy.length)
+
+              # Pad remainder of fragment
+              fragment += (['9']*(2187-fragment.length)).join('') if fragment.length < 2187
+
+              signatureFragments.push(fragment)
+            end
+          else
+            # Else, get single fragment with 2187 of 9's trytes
+            fragment = ''
+
+            fragment = transfers[i].message.slice(0, 2187) if transfers[i].message
+
+            # Pad remainder of fragment
+            fragment += (['9']*(2187-fragment.length)).join('') if fragment.length < 2187
+
+            signatureFragments.push(fragment)
+          end
+
+          # get current timestamp in seconds
+          timestamp = Time.now.utc.to_i
+
+          # If no tag defined, get 27 tryte tag.
+          tag = transfers[i].obsoleteTag ? transfers[i].obsoleteTag : (['9']*27).join('')
+
+          # Pad for required 27 tryte length
+          tag += (['9']*(27-tag.length)).join('') if tag.length < 27
+
+          # Add first entries to the bundle
+          # Slice the address in case the user provided a checksummed one
+          bundle.addEntry(signatureMessageLength, transfers[i].address.slice(0, 81), transfers[i].value, tag, timestamp)
+
+          # Sum up total value
+          totalValue += transfers[i].value.to_i
+        end
+
+        # Get inputs if we are sending tokens
+        if totalValue > 0
+          if input.balance
+            return createBundle(input.balance, totalValue, bundle, input, remainderAddress, tag, signatureFragments)
+          else
+            @api.getBalances([input.address], 100) do |st1, balances|
+              if !st1
+                raise StandardError, "Error fetching balances: #{balances}"
+              else
+                return createBundle(balances[0].to_i, totalValue, bundle, input, remainderAddress, tag, signatureFragments)
+              end
+            end
+          end
+        else
+          raise StandardError, "Invalid value transfer: the transfer does not require a signature."
+        end
+      end
+
+      def addSignature(bundleToSign, inputAddress, key)
+        bundleToSign = [bundleToSign] if bundleToSign.class != Array
+        bundle = IOTA::Crypto::Bundle.new(bundleToSign)
+
+        # Get the security used for the private key
+        # 1 security level = 2187 trytes
+        security = (key.length / 2187).to_i
+
+        # convert private key trytes into trits
+        key = @converter.trits(key)
+
+        # First get the total number of already signed transactions
+        # use that for the bundle hash calculation as well as knowing
+        # where to add the signature
+        numSignedTxs = 0
+
+        (0...bundle.bundle.length).step(1) do |i|
+          bundle.bundle[i] = IOTA::Models::Transaction.new(bundle.bundle[i]) if bundle.bundle[i].class != IOTA::Models::Transaction
+          if bundle.bundle[i].address === inputAddress
+            # If transaction is already signed, increase counter
+            if !@validator.isAllNine(bundle.bundle[i].signatureMessageFragment)
+              numSignedTxs += 1
+            else
+              # sign the transactions
+              bundleHash = bundle.bundle[i].bundle
+
+              # First 6561 trits for the firstFragment
+              firstFragment = key.slice(0, 6561)
+
+              # Get the normalized bundle hash
+              normalizedBundleHash = bundle.normalizedBundle(bundleHash)
+              normalizedBundleFragments = []
+
+              # Split hash into 3 fragments
+              (0...3).step(1) do |k|
+                normalizedBundleFragments[k] = normalizedBundleHash.slice(k * 27, 27)
+              end
+
+              # First bundle fragment uses 27 trytes
+              firstBundleFragment = normalizedBundleFragments[numSignedTxs % 3]
+
+              # Calculate the new signatureFragment with the first bundle fragment
+              firstSignedFragment = @signing.signatureFragment(firstBundleFragment, firstFragment)
+
+              # Convert signature to trytes and assign the new signatureFragment
+              bundle.bundle[i].signatureMessageFragment = @converter.trytes(firstSignedFragment)
+
+              (1...security).step(1) do |j|
+                # Next 6561 trits for the firstFragment
+                nextFragment = key.slice(6561 * j, 6561)
+
+
+                # Use the next 27 trytes
+                nextBundleFragment = normalizedBundleFragments[(numSignedTxs + j) % 3]
+
+                # Calculate the new signatureFragment with the first bundle fragment
+                nextSignedFragment = @signing.signatureFragment(nextBundleFragment, nextFragment)
+
+                # Convert signature to trytes and add new bundle entry at i + j position
+                # Assign the signature fragment
+                bundle.bundle[i + j].signatureMessageFragment = @converter.trytes(nextSignedFragment)
+              end
+
+              break
+            end
+          end
+        end
+
+        bundle.bundle
+      end
+
+      private
+      def getPrivateKey(seed, index, security)
+        seed = IOTA::Models::Seed.new(seed) if seed.class != IOTA::Models::Seed
+        IOTA::Crypto::PrivateKey.new(seed.as_trits, index, security)
+      end
+
+      def createBundle(totalBalance, totalValue, bundle, input, remainderAddress, tag, signatureFragments)
+        if totalBalance > 0
+          toSubtract = 0 - totalBalance
+          timestamp = Time.now.utc.to_i
+
+          # Add input as bundle entry
+          # Only a single entry, signatures will be added later
+          bundle.addEntry(input.security, input.address, toSubtract, tag, timestamp)
+        end
+
+        raise StandardError, "Not enough balance" if totalValue > totalBalance
+
+        # If there is a remainder value
+        # Add extra output to send remaining funds to
+        if totalBalance > totalValue
+          remainder = totalBalance - totalValue
+
+          # Remainder bundle entry if necessary
+          return StandardError, "No remainder address defined" if !remainderAddress
+
+          bundle.addEntry(1, remainderAddress, remainder, tag, timestamp)
+        end
+
+        bundle.finalize()
+        bundle.addTrytes(signatureFragments)
+
+        bundle.bundle
+      end
+    end
+  end
+end