iota-ruby 1.0.1

data/lib/iota/utils/utils.rb

@@ -0,0 +1,326 @@
+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 if !trytes
+
+        # validity check
+        (2279...2295).step(1) do |i|
+          raise ArgumentError, "Invalid trytes provided" if trytes[i] != "9"
+        end
+
+        trx = {}
+        transactionTrits = IOTA::Crypto::Converter.trits(trytes)
+        hash = []
+
+        curl = IOTA::Crypto::Curl.new
+
+        # generate the correct transaction hash
+        curl.setup()
+        curl.absorb(transactionTrits, 0, transactionTrits.length)
+        curl.squeeze(hash, 0, 243)
+
+        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)
+            throw Error, "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

data/lib/iota/version.rb

@@ -0,0 +1,3 @@
+module IOTA
+  VERSION = "1.0.1"
+end

data/lib/iota.rb

@@ -0,0 +1,73 @@
+require "iota/version"
+
+require "iota/utils/input_validator"
+require "iota/utils/object_validator"
+require "iota/utils/ascii"
+require "iota/utils/utils"
+require "iota/utils/broker"
+
+require "iota/api/commands"
+require "iota/api/wrappers"
+require "iota/api/api"
+
+require "iota/crypto/curl"
+require "iota/crypto/kerl"
+require "iota/crypto/converter"
+require "iota/crypto/bundle"
+require "iota/crypto/signing"
+require "iota/crypto/hmac"
+require "iota/crypto/private_key"
+
+require "iota/multisig/address"
+require "iota/multisig/multisig"
+
+require "iota/models/base"
+require "iota/models/input"
+require "iota/models/transfer"
+require "iota/models/seed"
+require "iota/models/transaction"
+require "iota/models/bundle"
+require "iota/models/account"
+
+module IOTA
+  class Client
+    attr_reader :version, :host, :port, :provider, :sandbox, :token, :broker, :api, :utils, :validator, :multisig
+
+    def initialize(settings = {})
+      setSettings(settings)
+      @utils = IOTA::Utils::Utils.new
+      @validator = @utils.validator
+      @multisig = IOTA::Multisig::Multisig.new(self)
+      # TODO: Implement MAM
+      # TODO: Implement Flash Channel
+    end
+
+    def changeNode(settings = {})
+      setSettings(settings)
+      self
+    end
+
+    private
+    def setSettings(settings)
+      settings = symbolize_keys(settings)
+      @host = settings[:host] ? settings[:host] : "http://localhost"
+      @port = settings[:port] ? settings[:port] : 14265
+      @provider = settings[:provider] || @host.gsub(/\/$/, '') + ":" + @port.to_s
+      @sandbox = settings[:sandbox] || false
+      @token = settings[:token] || false
+      @timeout = settings[:timeout] || 120
+
+      if @sandbox
+        @sandbox = @provider.gsub(/\/$/, '')
+        @provider = @sandbox + '/commands'
+      end
+
+      @broker = IOTA::Utils::Broker.new(@provider, @token, @timeout)
+      @api = IOTA::API::Api.new(@broker, @sandbox)
+    end
+
+    def symbolize_keys(hash)
+      hash.inject({}){ |h,(k,v)| h[k.to_sym] = v; h }
+    end
+  end
+end

data/test/ascii_test.rb

@@ -0,0 +1,114 @@
+require "test_helper"
+
+class AsciiTest < Minitest::Test
+  def setup
+    @utils = IOTA::Utils::Utils.new
+  end
+
+  def test_that_from_tryte_works
+    tests = [
+      {
+        message: " ASDFDSAFDSAja9fd",
+        expected: true
+      },
+      {
+        message: "994239432",
+        expected: true
+      },
+      {
+        message: "{ 'a' : 'b', 'c': 'd', 'e': '#asdfd?$' }",
+        expected: true
+      },
+      {
+        message: "{ 'a' : 'b', 'c': {'nested': 'json', 'much': 'wow', 'array': [ true, false, 'yes' ] } }",
+        expected: true
+      },
+      {
+        message: 994239432,
+        expected: false
+      },
+      {
+        message: 'true',
+        expected: true
+      },
+      {
+        message: [9, 'yes', true],
+        expected: false
+      },
+      {
+        message: { 'a' => 'b' },
+        expected: false
+      }
+    ]
+
+    tests.each do |test|
+      trytes = @utils.toTrytes(test[:message])
+      str = @utils.fromTrytes(trytes)
+
+      if test[:expected]
+        assert str.eql?(test[:message])
+      else
+        assert_nil str
+      end
+    end
+  end
+
+  def test_that_to_trytes_works
+    tests = [
+      {
+        message: " ΣASDFDSAFDSAja9fd",
+        expected: false
+      },
+      {
+        message: " ASDFDSAFDSAja9fd",
+        expected: true
+      },
+      {
+        message: "994239432",
+        expected: true
+      },
+      {
+        message: "{ 'a' : 'b', 'c': 'd', 'e': '#asdfd?$' }",
+        expected: true
+      },
+      {
+        message: "{ 'a' : 'b', 'c': {'nested': 'json', 'much': 'wow', 'array': [ true, false, 'yes' ] } }",
+        expected: true
+      },
+      {
+        message: "{ 'a' : 'b', 'c': {'nested': 'json', 'much': 'wow', 'array': [ true, false, 'yes' ] } }",
+        expected: true
+      },
+      {
+        message: "{'message': 'IOTA is a revolutionary new transactional settlement and data transfer layer for the Internet of Things. It's based on a new distributed ledger, the Tangle, which overcomes the inefficiencies of current Blockchain designs and introduces a new way of reaching consensus in a decentralized peer-to-peer system. For the first time ever, through IOTA people can transfer money without any fees. This means that even infinitesimally small nanopayments can be made through IOTA. IOTA is the missing puzzle piece for the Machine Economy to fully emerge and reach its desired potential. We envision IOTA to be the public, permissionless backbone for the Internet of Things that enables true interoperability between all devices. Tangle: A directed acyclic graph (DAG) as a distributed ledger which stores all transaction data of the IOTA network. It is a Blockchain without the blocks and the chain (so is it really a Blockchain?). The Tangle is the first distributed ledger to achieve scalability, no fee transactions, data integrity and transmission as well as quantum-computing protection. Contrary to today's Blockchains, consensus is no-longer decoupled but instead an intrinsic part of the system, leading to a completely decentralized and self-regulating peer-to-peer network. All IOTA\'s which will ever exist have been created with the genesis transaction. This means that the total supply of IOTA\'s will always stay the same and you cannot mine IOTA\'s. Therefore keep in mind, if you do Proof of Work in IOTA you are not generating new IOTA tokens, you\'re simply verifying other transactions.'}",
+        expected: true
+      },
+      {
+        message: 994239432,
+        expected: false
+      },
+      {
+        message: true,
+        expected: false
+      },
+      {
+        message: [9, 'yes', true],
+        expected: false
+      },
+      {
+        message: { 'a' => 'b' },
+        expected: false
+      }
+    ]
+
+    tests.each do |test|
+      trytes = @utils.toTrytes(test[:message])
+
+      if test[:expected]
+        refute_nil trytes
+      else
+        assert_nil trytes
+      end
+    end
+  end
+end

data/test/kerl_test.rb

@@ -0,0 +1,64 @@
+require "test_helper"
+
+class KerlTest < Minitest::Test
+  def setup
+    @converter = IOTA::Crypto::Converter
+    @kerl = IOTA::Crypto::Kerl.new
+  end
+
+  def test_that_sha3_works
+    digest = "\xe0\xef\x02\xd2FD\xa7\xb2\x8b<\x1b\x01\xc4\xfe\x13zI\x86M[\xdefV\xfa\xf49\xe1\xeb\xa6X\x06M\x9e\xcf\x842U\xba\x90=\x1c\xeb\xdcf\xff/\x16\xce".unpack('C*')
+    hexdigest = "e0ef02d24644a7b28b3c1b01c4fe137a49864d5bde6656faf439e1eba658064d9ecf843255ba903d1cebdc66ff2f16ce"
+
+    a = Digest::SHA3.new(384)
+    a.update("GYOMKVTSNHVJNCNFBBAH9AAMXLPLLLROQY99QN9DLSJUHDPBLCFFAIQXZA9BKMBJCYSFHFPXAHDWZFEIZ")
+
+    assert a.digest_length == 48
+    assert a.digest.bytes == digest
+    assert a.hexdigest == hexdigest
+  end
+
+  def test_that_absorb_squeeze_works
+    input = "GYOMKVTSNHVJNCNFBBAH9AAMXLPLLLROQY99QN9DLSJUHDPBLCFFAIQXZA9BKMBJCYSFHFPXAHDWZFEIZ"
+    expected = "OXJCNFHUNAHWDLKKPELTBFUCVW9KLXKOGWERKTJXQMXTKFKNWNNXYD9DMJJABSEIONOSJTTEVKVDQEWTW"
+    trits = @converter.trits(input)
+
+    @kerl.reset
+    @kerl.absorb(trits)
+    hashTrits = []
+    @kerl.squeeze(hashTrits)
+    hash = @converter.trytes(hashTrits)
+
+    assert expected == hash
+  end
+
+  def test_that_absorb_multi_squeeze_works
+    input = "9MIDYNHBWMBCXVDEFOFWINXTERALUKYYPPHKP9JJFGJEIUY9MUDVNFZHMMWZUYUSWAIOWEVTHNWMHANBH"
+    expected = "G9JYBOMPUXHYHKSNRNMMSSZCSHOFYOYNZRSZMAAYWDYEIMVVOGKPJBVBM9TDPULSFUNMTVXRKFIDOHUXXVYDLFSZYZTWQYTE9SPYYWYTXJYQ9IFGYOLZXWZBKWZN9QOOTBQMWMUBLEWUEEASRHRTNIQWJQNDWRYLCA"
+
+    trits = @converter.trits(input)
+    @kerl.reset
+    @kerl.absorb(trits)
+
+    hashTrits = []
+    @kerl.squeeze(hashTrits, 0, IOTA::Crypto::Curl::HASH_LENGTH * 2)
+    hash = @converter.trytes(hashTrits)
+
+    assert expected == hash
+  end
+
+  def test_that_multi_absorb_multi_squeeze_works
+    input = "G9JYBOMPUXHYHKSNRNMMSSZCSHOFYOYNZRSZMAAYWDYEIMVVOGKPJBVBM9TDPULSFUNMTVXRKFIDOHUXXVYDLFSZYZTWQYTE9SPYYWYTXJYQ9IFGYOLZXWZBKWZN9QOOTBQMWMUBLEWUEEASRHRTNIQWJQNDWRYLCA"
+    expected = "LUCKQVACOGBFYSPPVSSOXJEKNSQQRQKPZC9NXFSMQNRQCGGUL9OHVVKBDSKEQEBKXRNUJSRXYVHJTXBPDWQGNSCDCBAIRHAQCOWZEBSNHIJIGPZQITIBJQ9LNTDIBTCQ9EUWKHFLGFUVGGUWJONK9GBCDUIMAYMMQX"
+
+    trits = @converter.trits(input)
+    @kerl.reset
+    @kerl.absorb(trits, 0, trits.length)
+
+    hashTrits = []
+    @kerl.squeeze(hashTrits, 0, IOTA::Crypto::Curl::HASH_LENGTH * 2)
+    hash = @converter.trytes(hashTrits)
+
+    assert expected == hash
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,4 @@
+$LOAD_PATH.unshift File.expand_path("../../lib", __FILE__)
+require "iota"
+
+require "minitest/autorun"