iota-ruby 1.1.8-java

data/ext/ccurl/extconf.rb

@@ -0,0 +1,22 @@
+can_compile_extensions = false
+
+begin
+  require 'mkmf'
+  can_compile_extensions = true
+rescue Exception
+  # This will appear only in verbose mode.
+  $stderr.puts "Could not require 'mkmf'. Not fatal, the extensions are optional."
+end
+
+if can_compile_extensions && have_header('ruby.h')
+  extension_name = 'ccurl'
+  dir_config(extension_name)       # The destination
+  create_makefile(extension_name)  # Create Makefile
+else
+  # Create a dummy Makefile, to satisfy Gem::Installer#install
+  mfile = open("Makefile", "wb")
+  mfile.puts '.PHONY: install'
+  mfile.puts 'install:'
+  mfile.puts "\t" + '@echo "Extensions not installed, falling back to pure Ruby version."'
+  mfile.close
+end

data/ext/jcurl/JCurl.java

@@ -0,0 +1,126 @@
+package com.vmarakana;
+
+import java.util.Arrays;
+
+import org.jruby.Ruby;
+import org.jruby.RubyArray;
+import org.jruby.RubyClass;
+import org.jruby.RubyInteger;
+import org.jruby.RubyNil;
+import org.jruby.RubyObject;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+
+public class JCurl extends RubyObject {
+  /**
+   * The hash length.
+   */
+  public static final int HASH_LENGTH = 243;
+  private static final int STATE_LENGTH = 3 * HASH_LENGTH;
+
+  public static final int NUMBER_OF_ROUNDS = 81;
+  private int numberOfRounds;
+
+  private static final int[] TRUTH_TABLE = {1, 0, -1, 2, 1, -1, 0, 2, -1, 1, 0};
+  private final int[] scratchpad = new int[STATE_LENGTH];
+  private int[] state;
+
+  /**
+   * Java constructor
+   * @param ruby Ruby
+   * @param metaclass RubyClass
+   */
+  public JCurl(Ruby ruby, RubyClass rubyClass) {
+    super(ruby, rubyClass);
+  }
+
+  /**
+   *
+   * @param context ThreadContext
+   * @param klass IRubyObject
+   * @param args optional (no args rounds = NUMBER_OF_ROUNDS)
+   * @return new Vec3 object (ruby)
+   */
+  @JRubyMethod(name = "new", meta = true, rest = true)
+  public static IRubyObject rbNew(ThreadContext context, IRubyObject klass, IRubyObject... args) {
+    JCurl jcurl = (JCurl) ((RubyClass) klass).allocate();
+    jcurl.init(context, args);
+    return jcurl;
+  }
+
+  // This method is internal and not exposed
+  private IRubyObject init(ThreadContext context, IRubyObject... args) {
+    state = new int[STATE_LENGTH];
+
+    // Set rounds
+    if (args.length > 0 && args[0] instanceof RubyInteger) {
+      numberOfRounds = ((RubyInteger) args[0]).getIntValue();
+    } else {
+      numberOfRounds = NUMBER_OF_ROUNDS;
+    }
+
+    return new RubyNil(context.runtime);
+  }
+
+  @JRubyMethod
+  public IRubyObject transform(ThreadContext context) {
+    int scratchpadIndex = 0;
+    int prev_scratchpadIndex = 0;
+    for (int round = 0; round < numberOfRounds; round++) {
+      System.arraycopy(state, 0, scratchpad, 0, STATE_LENGTH);
+      for (int stateIndex = 0; stateIndex < STATE_LENGTH; stateIndex++) {
+        prev_scratchpadIndex = scratchpadIndex;
+        if (scratchpadIndex < 365) {
+          scratchpadIndex += 364;
+        } else {
+          scratchpadIndex += -365;
+        }
+        state[stateIndex] = TRUTH_TABLE[scratchpad[prev_scratchpadIndex] + (scratchpad[scratchpadIndex] << 2) + 5];
+      }
+    }
+
+    return new RubyNil(context.runtime);
+  }
+
+  @JRubyMethod
+  public IRubyObject absorb(ThreadContext context, final IRubyObject trits) {
+    int offset = 0;
+    int length = ((RubyArray) trits).getLength();
+
+    do {
+      System.arraycopy(trits.toJava(int[].class), offset, state, 0, length < HASH_LENGTH ? length : HASH_LENGTH);
+      transform(context);
+      offset += HASH_LENGTH;
+    } while ((length -= HASH_LENGTH) > 0);
+
+    return new RubyNil(context.runtime);
+  }
+
+  @JRubyMethod
+  public RubyNil squeeze(ThreadContext context, final IRubyObject trits) {
+    int offset = 0;
+    int length = ((RubyArray) trits).getLength();
+
+    do {
+      for(; length < HASH_LENGTH; length++) {
+        ((RubyArray) trits).append(context.runtime.newFixnum(0));
+      }
+
+      for (int i = 0; i < HASH_LENGTH; i++) {
+        ((RubyArray) trits).store(i, context.runtime.newFixnum(state[i]));
+      }
+
+      transform(context);
+      offset += HASH_LENGTH;
+    } while ((length -= HASH_LENGTH) > 0);
+
+    return new RubyNil(context.runtime);
+  }
+
+  @JRubyMethod
+  public IRubyObject reset(ThreadContext context) {
+    Arrays.fill(state, 0);
+    return new RubyNil(context.runtime);
+  }
+}

data/ext/jcurl/JCurlService.java

@@ -0,0 +1,36 @@
+package com.vmarakana;
+
+import java.io.IOException;
+
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.RubyModule;
+import org.jruby.runtime.ObjectAllocator;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.runtime.load.BasicLibraryService;
+
+public class JCurlService implements BasicLibraryService {
+  private Ruby runtime;
+
+  /**
+   * Basic load method of the BasicLibraryService, this method is
+   * invoked when the ruby code does the related require call.
+   * @param ruby An instance of the JRuby runtime.
+   * @return boolean True if everything was successful, false otherwise.
+   * @throws IOException is required to match the BasicLibraryService signature
+   */
+
+  @Override
+  public boolean basicLoad(final Ruby ruby) throws IOException {
+    RubyModule iota = ruby.defineModule("IOTA");
+    RubyModule crypto = iota.defineModuleUnder("Crypto");
+    RubyClass jcurl = crypto.defineClassUnder("JCurl", ruby.getObject(), new ObjectAllocator() {
+      public IRubyObject allocate(Ruby ruby1, RubyClass rubyClass) {
+        return new JCurl(ruby1, rubyClass);
+      }
+    });
+
+    jcurl.defineAnnotatedMethods(JCurl.class);
+    return true;
+  }
+}

data/iota-ruby.gemspec

@@ -0,0 +1,37 @@
+# coding: utf-8
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "iota/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "iota-ruby"
+  spec.version       = IOTA::VERSION
+  spec.authors       = ["Vivek Marakana"]
+  spec.email         = ["vivek.marakana@gmail.com"]
+
+  spec.summary       = "IOTA API wrapper for Ruby"
+  spec.description   = "Ruby gem for the IOTA core"
+  spec.homepage      = "https://github.com/vivekmarakana/iota.lib.rb"
+
+  spec.files         = `git ls-files`.split("\n") - [ "lib/jcurl.jar"]
+  spec.test_files    = `git ls-files -- test/*`.split("\n")
+  spec.require_paths = ["lib"]
+
+  if RUBY_PLATFORM =~ /java/
+    spec.platform      = "java"
+    spec.files         << "lib/jcurl.jar"
+  else
+    spec.extensions    = ["ext/ccurl/extconf.rb"]
+  end
+
+  spec.add_development_dependency "bundler", ">= 1.15"
+  spec.add_development_dependency "rake", ">= 10.0"
+  spec.add_development_dependency "minitest", ">= 5.0"
+  spec.add_development_dependency "rake-compiler", ">= 1.0.4"
+
+  unless RUBY_PLATFORM =~ /java/
+    spec.add_runtime_dependency "digest-sha3", "~> 1.1"
+  end
+
+  spec.add_runtime_dependency "ffi", "~> 1.9.25"
+end

data/lib/iota.rb

@@ -0,0 +1,76 @@
+require "patch"
+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/transport"
+require "iota/api/api"
+
+require "iota/crypto/pow_provider"
+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, :batch_size
+
+    def initialize(settings = {})
+      setSettings(settings)
+      @utils = IOTA::Utils::Utils.new
+      @validator = @utils.validator
+      @multisig = IOTA::Multisig::Multisig.new(self)
+    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
+      @batch_size = settings[:batch_size] || 500
+      @local_pow = settings[:local_pow] || false
+
+      if @sandbox
+        @sandbox = @provider.gsub(/\/$/, '')
+        @provider = @sandbox + '/commands'
+      end
+
+      @broker = IOTA::Utils::Broker.new(@provider, @token, @timeout, user: settings[:user], password: settings[:password])
+      @api = IOTA::API::Api.new(@broker, @sandbox, @batch_size, @local_pow)
+    end
+
+    def symbolize_keys(hash)
+      hash.inject({}){ |h,(k,v)| h[k.to_sym] = v; h }
+    end
+  end
+end

data/lib/iota/api/api.rb

@@ -0,0 +1,251 @@
+module IOTA
+  module API
+    class Api
+      include Wrappers
+      include Transport
+
+      attr_reader :pow_provider
+
+      def initialize(broker, sandbox, batch_size = 500, local_pow = false)
+        @broker = broker
+        @sandbox = sandbox
+        @commands = Commands.new
+        @utils = IOTA::Utils::Utils.new
+        @validator = @utils.validator
+        @batch_size = batch_size
+        @pow_provider = local_pow ? IOTA::Crypto::PowProvider.new : nil
+      end
+
+      def findTransactions(searchValues, &callback)
+        if !@validator.isObject(searchValues)
+          return sendData(false, "You have provided an invalid key value", &callback)
+        end
+
+        searchKeys = searchValues.keys
+        validKeys = ['bundles', 'addresses', 'tags', 'approvees']
+
+        error = false
+        entry_count = 0
+
+        searchKeys.each do |key|
+          if !validKeys.include?(key.to_s)
+            error = "You have provided an invalid key value"
+            break
+          end
+
+          hashes = searchValues[key]
+          entry_count += hashes.count
+
+          if key.to_s == 'addresses'
+            searchValues[key] = hashes.map do |address|
+              @utils.noChecksum(address)
+            end
+          end
+
+          # If tags, append to 27 trytes
+          if key.to_s == 'tags'
+            searchValues[key] = hashes.map do |hash|
+              # Simple padding to 27 trytes
+              while hash.length < 27
+                hash += '9'
+              end
+              # validate hash
+              if !@validator.isTrytes(hash, 27)
+                error = "Invalid Trytes provided"
+                break
+              end
+
+              hash
+            end
+          else
+            # Check if correct array of hashes
+            if !@validator.isArrayOfHashes(hashes)
+              error = "Invalid Trytes provided"
+              break
+            end
+          end
+        end
+
+        if error
+          return sendData(false, error, &callback)
+        else
+          if entry_count <= @batch_size || searchKeys.count > 1
+            return sendCommand(@commands.findTransactions(searchValues), &callback)
+          else
+            return sendBatchedCommand(@commands.findTransactions(searchValues), &callback)
+          end
+        end
+      end
+
+      def getBalances(addresses, threshold, &callback)
+        if !@validator.isArrayOfHashes(addresses)
+          return sendData(false, "Invalid Trytes provided", &callback)
+        end
+
+        command = @commands.getBalances(addresses.map{|address| @utils.noChecksum(address)}, threshold)
+        sendBatchedCommand(command, &callback)
+      end
+
+      def getTrytes(hashes, &callback)
+        if !@validator.isArrayOfHashes(hashes)
+          return sendData(false, "Invalid Trytes provided", &callback)
+        end
+
+        sendBatchedCommand(@commands.getTrytes(hashes), &callback)
+      end
+
+      def getInclusionStates(transactions, tips, &callback)
+        if !@validator.isArrayOfHashes(transactions) || !@validator.isArrayOfHashes(tips)
+          return sendData(false, "Invalid Trytes provided", &callback)
+        end
+
+        sendBatchedCommand(@commands.getInclusionStates(transactions, tips), &callback)
+      end
+
+      def getNodeInfo(&callback)
+        sendCommand(@commands.getNodeInfo, &callback)
+      end
+
+      def getNeighbors(&callback)
+        sendCommand(@commands.getNeighbors, &callback)
+      end
+
+      def addNeighbors(uris, &callback)
+        (0...uris.length).step(1) do |i|
+          return sendData(false, "You have provided an invalid URI for your Neighbor: " + uris[i], &callback) if !@validator.isUri(uris[i])
+        end
+
+        sendCommand(@commands.addNeighbors(uris), &callback)
+      end
+
+      def removeNeighbors(uris, &callback)
+        (0...uris.length).step(1) do |i|
+          return sendData(false, "You have provided an invalid URI for your Neighbor: " + uris[i], &callback) if !@validator.isUri(uris[i])
+        end
+
+        sendCommand(@commands.removeNeighbors(uris), &callback)
+      end
+
+      def getTips(&callback)
+        sendCommand(@commands.getTips, &callback)
+      end
+
+      def getTransactionsToApprove(depth, reference = nil, &callback)
+        # Check if correct depth
+        if !@validator.isValue(depth)
+          return sendData(false, "Invalid inputs provided", &callback)
+        end
+
+        sendCommand(@commands.getTransactionsToApprove(depth, reference), &callback)
+      end
+
+      def attachToTangle(trunkTransaction, branchTransaction, minWeightMagnitude, trytes, &callback)
+        # Check if correct trunk
+        if !@validator.isHash(trunkTransaction)
+          return sendData(false, "You have provided an invalid hash as a trunk: #{trunkTransaction}", &callback)
+        end
+
+        # Check if correct branch
+        if !@validator.isHash(branchTransaction)
+          return sendData(false, "You have provided an invalid hash as a branch: #{branchTransaction}", &callback)
+        end
+
+        # Check if minweight is integer
+        if !@validator.isValue(minWeightMagnitude)
+          return sendData(false, "Invalid minWeightMagnitude provided", &callback)
+        end
+
+        # Check if array of trytes
+        if !@validator.isArrayOfTrytes(trytes)
+          return sendData(false, "Invalid Trytes provided", &callback)
+        end
+
+        if @pow_provider.nil?
+          command = @commands.attachToTangle(trunkTransaction, branchTransaction, minWeightMagnitude, trytes)
+
+          sendCommand(command, &callback)
+        else
+          previousTxHash = nil
+          finalBundleTrytes = []
+
+          trytes.each do |current_trytes|
+            txObject = @utils.transactionObject(current_trytes)
+
+            if !previousTxHash
+              if txObject.lastIndex != txObject.currentIndex
+                return sendData(false, "Wrong bundle order. The bundle should be ordered in descending order from currentIndex", &callback)
+              end
+
+              txObject.trunkTransaction = trunkTransaction
+              txObject.branchTransaction = branchTransaction
+            else
+              txObject.trunkTransaction = previousTxHash
+              txObject.branchTransaction = trunkTransaction
+            end
+
+            txObject.attachmentTimestamp = (Time.now.to_f * 1000).to_i
+            txObject.attachmentTimestampLowerBound = 0
+            txObject.attachmentTimestampUpperBound = (3**27 - 1) / 2
+
+            newTrytes = @utils.transactionTrytes(txObject)
+
+            begin
+              returnedTrytes = @pow_provider.pow(newTrytes, minWeightMagnitude)
+
+              newTxObject= @utils.transactionObject(returnedTrytes)
+              previousTxHash = newTxObject.hash
+
+              finalBundleTrytes << returnedTrytes
+            rescue => e
+              return sendData(false, e.message, &callback)
+            end
+          end
+
+          sendData(true, finalBundleTrytes, &callback)
+        end
+      end
+
+      def interruptAttachingToTangle(&callback)
+        sendCommand(@commands.interruptAttachingToTangle, &callback)
+      end
+
+      def broadcastTransactions(trytes, &callback)
+        if !@validator.isArrayOfAttachedTrytes(trytes)
+          return sendData(false, "Invalid attached Trytes provided", &callback)
+        end
+
+        sendCommand(@commands.broadcastTransactions(trytes), &callback)
+      end
+
+      def storeTransactions(trytes, &callback)
+        if !@validator.isArrayOfAttachedTrytes(trytes)
+          return sendData(false, "Invalid attached Trytes provided", &callback)
+        end
+
+        sendCommand(@commands.storeTransactions(trytes), &callback)
+      end
+
+      def checkConsistency(tails, &callback)
+        if !@validator.isArrayOfHashes(tails)
+          return sendData(false, "Invalid tails provided", &callback)
+        end
+
+        sendCommand(@commands.checkConsistency(tails), &callback)
+      end
+
+      def wereAddressesSpentFrom(addresses, &callback)
+        if !@validator.isArrayOfHashes(addresses)
+          return sendData(false, "Invalid Trytes provided", &callback)
+        end
+
+        command = @commands.wereAddressesSpentFrom(addresses.map{|address| @utils.noChecksum(address)})
+        sendBatchedCommand(command, &callback)
+      end
+
+      private
+      def sendData(status, data, &callback)
+        callback ? callback.call(status, data) : [status, data]
+      end
+    end
+  end
+end