iota-ruby 1.1.8-java

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b762aee06e150e37e0998b97106204794c256078df463f5ca81a68abe77df44e
+  data.tar.gz: c0efd60e7d56ce9636b37d1e2e12e1ca71bd1baa9e2965d4ccce27708d28c4a0
+SHA512:
+  metadata.gz: 9d62b2da39b068fbbb78d03189dcfc83af26df4da42713e6f7cb6d00ce919903b3955c9ba3a3b52c2c8aa12c345a9771d4b5dff46a802fc0dc1546624af784a2
+  data.tar.gz: 371522bd00bebb25c36e12aa66b141afc0e560f4cd4fe4019e3402b7f80f2e1a7547468ac692ac203ae72a337a11fa3675748911105ee3424054d582023d4d58

data/.editorconfig

@@ -0,0 +1,8 @@
+root=true
+
+[*]
+end_of_line=lf
+insert_final_newline=true
+indent_style=space
+indent_size=2
+trim_trailing_whitespace=true

data/.gitignore

@@ -0,0 +1,15 @@
+*.gem
+Gemfile.lock
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+.DS_Store
+Makefile
+*.bundle
+*.o

data/.travis.yml

@@ -0,0 +1,24 @@
+sudo: false
+language: ruby
+dist: trusty
+osx_image: xcode9.3
+os:
+  - linux
+  - osx
+rvm:
+  - ruby-head
+  - 2.5.1
+  - 2.4.1
+  - jruby-head
+  - jruby-18mode
+  - jruby-19mode
+  - rbx-3
+matrix:
+  exclude:
+    - os: osx
+      rvm: rbx-3
+    - os: osx
+      rvm: ruby-head
+    - os: osx
+      rvm: jruby-head
+before_install: gem install bundler -v 1.15.0

data/.yardopts

@@ -0,0 +1,7 @@
+--protected
+--no-private
+--embed-mixin ClassMethods
+-
+README.md
+CHANGELOG.md
+LICENSE

data/CHANGELOG.md

@@ -0,0 +1,18 @@
+## [1.1.8] - 2019-07-15
+- minor fixes in IOTA::Crypto::Converter.trytes
+- Fixing some stuff in c extenstion to make it compatible with MRI ruby and Rubinius
+- adding support for Rubinius
+- adding support for JRuby platforms with native curl function in Java
+
+## [1.1.7] - 2018-12-02
+- adding `user` & `password` options to client
+- [Local PoW Support](https://github.com/vivekmarakana/iota.lib.rb#local-pow-support)
+
+## [1.1.6] - 2018-07-22
+### Added
+- `wasAddressSpentFrom` API
+- Inbuilt batching for following apis: `getTrytes`, `getBalances`, `wereAddressesSpentFrom`, `getInclusionStates` & `findTransactions`
+- adding changelog file to keep track of future changes
+
+### Old major changes
+- Only returning balance array as reponse for `getBalances` api call

data/Gemfile

@@ -0,0 +1,3 @@
+source "https://rubygems.org"
+
+gemspec

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 Vivek Marakana
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,121 @@
+# IOTA Ruby Gem
+
+[![Build Status](https://travis-ci.org/vivekmarakana/iota.lib.rb.svg?branch=master)](https://travis-ci.org/vivekmarakana/iota.lib.rb) [![Gem Version](https://badge.fury.io/rb/iota-ruby.svg)](https://badge.fury.io/rb/iota-ruby) [![GitHub license](https://img.shields.io/badge/license-MIT-blue.svg)](https://raw.githubusercontent.com/vivekmarakana/iota.lib.rb/master/LICENSE)
+
+This is the **unofficial** Ruby gem for the IOTA Core. It implements both the [official API](https://iota.readme.io/), as well as newly proposed functionality (such as signing, bundles, utilities, conversion, multi signature support and reattch/promote).
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'iota-ruby'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install iota-ruby
+
+
+# Documentation
+
+You can find basic documentation at: [https://vivekmarakana.gitbooks.io/iota-ruby](https://vivekmarakana.gitbooks.io/iota-ruby/)
+
+
+## Getting Started
+
+After you've successfully installed the library, it is fairly easy to get started by simply launching a new instance of the IOTA object with an optional settings object. When instantiating the object you have the option to decide the API provider that is used to send the requests to and you can also connect directly to the Sandbox environment.
+
+The optional settings object can have the following values:
+
+1. **`host`**: `String` Host you want to connect to. Can be DNS, IPv4 or IPv6. Defaults to `localhost `
+2. **`port`**: `Integer` port of the host you want to connect to. Defaults to 14265.
+2. **`user`**: `String` username for host if required.
+2. **`password`**: `String` password for host if required.
+3. **`provider`**: `String` If you don't provide host and port, you can supply the full provider value to connect to
+4. **`sandbox`**: `Boolean` Optional value to determine if your provider is the IOTA Sandbox or not.
+5. **`token`**: `String` Token string in case you are using sandbox.
+5. **`timeout`**: `Integer` Timeout in seconds for api requests to full node. Defaults to 120.
+5. **`batch_size`**: `Integer` Batch size for apis like `getTrytes`, `getBalances` etc. Defaults to 500.
+5. **`local_pow`**: `Boolean` Should PoW be done local machine or not. Defaults to `false` i.e. remote PoW.
+
+You can either supply the remote node directly via the `provider` option, or individually with `host` and `port`, as can be seen in the example below:
+
+```ruby
+require 'iota'
+
+# Create client with host and port as provider
+client = IOTA::Client.new(host: 'http://localhost', port: 14265)
+
+# Create client directly with provider
+client = IOTA::Client.new(provider: 'http://localhost:14265')
+
+# now you can start using all of the functions
+status, data = client.api.getNodeInfo
+```
+
+Overall, there are currently four subclasses that are accessible from the IOTA object:
+- **`api`**: Core API functionality for interacting with the IOTA core.
+- **`utils`**: Utility related functions for conversions, validation and so on
+- **`validator`**: Validator functions that can help with determining whether the inputs or results that you get are valid.
+- **`multisig`**: Functions for creating and signing multi-signature addresses and transactions.
+
+
+## How to use the Library
+
+All API calls are executed **synchronously** and returns array with 2 entries. First entry is `status` and second is `data`. However, you can use it by passing block to it as well.
+
+Here is a simple example of how to access the `getNodeInfo` function:
+
+```ruby
+# Method 1
+client.api.getNodeInfo do |status, data|
+  if !status
+    # If status is `false`, `data` contains error message...
+    puts data
+  else
+    # If status is `true`, `data` contains response...
+    puts data.inspect
+  end
+end
+
+# Method 2
+status, data = client.api.getNodeInfo
+if !status
+  puts data
+else
+  puts data.inspect
+end
+```
+
+## Local PoW Support
+
+If you want to use this gem with public full node which does not support remote PoW on host, you can set `local_pow` to `true` when initialising the client.
+
+```ruby
+require 'iota'
+
+# With remote PoW
+client = IOTA::Client.new(provider: 'https://node.iota-tangle.io:14265')
+# If you use `client.api.attachToTangle` api here, you'll get error saying that attachToTangle command is not allowed
+
+# With local pow
+client = IOTA::Client.new(provider: 'https://node.iota-tangle.io:14265', local_pow: true)
+# Now you can use `client.api.attachToTangle` api, which will do the proof-of-work on transaction and return the trytes that needs to be broadcasted
+```
+
+## Compatibility
+
+Tested on [Travis CI](https://travis-ci.org/vivekmarakana/iota.lib.rb) on following environment [configurations](https://github.com/vivekmarakana/iota.lib.rb/blob/master/.travis.yml):
+
+- ruby-head (Linux)
+- 2.5.1 (Linux & Mac)
+- 2.4.1 (Linux & Mac)
+- jruby-head (OpenJDK8/Linux)
+- jruby-19mode (OpenJDK8/Linux & OpenJDK8/OSX)
+- jruby-18mode (OpenJDK8/Linux & OpenJDK8/OSX)
+- rbx-3 (Linux)

data/Rakefile

@@ -0,0 +1,36 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+tasks = []
+
+if RUBY_PLATFORM =~ /java/
+  if ENV['TRAVIS'].to_s.empty?
+    puts "Will build JAVA extension"
+
+    require 'rake/javaextensiontask'
+    Rake::JavaExtensionTask.new "jcurl" do |ext|
+      ext.lib_dir = "lib"
+    end
+
+    tasks << :compile
+  else
+    puts "Not building jar for travis"
+  end
+else
+  puts "Will build C extension"
+
+  require 'rake/extensiontask'
+  Rake::ExtensionTask.new "ccurl" do |ext|
+    ext.lib_dir = "lib"
+  end
+
+  tasks << :compile
+end
+
+task :default => tasks + [:test]

data/bin/iota-console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "iota"
+
+require "irb"
+require "irb/completion"
+
+# Config IRB to enable --simple-prompt and auto indent
+IRB.conf[:PROMPT_MODE] = :SIMPLE
+IRB.conf[:AUTO_INDENT] = true
+
+puts "Gem loaded..."
+IRB.start
+

data/examples/multisig.rb

@@ -0,0 +1,69 @@
+require "bundler/setup"
+require "iota"
+
+iota = IOTA::Client.new(provider: 'http://localhost:14265')
+
+# First co-signer uses index 0 and security level 3
+digestOne = iota.multisig.getDigest('ABCDFG', 0, 3)
+
+# Second cosigner also uses index 0 and security level 3 for the private key
+digestTwo = iota.multisig.getDigest('FDSAG', 0, 3)
+
+# Initiate the multisig address generation
+address = IOTA::Multisig::Address.new
+
+# Absorb the first cosigners key digest
+address.absorb(digestOne)
+
+# Absorb the second cosigners key digest
+address.absorb(digestTwo)
+
+# and finally we finalize the address itself
+finalAddress = address.finalize()
+
+puts "MULTISIG ADDRESS: #{finalAddress}"
+
+# Simple validation if the multisig was created correctly
+# Can be called by each cosigner independently
+isValid = iota.multisig.validateAddress(finalAddress, [digestOne, digestTwo])
+
+puts "IS VALID MULTISIG ADDRESS: #{isValid}"
+
+
+# Transfers object
+multisigTransfer = [
+  {
+    address: 'ZGHXPZYDKXPEOSQTAQOIXEEI9K9YKFKCWKYYTYAUWXK9QZAVMJXWAIZABOXHHNNBJIEBEUQRTBWGLYMTX',
+    value: 999,
+    message: '',
+    tag: '999999999999999999999999999'
+  }
+]
+
+# Multisig address object, used as input
+input = {
+  address: finalAddress,
+  security: 6,
+  balance: 1000
+}
+
+# Define remainder address
+remainderAddress = 'NZRALDYNVGJWUVLKDWFKJVNYLWQGCWYCURJIIZRLJIKSAIVZSGEYKTZRDBGJLOA9AWYJQB9IPWRAKUC9FBDRZJZXZG'
+
+initiatedBundle = iota.multisig.initiateTransfer(input, remainderAddress, multisigTransfer)
+firstSignedBundle = iota.multisig.addSignature(initiatedBundle, finalAddress, iota.multisig.getKey('ABCDFG', 0, 3))
+finalBundle = iota.multisig.addSignature(firstSignedBundle, finalAddress, iota.multisig.getKey('FDSAG', 0, 3))
+
+puts "IS VALID SIGNATURE: #{iota.utils.validateSignatures(finalBundle, finalAddress)}"
+
+# Send signed transction
+# Uncomment following lines if you want to send transaction
+# trytes = finalBundle.map do |tx|
+#   iota.utils.transactionTrytes(tx)
+# end
+
+# iota.api.sendTrytes(trytes.reverse, 10, 14) do |st1, transactions|
+#   if st1
+#     puts data
+#   end
+# end

data/ext/ccurl/ccurl.c

@@ -0,0 +1,134 @@
+#include <ruby.h>
+#include <stdint.h>
+
+#define HASH_LENGTH 243
+#define NUMBER_OF_ROUNDS 81
+#define STATE_LENGTH 3 * HASH_LENGTH
+
+#ifndef RARRAY_LEN
+#  define RARRAY_LEN(x) return (long)NUM2INT(rb_funcall(x, rb_intern("length"), 0));
+#endif
+
+typedef int64_t trit_t;
+
+#define __TRUTH_TABLE 1,  0, -1, 1, -1,  0, -1,  1,  0
+
+static const trit_t TRUTH_TABLE[9] = {__TRUTH_TABLE};
+
+typedef struct {
+  int rounds;
+  trit_t state[STATE_LENGTH];
+} Curl;
+
+static VALUE ccurl_transform(VALUE self);
+
+static VALUE ccurl_alloc(VALUE klass) {
+  Curl *ctx = ALLOC(Curl);
+  return Data_Wrap_Struct(klass, 0, RUBY_DEFAULT_FREE, ctx);
+}
+
+static VALUE ccurl_init(VALUE self, VALUE rounds) {
+  Curl *ctx;
+  int requested = NUMBER_OF_ROUNDS;
+
+  if (TYPE(rounds) != T_NIL) {
+    requested =  NUM2INT(rounds);
+  }
+
+  Data_Get_Struct(self, Curl, ctx);
+
+  ctx->rounds = requested;
+  memset(ctx->state, (trit_t)0, STATE_LENGTH * sizeof(trit_t));
+
+  return self;
+}
+
+static VALUE ccurl_absorb(VALUE self, VALUE data) {
+  trit_t *trits;
+  int offset = 0;
+  int i;
+  int length = (int)RARRAY_LEN(data);
+
+  Curl *ctx;
+  Data_Get_Struct(self, Curl, ctx);
+
+  trits = (trit_t*)malloc(length * sizeof(trit_t));
+
+  for (i = 0; i < length; ++i) {
+    trits[i] = (trit_t)(NUM2LONG(rb_ary_entry(data, i)));
+  }
+
+  do {
+    memcpy(ctx->state, trits + offset, (length < HASH_LENGTH ? length : HASH_LENGTH) * sizeof(trit_t));
+    ccurl_transform(self);
+    offset += HASH_LENGTH;
+  } while ((length -= HASH_LENGTH) > 0);
+
+  free(trits);
+
+  return Qnil;
+}
+
+static VALUE ccurl_squeeze(VALUE self, VALUE data) {
+  int offset = 0;
+  int i;
+  int length = (int)RARRAY_LEN(data);
+
+  Curl *ctx;
+  Data_Get_Struct(self, Curl, ctx);
+
+  do {
+    for(; length < HASH_LENGTH; length++) {
+      rb_ary_push(data, LONG2NUM(0));
+    }
+
+    for (i = 0; i < HASH_LENGTH; i++) {
+      rb_ary_store(data, i, LONG2NUM(ctx->state[i]));
+    }
+
+    ccurl_transform(self);
+    offset += HASH_LENGTH;
+  } while ((length -= HASH_LENGTH) > 0);
+
+  return Qnil;
+}
+
+static VALUE ccurl_transform(VALUE self) {
+  trit_t scratchpad[STATE_LENGTH];
+  int round, scratchpadIndex=0, scratchpadIndexSave, stateIndex;
+
+  Curl *ctx;
+  Data_Get_Struct(self, Curl, ctx);
+
+  for (round = 0; round < NUMBER_OF_ROUNDS; round++) {
+    memcpy(scratchpad, ctx->state, STATE_LENGTH * sizeof(trit_t));
+
+    for (stateIndex = 0; stateIndex < STATE_LENGTH; stateIndex++) {
+      scratchpadIndexSave = scratchpadIndex;
+      scratchpadIndex += (scratchpadIndex < 365 ? 364 : -365);
+      ctx->state[stateIndex] = TRUTH_TABLE[scratchpad[scratchpadIndexSave ] + scratchpad[scratchpadIndex ] * 3 + 4];
+    }
+  }
+
+  return Qnil;
+}
+
+static VALUE ccurl_reset(VALUE self) {
+  Curl *ctx;
+  Data_Get_Struct(self, Curl, ctx);
+  memset(ctx->state, 0, STATE_LENGTH * sizeof(char));
+  return Qnil;
+}
+
+void Init_ccurl(void) {
+  VALUE iota = rb_define_module("IOTA");
+  VALUE iotaCrypto = rb_define_module_under(iota, "Crypto");
+  VALUE cCurl = rb_define_class_under(iotaCrypto, "CCurl", rb_cObject);
+
+  rb_define_alloc_func(cCurl, ccurl_alloc);
+  rb_define_method(cCurl, "initialize", ccurl_init, 1);
+  rb_define_method(cCurl, "absorb", ccurl_absorb, 1);
+  rb_define_method(cCurl, "squeeze", ccurl_squeeze, 1);
+  rb_define_method(cCurl, "transform", ccurl_transform, 0);
+  rb_define_method(cCurl, "reset", ccurl_reset, 0);
+}