iota-ruby 1.0.1

data/lib/iota/models/account.rb

@@ -0,0 +1,470 @@
+module IOTA
+  module Models
+    class Account < Base
+      attr_reader :client, :seed, :latestAddress, :addresses, :transfers, :inputs, :balance
+
+      def initialize(client, seed)
+        @api = client.api
+        @validator = client.validator
+        @utils = client.utils
+        @seed = seed.class == String ? Seed.new(seed) : seed
+
+        reset
+      end
+
+      def reset
+        @latestAddress = nil
+        @addresses = []
+        @transfers = []
+        @inputs = []
+        @balance = 0.0
+      end
+
+      def getAccountDetails(options = {}, fetchInputs = true, fetchTransfers = true)
+        reset
+        options = symbolize_keys(options)
+        startIndex = options[:start] || 0
+        endIndex = options[:end] || nil
+        security = options[:security] || 2
+
+        # If start value bigger than end, return error or if difference between end and start is bigger than 1000 keys
+        if endIndex && (startIndex > endIndex || endIndex > (startIndex + 1000))
+          raise StandardError, "Invalid inputs provided"
+        end
+
+        addressOptions = {
+          index: startIndex,
+          total: endIndex ? endIndex - startIndex : nil,
+          returnAll: true,
+          security: security,
+          checksum: true
+        }
+
+        # Get a list of all addresses associated with the users seed
+        addresses = getNewAddress(addressOptions)
+
+        # assign the last address as the latest address
+        # since it has no transactions associated with it
+        @latestAddress = addresses.last
+
+        # Add all returned addresses to the lsit of addresses
+        # remove the last element as that is the most recent address
+        @addresses = addresses.slice(0, addresses.length)
+
+        if fetchInputs
+          # Get the correct balance count of all addresses
+          @api.getBalances(addresses, 100) do |status2, balancesData|
+            if !status2
+              raise StandardError, balancesData
+            end
+
+            balancesData['balances'].each_with_index do |balance, index|
+              balance = balance.to_i
+              @balance += balance
+
+              if balance > 0
+                @inputs << IOTA::Models::Input.new(
+                  address: @addresses[index],
+                  keyIndex: index,
+                  security: security,
+                  balance: balance
+                )
+              end
+            end
+          end
+        end
+
+        if fetchTransfers
+          # get all bundles from a list of addresses
+          @api.bundlesFromAddresses(addresses, true) do |status1, bundlesData|
+            if !status1
+              raise StandardError, bundlesData
+            end
+
+            # add all transfers
+            @transfers = bundlesData
+          end
+        end
+
+        self
+      end
+
+      def getInputs(options = {})
+        self.getAccountDetails(options, true, false)
+        @inputs
+      end
+
+      def getTransfers(options = {})
+        self.getAccountDetails(options, false, true)
+        @transfers
+      end
+
+      def prepareTransfers(transfers, options = {})
+        options = symbolize_keys(options)
+        hmacKey = options[:hmacKey] || nil
+        if !hmacKey.nil?
+          raise StandardError, "Invalid trytes provided: #{hmacKey}" if !@validator.isTrytes(hmacKey)
+        end
+
+        # If message or tag is not supplied, provide it
+        # Also remove the checksum of the address if it's there after validating it
+        (0...transfers.length).step(1) do |index|
+          if transfers[index].class != IOTA::Models::Transfer
+            transfers[index] = IOTA::Models::Transfer.new(transfers[index].merge({ hmacKey: hmacKey }))
+          end
+        end
+
+        # Input validation of transfers object
+        raise StandardError, "Invalid transfers provided" if !@validator.isTransfersArray(transfers)
+
+        # If inputs provided, validate the format
+        chosenInputs = options[:inputs] || nil
+        raise StandardError, "Invalid inputs provided" if chosenInputs && !@validator.isInputs(chosenInputs)
+
+        remainderAddress = options[:address] || nil
+        chosenInputs = chosenInputs || []
+        security = options[:security] || 2
+
+        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 2nd transaction)
+          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[0...2187]
+              msgCopy = msgCopy[2187...msgCopy.length]
+
+              # Pad remainder of fragment
+              while fragment.length < 2187
+                fragment += '9'
+              end
+
+              signatureFragments << fragment
+            end
+          else
+            # Else, get single fragment with 2187 of 9's trytes
+            fragment = ''
+
+            fragment = transfers[i].message[0...2187] if transfers[i].message
+
+            while fragment.length < 2187
+              fragment += '9'
+            end
+
+            signatureFragments << 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 || ''
+
+          # Pad for required 27 tryte length
+          while tag.length < 27
+            tag += '9'
+          end
+
+          # Add first entries to the bundle
+          # Slice the address in case the user provided a checksummed one
+          bundle.addEntry(signatureMessageLength, transfers[i].address, 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
+          #  Case 1: user provided inputs
+          #
+          #  Validate the inputs by calling getBalances
+          if chosenInputs && chosenInputs.length > 0
+            # Get list if addresses of the provided inputs
+            inputsAddresses = [];
+            (0...chosenInputs.length).step(1) do |i|
+              if chosenInputs[i].class != IOTA::Models::Input
+                chosenInputs[i] = IOTA::Models::Input.new(chosenInputs[i])
+              end
+              inputsAddresses << chosenInputs[i].address
+            end
+
+            @api.getBalances(inputsAddresses, 100) do |status, balances|
+              raise StandardError, balances if !status
+
+              confirmedInputs = []
+              totalBalance = 0
+
+              balances['balances'].each_with_index do |balance, i|
+                # If input has balance, add it to confirmedInputs
+                balance = balance.to_i
+
+                if balance > 0
+                  totalBalance += balance
+
+                  input = chosenInputs[i]
+                  input.balance = balance
+
+                  confirmedInputs << input
+
+                  # if we've already reached the intended input value, break out of loop
+                  if totalBalance >= totalValue
+                    break
+                  end
+                end
+              end
+
+              # Return not enough balance error
+              raise StandardError, "Not enough balance" if totalValue > totalBalance
+
+              return addRemainder(confirmedInputs, totalValue, bundle, tag, security, signatureFragments, remainderAddress, hmacKey)
+            end
+          else
+            # Case 2: Get inputs deterministically
+            # If no inputs provided, derive the addresses from the seed and
+            # confirm that the inputs exceed the threshold
+            self.getInputs(security: security)
+
+            raise StandardError, "Not enough balance" if totalValue > @balance
+
+            return addRemainder(@inputs, totalValue, bundle, tag, security, signatureFragments, remainderAddress, hmacKey)
+          end
+        else
+          # If no input required, don't sign and simply finalize the bundle
+          bundle.finalize()
+          bundle.addTrytes(signatureFragments)
+
+          bundleTrytes = []
+          bundle.bundle.each do |bndl|
+            bundleTrytes << @utils.transactionTrytes(bndl)
+          end
+
+          return bundleTrytes.reverse
+        end
+      end
+
+      def sendTransfer(depth, minWeightMagnitude, transfers, options = {})
+        # Check if correct depth and minWeightMagnitude
+        if !@validator.isValue(depth) || !@validator.isValue(minWeightMagnitude)
+          raise StandardError, "Invalid inputs provided"
+        end
+
+        trytes = prepareTransfers(transfers, options)
+        @api.sendTrytes(trytes, depth, minWeightMagnitude) do |status, data|
+          if !status
+            raise StandardError, data
+          else
+            return data
+          end
+        end
+      end
+
+      def getNewAddress(options = {})
+        # default index value
+        options = symbolize_keys(options)
+        index = options[:index] || 0
+
+        # validate the index option
+        if !@validator.isValue(index) || index < 0
+          raise StandardError, "Invalid index provided: #{index}"
+        end
+
+        checksum = options[:checksum] || false
+        total = options[:total] || nil
+        return_all = options[:returnAll] || false
+
+        # If no user defined security, use the standard value of 2
+        security = options[:security] || 2
+
+        # validate the security option
+        if !@validator.isValue(security) || security < 1 || security > 3
+          raise StandardError, "Invalid security provided: #{index}"
+        end
+
+        allAddresses = []
+
+        # Case 1: total
+        #
+        # If total number of addresses to generate is supplied, simply generate
+        # and return the list of all addresses
+        if total
+            # Increase index with each iteration
+            (0...total).step(1) do |i|
+              address = @seed.getAddress(index, security, checksum)
+              allAddresses << address
+              index += 1
+            end
+
+            return allAddresses
+        else
+          #  Case 2: no total provided
+          #
+          # Continue calling findTransactions to see if address was already created
+          #  if null, return list of addresses
+          loop do
+            newAddress = @seed.getAddress(index, security, checksum)
+
+            @api.findTransactions(addresses: [newAddress]) do |status, trx_hashes|
+              if !status
+                raise StandardError, trx_hashes
+              end
+
+              if return_all
+                allAddresses << newAddress
+              end
+
+              index += 1
+
+              return (return_all ? allAddresses : newAddress) if trx_hashes.length == 0
+            end
+          end
+        end
+      end
+
+      private
+      def addRemainder(inputs, totalValue, bundle, tag, security, signatureFragments, remainderAddress, hmacKey)
+        totalTransferValue = totalValue
+        inputs.each do |input|
+          balance = input.balance
+          timestamp = Time.now.utc.to_i
+
+          # Add input as bundle entry
+          bundle.addEntry(input.security, input.address, -balance, tag, timestamp)
+
+          # If there is a remainder value
+          # Add extra output to send remaining funds to
+          if balance >= totalTransferValue
+            remainder = balance - totalTransferValue
+
+            # If user has provided remainder address
+            # Use it to send remaining funds to
+            if remainder > 0 && remainderAddress
+              # Remainder bundle entry
+              bundle.addEntry(1, remainderAddress, remainder, tag, timestamp)
+
+              # Final function for signing inputs
+              return signInputs(inputs, bundle, signatureFragments, hmacKey)
+            elsif remainder > 0
+              # Generate a new Address by calling getNewAddress
+              address = getNewAddress({security: security})
+              timestamp = Time.now.utc.to_i
+
+              # Remainder bundle entry
+              bundle.addEntry(1, address, remainder, tag, timestamp)
+
+              # Final function for signing inputs
+              return signInputs(inputs, bundle, signatureFragments, hmacKey)
+            else
+              # If there is no remainder, do not add transaction to bundle simply sign and return
+              return signInputs(inputs, bundle, signatureFragments, hmacKey)
+            end
+          else
+            # If multiple inputs provided, subtract the totalTransferValue by the inputs balance
+            totalTransferValue -= balance
+          end
+        end
+      end
+
+      def signInputs(inputs, bundle, signatureFragments, hmacKey)
+        bundle.finalize()
+        bundle.addTrytes(signatureFragments)
+
+        # SIGNING OF INPUTS
+        # Here we do the actual signing of the inputs
+        # Iterate over all bundle transactions, find the inputs
+        # Get the corresponding private key and calculate the signatureFragment
+
+        (0...bundle.bundle.length).step(1) do |i|
+          trx = bundle.bundle[i]
+
+          if trx.value < 0
+            address = trx.address
+
+            # Get the corresponding keyIndex and security of the address
+            keyIndex = nil
+            keySecurity = nil
+            inputs.each do |input|
+              if input.address == address
+                keyIndex = input.keyIndex
+                keySecurity = input.security ? input.security : security
+                break
+              end
+            end
+
+            # Get corresponding private key of address
+            privateKey = IOTA::Crypto::PrivateKey.new(@seed.as_trits, keyIndex, keySecurity)
+            key = privateKey.key
+
+            #  Get the normalized bundle hash
+            normalizedBundleHash = bundle.normalizedBundle(trx.bundle)
+            normalizedBundleFragments = []
+
+            # Split hash into 3 fragments
+            (0...3).step(1) do |l|
+              normalizedBundleFragments[l] = normalizedBundleHash.slice(l * 27, 27)
+            end
+
+            #  First 6561 trits for the firstFragment
+            firstFragment = key[0...6561]
+
+            #  First bundle fragment uses the first 27 trytes
+            firstBundleFragment = normalizedBundleFragments[0]
+
+            #  Calculate the new signatureFragment with the first bundle fragment
+            firstSignedFragment = IOTA::Crypto::Signing.signatureFragment(firstBundleFragment, firstFragment)
+
+            #  Convert signature to trytes and assign the new signatureFragment
+            trx.signatureMessageFragment = IOTA::Crypto::Converter.trytes(firstSignedFragment)
+
+            # if user chooses higher than 27-tryte security
+            # for each security level, add an additional signature
+            (1...keySecurity).step(1) do |j|
+              #  Because the signature is > 2187 trytes, we need to
+              #  find the subsequent transaction to add the remainder of the signature
+              #  Same address as well as value = 0 (as we already spent the input)
+              if bundle.bundle[i + j].address == address && bundle.bundle[i + j].value == 0
+                # Use the next 6561 trits
+                nextFragment = key.slice(6561 * j, 6561)
+
+                nextBundleFragment = normalizedBundleFragments[j]
+
+                #  Calculate the new signature
+                nextSignedFragment = IOTA::Crypto::Signing.signatureFragment(nextBundleFragment, nextFragment)
+
+                #  Convert signature to trytes and assign it again to this bundle entry
+                bundle.bundle[i + j].signatureMessageFragment = IOTA::Crypto::Converter.trytes(nextSignedFragment)
+              end
+            end
+          end
+        end
+
+        if hmacKey
+          hmac = IOTA::Crypto::Hmac(hmacKey)
+          hmac.addHMAC(bundle)
+        end
+
+        bundleTrytes = []
+
+        # Convert all bundle entries into trytes
+        bundle.bundle.each do |bndl|
+          bundleTrytes << @utils.transactionTrytes(bndl)
+        end
+
+        bundleTrytes.reverse
+      end
+    end
+  end
+end

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