iota-ruby 1.0.1

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.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['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

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,117 @@
+require 'net/http'
+require 'uri'
+require 'json'
+
+module IOTA
+  module Utils
+    class Broker
+      def initialize(provider, token, timeout = 120)
+        @provider, @token = provider, token
+        @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
+        }
+
+        request["Authorization"] = "token #{@token}" if @token
+
+        [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'
+        }
+
+        # 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