iota-ruby 1.1.8-java

data/lib/iota/utils/ascii.rb

@@ -0,0 +1,50 @@
+module IOTA
+  module Utils
+    module Ascii
+      TRYTE_VALUES = "9ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+
+      def toTrytes(input)
+        # If input is not a string, return nil
+        return nil if !@validator.isString(input)
+        trytes = ""
+
+        (0...input.length).step(1) do |i|
+          char = input[i]
+          asciiValue = char.bytes.sum
+
+          # If not recognizable ASCII character, return null
+          return nil if asciiValue > 255
+
+          firstValue = asciiValue % 27
+          secondValue = (asciiValue - firstValue) / 27
+
+          trytesValue = TRYTE_VALUES[firstValue] + TRYTE_VALUES[secondValue]
+
+          trytes += trytesValue
+        end
+
+        trytes
+      end
+
+      def fromTrytes(input)
+        # If input is invalid trytes or input length is odd
+        return nil if !@validator.isTrytes(input) || input.length % 2 != 0
+
+        outputString = ""
+
+        (0...input.length).step(2) do |i|
+          trytes = input[i] + input[i + 1]
+
+          firstValue = TRYTE_VALUES.index(trytes[0])
+          secondValue = TRYTE_VALUES.index(trytes[1])
+
+          decimalValue = firstValue + secondValue * 27
+
+          outputString += decimalValue.chr
+        end
+
+        outputString
+      end
+    end
+  end
+end

data/lib/iota/utils/broker.rb

@@ -0,0 +1,124 @@
+require 'net/http'
+require 'uri'
+require 'json'
+
+module IOTA
+  module Utils
+    class Broker
+      def initialize(provider, token, timeout = 120, user: nil, password: nil)
+        @provider, @token, @user, @password = provider, token, user, password
+        @timeout = timeout if timeout.to_i > 0
+      end
+
+      def send(command, &callback)
+        uri, request, req_options = prepareRequest(command)
+        response = Net::HTTP.start(uri.hostname, uri.port, req_options) do |http|
+          http.request(request)
+        end
+
+        success = true
+        begin
+          data = JSON.parse(response.body)
+          if data.key?('error')
+            data = data['error']
+            success = false
+          else
+            data = prepareResponse(data, command[:command])
+          end
+        rescue JSON::ParserError
+          success = false
+          data = "Invalid response"
+        end
+        callback ? callback.call(success, data) : [success, data]
+      end
+
+      def sandboxSend(uri, &callback)
+        processed = false
+        success = false
+        retValue = nil
+
+        loop do
+          uri, request, req_options = prepareRequest(nil, uri, Net::HTTP::Get)
+
+          response = Net::HTTP.start(uri.hostname, uri.port, req_options) do |http|
+            http.request(request)
+          end
+
+          begin
+            data = JSON.parse(response.body)
+            if data['status'] == 'FINISHED'
+              processed = true
+              success = true
+              retValue = data['attachToTangleResponse']['trytes']
+            elsif data['status'] == 'FAILED'
+              processed = true
+              success = false
+              retValue = "Sandbox transaction processing failed. Please retry."
+            end
+          rescue JSON::ParserError
+            processed = true
+            success = false
+            retValue = "Invalid response"
+          end
+
+          break if processed
+
+          # Sleep for 15 seconds before making another request
+          sleep 15
+        end
+
+        callback ? callback.call(success, retValue) : [success, retValue]
+      end
+
+      private
+      def prepareRequest(command = nil, uri = @provider, requestMethod = Net::HTTP::Post)
+        uri = URI.parse(uri)
+        request = requestMethod.new(uri)
+        request.content_type = "application/json"
+        request['X-IOTA-API-Version'] = '1'
+        request.body = JSON.dump(command) if !command.nil?
+
+        req_options = {
+          use_ssl: uri.scheme == "https",
+          read_timeout: @timeout || 120
+        }
+
+        if @token
+          request["Authorization"] = "token #{@token}"
+        elsif @user && @password
+          request.basic_auth @user, @password
+        end
+
+        [uri, request, req_options]
+      end
+
+      def prepareResponse(result, command)
+        resultMap = {
+          'getNeighbors'          =>   'neighbors',
+          'addNeighbors'          =>   'addedNeighbors',
+          'removeNeighbors'       =>   'removedNeighbors',
+          'getTips'               =>   'hashes',
+          'findTransactions'      =>   'hashes',
+          'getTrytes'             =>   'trytes',
+          'getInclusionStates'    =>   'states',
+          'attachToTangle'        =>   'trytes',
+          'checkConsistency'      =>   'state',
+          'getBalances'           =>   'balances',
+          'wereAddressesSpentFrom'=>   'states'
+        }
+
+        # If correct result and we want to prepare the result
+        if result && resultMap.key?(command)
+          # If the response is from the sandbox, don't prepare the result
+          if command === 'attachToTangle' && result.key?('id')
+            result = result
+          else
+            result = result[resultMap[command]]
+          end
+        end
+
+        result
+      end
+    end
+  end
+end

data/lib/iota/utils/input_validator.rb

@@ -0,0 +1,149 @@
+module IOTA
+  module Utils
+    class InputValidator
+      def isAllNine(input)
+        /^[9]+$/.match?(input)
+      end
+
+      def isValue(input)
+        input && input.is_a?(Integer)
+      end
+
+      def isNum(input)
+        /^(\d+\.?\d{0,15}|\.\d{0,15})$/.match?(input.to_s)
+      end
+
+      def isString(input)
+        input.class == String
+      end
+
+      def isArray(input)
+        input.class == Array
+      end
+
+      def isObject(input)
+        input.class == Hash
+      end
+
+      def isHash(input)
+        isTrytes(input, 81)
+      end
+
+      def isAddress(input)
+        if input.length == 90
+          if !isTrytes(input, 90)
+            return false
+          end
+        else
+          if !isTrytes(input, 81)
+            return false
+          end
+        end
+
+        true
+      end
+
+      def isTrytes(input, length = "0,")
+        isString(input) && /^[9A-Z]{#{length}}$/.match?(input)
+      end
+
+      def isArrayOfTrytes(trytesArray)
+        return false if !isArray(trytesArray)
+
+        trytesArray.each do |tryte|
+          return false if !isTrytes(tryte, 2673)
+        end
+
+        true
+      end
+
+      def isArrayOfHashes(input)
+        return false if !isArray(input)
+
+        input.each do |entry|
+          return false if !isAddress(entry)
+        end
+
+        true
+      end
+
+      def isArrayOfAttachedTrytes(trytes)
+        return false if !isArray(trytes)
+
+        (0...trytes.length).step(1) do |i|
+          tryte = trytes[i]
+          return false if !isTrytes(tryte, 2673)
+
+          lastTrytes = tryte.slice(2673 - (3 * 81), trytes.length)
+          return false if isAllNine(lastTrytes)
+        end
+
+        true
+      end
+
+      def isArrayOfTxObjects(bundle)
+        bundle = bundle.transactions if bundle.class == IOTA::Models::Bundle
+
+        return false if !isArray(bundle) || bundle.length == 0
+
+        bundle.each do |txObject|
+          if txObject.class != IOTA::Models::Transaction
+            txObject = IOTA::Models::Transaction.new(txObject)
+          end
+
+          return false if !txObject.valid?
+        end
+
+        true
+      end
+
+      def isTransfersArray(transfersArray)
+        return false if !isArray(transfersArray)
+
+        transfersArray.each do |transfer|
+          if transfer.class != IOTA::Models::Transfer
+            transfer = IOTA::Models::Transfer.new(transfer)
+          end
+
+          return false if !transfer.valid?
+        end
+
+        true
+      end
+
+      def isInputs(inputs)
+        return false if !isArray(inputs)
+
+        inputs.each do |input|
+          if input.class != IOTA::Models::Input
+            input = IOTA::Models::Input.new(input)
+          end
+
+          return false if !input.valid?
+        end
+
+        true
+      end
+
+      # Checks that a given uri is valid
+      # Valid Examples:
+      # udp://[2001:db8:a0b:12f0::1]:14265
+      # udp://[2001:db8:a0b:12f0::1]
+      # udp://8.8.8.8:14265
+      # udp://domain.com
+      # udp://domain2.com:14265
+      def isUri(node)
+        getInside = /^(udp|tcp):\/\/([\[][^\]\.]*[\]]|[^\[\]:]*)[:]{0,1}([0-9]{1,}$|$)/i
+
+        stripBrackets = /[\[]{0,1}([^\[\]]*)[\]]{0,1}/
+
+        uriTest = /((^\s*((([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])\.){3}([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5]))\s*$)|(^\s*((([0-9A-Fa-f]{1,4}:){7}([0-9A-Fa-f]{1,4}|:))|(([0-9A-Fa-f]{1,4}:){6}(:[0-9A-Fa-f]{1,4}|((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9A-Fa-f]{1,4}:){5}(((:[0-9A-Fa-f]{1,4}){1,2})|:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9A-Fa-f]{1,4}:){4}(((:[0-9A-Fa-f]{1,4}){1,3})|((:[0-9A-Fa-f]{1,4})?:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){3}(((:[0-9A-Fa-f]{1,4}){1,4})|((:[0-9A-Fa-f]{1,4}){0,2}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){2}(((:[0-9A-Fa-f]{1,4}){1,5})|((:[0-9A-Fa-f]{1,4}){0,3}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){1}(((:[0-9A-Fa-f]{1,4}){1,6})|((:[0-9A-Fa-f]{1,4}){0,4}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(:(((:[0-9A-Fa-f]{1,4}){1,7})|((:[0-9A-Fa-f]{1,4}){0,5}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:)))(%.+)?\s*$))|(^\s*((?=.{1,255}$)(?=.*[A-Za-z].*)[0-9A-Za-z](?:(?:[0-9A-Za-z]|\b-){0,61}[0-9A-Za-z])?(?:\.[0-9A-Za-z](?:(?:[0-9A-Za-z]|\b-){0,61}[0-9A-Za-z])?)*)\s*$)/
+
+        match = getInside.match(node)
+        return false if match.nil? || match[2].nil?
+
+        uriTest.match?(stripBrackets.match(match[2])[1])
+      end
+    end
+  end
+end

data/lib/iota/utils/object_validator.rb

@@ -0,0 +1,34 @@
+module IOTA
+  module Utils
+    class ObjectValidator
+      def initialize(keysToValidate)
+        @validator = InputValidator.new
+        @keysToValidate = keysToValidate
+      end
+
+      def valid?(object)
+        valid = true
+        @keysToValidate.each do |keyToValidate|
+          key = keyToValidate[:key]
+          func = keyToValidate[:validator]
+          args = keyToValidate[:args]
+
+          # If input does not have keyIndex and address, return false
+          if !object.respond_to?(key)
+            valid = false
+            break
+          end
+
+          # If input function does not return true, exit
+          method_args = [object.send(key)]
+          method_args << args if !args.nil?
+          if !@validator.method(func).call(*method_args)
+            valid = false
+            break
+          end
+        end
+        valid
+      end
+    end
+  end
+end

data/lib/iota/utils/utils.rb

@@ -0,0 +1,324 @@
+require 'bigdecimal'
+
+module IOTA
+  module Utils
+    class Utils
+      include Ascii
+
+      attr_reader :validator
+
+      UNIT_MAP = {
+        'i'  => 1,
+        'Ki' => 1_000,
+        'Mi' => 1_000_000,
+        'Gi' => 1_000_000_000,
+        'Ti' => 1_000_000_000_000,
+        'Pi' => 1_000_000_000_000_000
+      }
+
+      UNIT_MAP_ORDER = ['Pi', 'Ti', 'Gi', 'Mi', 'Ki', 'i']
+
+      def initialize
+        @validator = InputValidator.new
+      end
+
+      def convertUnits(value, fromUnit, toUnit)
+        # Check if wrong unit provided
+        if !UNIT_MAP[fromUnit] || !UNIT_MAP[toUnit]
+          raise ArgumentError, "Invalid unit provided"
+        end
+
+        # If not valid value, throw error
+        if !@validator.isNum(value)
+          raise ArgumentError, "Invalid value"
+        end
+
+        converted = (BigDecimal(value.to_s) * UNIT_MAP[fromUnit]) / UNIT_MAP[toUnit]
+        converted.to_f
+      end
+
+      def noChecksum(address)
+        isSingleAddress = @validator.isString(address)
+
+        return address if isSingleAddress && address.length == 81
+
+        # If only single address, turn it into an array
+        if isSingleAddress
+          address = [address]
+        end
+
+        addressesWithChecksum = []
+
+        address.each do |addr|
+          addressesWithChecksum << addr.slice(0, 81)
+        end
+
+        # return either string or the list
+        if isSingleAddress
+            return addressesWithChecksum.first
+        else
+            return addressesWithChecksum
+        end
+      end
+
+      def transactionObject(trytes)
+        return nil if !trytes
+
+        # validity check
+        (2279...2295).step(1) do |i|
+          return nil if trytes[i] != "9"
+        end
+
+        trx = {}
+        transactionTrits = IOTA::Crypto::Converter.trits(trytes)
+        hash = []
+
+        # generate the correct transaction hash
+        curl = IOTA::Crypto::Curl.new
+        curl.absorb(transactionTrits)
+        curl.squeeze(hash)
+
+        trx['hash'] = IOTA::Crypto::Converter.trytes(hash)
+        trx['signatureMessageFragment'] = trytes.slice(0, 2187)
+        trx['address'] = trytes.slice(2187, 81)
+        trx['value'] = IOTA::Crypto::Converter.value(transactionTrits.slice(6804, 33))
+        trx['obsoleteTag'] = trytes.slice(2295, 27)
+        trx['timestamp'] = IOTA::Crypto::Converter.value(transactionTrits.slice(6966, 27))
+        trx['currentIndex'] = IOTA::Crypto::Converter.value(transactionTrits.slice(6993, 27))
+        trx['lastIndex'] = IOTA::Crypto::Converter.value(transactionTrits.slice(7020, 27))
+        trx['bundle'] = trytes.slice(2349, 81)
+        trx['trunkTransaction'] = trytes.slice(2430, 81)
+        trx['branchTransaction'] = trytes.slice(2511, 81)
+
+        trx['tag'] = trytes.slice(2592, 27)
+        trx['attachmentTimestamp'] = IOTA::Crypto::Converter.value(transactionTrits.slice(7857, 27))
+        trx['attachmentTimestampLowerBound'] = IOTA::Crypto::Converter.value(transactionTrits.slice(7884, 27))
+        trx['attachmentTimestampUpperBound'] = IOTA::Crypto::Converter.value(transactionTrits.slice(7911, 27))
+        trx['nonce'] = trytes.slice(2646, 27)
+
+        IOTA::Models::Transaction.new(trx)
+      end
+
+      def transactionTrytes(transaction)
+        valueTrits = IOTA::Crypto::Converter.trits(transaction.value)
+        valueTrits = valueTrits.concat([0]*(81-valueTrits.length)) if valueTrits.length < 81
+
+        timestampTrits = IOTA::Crypto::Converter.trits(transaction.timestamp)
+        timestampTrits = timestampTrits.concat([0]*(27-timestampTrits.length)) if timestampTrits.length < 27
+
+        currentIndexTrits = IOTA::Crypto::Converter.trits(transaction.currentIndex)
+        currentIndexTrits = currentIndexTrits.concat([0]*(27-currentIndexTrits.length)) if currentIndexTrits.length < 27
+
+        lastIndexTrits = IOTA::Crypto::Converter.trits(transaction.lastIndex)
+        lastIndexTrits = lastIndexTrits.concat([0]*(27-lastIndexTrits.length)) if lastIndexTrits.length < 27
+
+        attachmentTimestampTrits = IOTA::Crypto::Converter.trits(transaction.attachmentTimestamp || 0);
+        attachmentTimestampTrits = attachmentTimestampTrits.concat([0]*(27-attachmentTimestampTrits.length)) if attachmentTimestampTrits.length < 27
+
+        attachmentTimestampLowerBoundTrits = IOTA::Crypto::Converter.trits(transaction.attachmentTimestampLowerBound || 0);
+        attachmentTimestampLowerBoundTrits = attachmentTimestampLowerBoundTrits.concat([0]*(27-attachmentTimestampLowerBoundTrits.length)) if attachmentTimestampLowerBoundTrits.length < 27
+
+        attachmentTimestampUpperBoundTrits = IOTA::Crypto::Converter.trits(transaction.attachmentTimestampUpperBound || 0);
+        attachmentTimestampUpperBoundTrits = attachmentTimestampUpperBoundTrits.concat([0]*(27-attachmentTimestampUpperBoundTrits.length)) if attachmentTimestampUpperBoundTrits.length < 27
+
+        tag = transaction.tag || transaction.obsoleteTag
+
+        return (
+          transaction.signatureMessageFragment +
+          transaction.address +
+          IOTA::Crypto::Converter.trytes(valueTrits) +
+          transaction.obsoleteTag +
+          IOTA::Crypto::Converter.trytes(timestampTrits) +
+          IOTA::Crypto::Converter.trytes(currentIndexTrits) +
+          IOTA::Crypto::Converter.trytes(lastIndexTrits) +
+          transaction.bundle +
+          transaction.trunkTransaction +
+          transaction.branchTransaction +
+          tag +
+          IOTA::Crypto::Converter.trytes(attachmentTimestampTrits) +
+          IOTA::Crypto::Converter.trytes(attachmentTimestampLowerBoundTrits) +
+          IOTA::Crypto::Converter.trytes(attachmentTimestampUpperBoundTrits) +
+          transaction.nonce
+        )
+      end
+
+      def addChecksum(input, checksumLength = 9, isAddress = true)
+        # the length of the trytes to be validated
+        validationLength = isAddress ? 81 : nil
+
+        isSingleInput = @validator.isString(input)
+
+        # If only single address, turn it into an array
+        input = [input] if isSingleInput
+
+        inputsWithChecksum = input.map do |inputValue|
+          # check if correct trytes
+          if !@validator.isTrytes(inputValue, validationLength)
+            raise ArgumentError, "Invalid input provided"
+          end
+
+          kerl = IOTA::Crypto::Kerl.new
+
+          # Address trits
+          addressTrits = IOTA::Crypto::Converter.trits(inputValue)
+
+          # Checksum trits
+          checksumTrits = []
+
+          # Absorb address trits
+          kerl.absorb(addressTrits, 0, addressTrits.length)
+
+          # Squeeze checksum trits
+          kerl.squeeze(checksumTrits, 0, IOTA::Crypto::Curl::HASH_LENGTH)
+
+          # First 9 trytes as checksum
+          checksum = IOTA::Crypto::Converter.trytes(checksumTrits)[81-checksumLength...81]
+          inputValue + checksum
+        end
+
+        isSingleInput ? inputsWithChecksum[0] : inputsWithChecksum
+      end
+
+      def isBundle(bundle)
+        # If not correct bundle
+        return false if !@validator.isArrayOfTxObjects(bundle)
+
+        bundle = bundle.transactions if bundle.class == IOTA::Models::Bundle
+
+        totalSum = 0
+        bundleHash = bundle[0].bundle
+
+        # Prepare to absorb txs and get bundleHash
+        bundleFromTxs = []
+
+        kerl = IOTA::Crypto::Kerl.new
+
+        # Prepare for signature validation
+        signaturesToValidate = []
+
+        bundle.each_with_index do |bundleTx, index|
+          totalSum += bundleTx.value
+
+          # currentIndex has to be equal to the index in the array
+          return false if bundleTx.currentIndex != index
+
+          # Get the transaction trytes
+          trytes = transactionTrytes(bundleTx)
+
+          # Absorb bundle hash + value + timestamp + lastIndex + currentIndex trytes.
+          trits = IOTA::Crypto::Converter.trits(trytes.slice(2187, 162))
+          kerl.absorb(trits, 0, trits.length)
+
+          # Check if input transaction
+          if bundleTx.value < 0
+            address = bundleTx.address
+
+            newSignatureToValidate = {
+              address: address,
+              signatureFragments: [bundleTx.signatureMessageFragment]
+            }
+
+            # Find the subsequent txs with the remaining signature fragment
+            (index...bundle.length-1).step(1) do |i|
+              newBundleTx = bundle[i+1]
+
+              if newBundleTx.address == address && newBundleTx.value == 0
+                newSignatureToValidate[:signatureFragments] << newBundleTx.signatureMessageFragment
+              end
+            end
+
+            signaturesToValidate << newSignatureToValidate
+          end
+        end
+
+        # Check for total sum, if not equal 0 return error
+        return false if totalSum != 0
+
+        # get the bundle hash from the bundle transactions
+        kerl.squeeze(bundleFromTxs, 0, IOTA::Crypto::Kerl::HASH_LENGTH)
+        bundleFromTxs = IOTA::Crypto::Converter.trytes(bundleFromTxs)
+
+        # Check if bundle hash is the same as returned by tx object
+        return false if bundleFromTxs != bundleHash
+
+        # Last tx in the bundle should have currentIndex === lastIndex
+        return false if bundle[bundle.length - 1].currentIndex != bundle[bundle.length - 1].lastIndex
+
+        # Validate the signatures
+        (0...signaturesToValidate.length).step(1) do |i|
+          return false if !IOTA::Crypto::Signing.validateSignatures(signaturesToValidate[i][:address], signaturesToValidate[i][:signatureFragments], bundleHash)
+        end
+
+        true
+      end
+
+      def isValidChecksum(addressWithChecksum)
+        withoutChecksum = noChecksum(addressWithChecksum)
+        newWithCheckcum = addChecksum(withoutChecksum)
+        newWithCheckcum == addressWithChecksum
+      end
+
+      def validateSignatures(signedBundle, inputAddress)
+        bundleHash = nil
+        signatureFragments = []
+
+        signedBundle = signedBundle.transactions if signedBundle.class == IOTA::Models::Bundle
+
+        (0...signedBundle.length).step(1) do |i|
+          if signedBundle[i].address === inputAddress
+            bundleHash = signedBundle[i].bundle
+
+            signature = signedBundle[i].signatureMessageFragment
+
+            # if we reached remainder bundle
+            break if @validator.isString(signature) && @validator.isAllNine(signature)
+
+            signatureFragments << signature
+          end
+        end
+
+        return false if bundleHash.nil?
+
+        IOTA::Crypto::Signing.validateSignatures(inputAddress, signatureFragments, bundleHash)
+      end
+
+      def categorizeTransfers(transfers, addresses)
+        categorized = {
+          sent: [],
+          received: []
+        }
+
+        addresses = addresses.map { |a| a[0...81] }
+
+        # Iterate over all bundles and sort them between incoming and outgoing transfers
+        transfers.each do |bundle|
+          spentAlreadyAdded = false
+
+          bundle = IOTA::Models::Bundle.new(bundle) if bundle.class != IOTA::Models::Bundle
+
+          # Iterate over every bundle entry
+          bundle.transactions.each_with_index do |bundleEntry, bundleIndex|
+            address = bundleEntry.address[0...81]
+            if !addresses.index(address).nil?
+              # Check if it's a remainder address
+              isRemainder = (bundleEntry.currentIndex == bundleEntry.lastIndex) && bundleEntry.lastIndex != 0
+
+              # check if sent transaction
+              if bundleEntry.value < 0 && !spentAlreadyAdded && !isRemainder
+                categorized[:sent] << bundle
+
+                # too make sure we do not add transactions twice
+                spentAlreadyAdded = true
+              elsif bundleEntry.value >= 0 && !spentAlreadyAdded && !isRemainder
+                # check if received transaction, or 0 value (message)
+                # also make sure that this is not a 2nd tx for spent inputs
+                categorized[:received] << bundle
+              end
+            end
+          end
+        end
+        categorized
+      end
+    end
+  end
+end