iota-ruby 1.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d338628f110c60d06b1b639d25dd4773839658bf
+  data.tar.gz: 7e06e28d669a453fcf59373c099f209519342c17
+SHA512:
+  metadata.gz: 95ef1fb4978e645b6b6baed2822764ee0e60fa4cfa9f2439073c3a0a35b7ddf2e4bfb854b640123805246a440ec9ca441ba18a8c2a4804ccdd7c10556105332c
+  data.tar.gz: e12509d8fa7ec4b673aaafbccd7a7fee6888fb70d33943e4ca66a73b986653f6ce857a6f3f837cc2181c955d6397040eac62354b8bd644795c91195380e03541

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,12 @@
+*.gem
+Gemfile.lock
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+.DS_Store

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.4.1
+before_install: gem install bundler -v 1.15.0

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,88 @@
+# IOTA Ruby Gem
+
+[![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 and conversion).
+
+This gem is a **beta release**. If you find any bug or face issue, please [post it here](https://github.com/vivekmarakana/iota.lib.rb/issues).
+
+**Note: This release does not have multi signature support. It will be added after successful testing of this version**
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'iota-ruby', '~> 1.0.1', require: 'iota'
+```
+
+And then execute:
+
+    $ bundle
+
+
+# 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`**: `Int` port of the host you want to connect to. Defaults to 14265.
+3. **`provider`**: `String` If you don't provide host and port, you can supply the full provider value to connect to
+4. **`sandbox`**: `Bool` Optional value to determine if your provider is the IOTA Sandbox or not.
+5. **`token`**: `String` Token string in case you are using sandbox.
+
+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
+# 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`**: *In progress*
+
+
+## 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
+```
+
+If you'd like to support development, please consider donating to my IOTA address: **LOBYBAFIKJFEGTLCCQSHOPX9ROIRAI99QSTD9BRALHMHUOISF9DIZJYICXAIQMJCPZYTXMRMPOWG9WOICGMMNHQIH9**

data/Rakefile

@@ -0,0 +1,10 @@
+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
+
+task :default => :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,57 @@
+require "bundler/setup"
+require "iota"
+
+iota = IOTA::Client.new(provider: 'http://node.lukaseder.de: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)}"

data/iota-ruby.gemspec

@@ -0,0 +1,25 @@
+# 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")
+  spec.test_files    = `git ls-files -- test/*`.split("\n")
+  spec.executables   = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.15"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest", "~> 5.0"
+  spec.add_dependency "digest-sha3", "~> 1.1"
+end

data/lib/iota/api/api.rb

@@ -0,0 +1,194 @@
+module IOTA
+  module API
+    class Api
+      include Wrappers
+
+      def initialize(broker, sandbox)
+        @broker = broker
+        @sandbox = sandbox
+        @commands = Commands.new
+        @utils = IOTA::Utils::Utils.new
+        @validator = @utils.validator
+      end
+
+      def sendCommand(command, &callback)
+        @broker.send(command, &callback)
+      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;
+
+        searchKeys.each do |key|
+          if !validKeys.include?(key.to_s)
+            error = "You have provided an invalid key value"
+            break
+          end
+
+          hashes = searchValues[key]
+
+          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
+          sendCommand(@commands.findTransactions(searchValues), &callback)
+        end
+      end
+
+      def getBalances(addresses, threshold, &callback)
+        # Check if correct transaction hashes
+        if !@validator.isArrayOfHashes(addresses)
+          return sendData(false, "Invalid Trytes provided", &callback)
+        end
+
+        command = @commands.getBalances(addresses.map{|address| @utils.noChecksum(address)}, threshold)
+        sendCommand(command, &callback)
+      end
+
+      def getTrytes(hashes, &callback)
+        if !@validator.isArrayOfHashes(hashes)
+          return sendData(false, "Invalid Trytes provided", &callback)
+        end
+
+        sendCommand(@commands.getTrytes(hashes), &callback)
+      end
+
+      def getInclusionStates(transactions, tips, &callback)
+        # Check if correct transaction hashes
+        if !@validator.isArrayOfHashes(transactions)
+          return sendData(false, "Invalid Trytes provided", &callback)
+        end
+
+        # Check if correct tips
+        if !@validator.isArrayOfHashes(tips)
+          return sendData(false, "Invalid Trytes provided", &callback)
+        end
+
+        sendCommand(@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, &callback)
+        # Check if correct depth
+        if !@validator.isValue(depth)
+          return sendData(false, "Invalid inputs provided", &callback)
+        end
+
+        sendCommand(@commands.getTransactionsToApprove(depth), &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/branch: " + trunkTransaction, &callback)
+        end
+
+        # Check if correct branch
+        if !@validator.isHash(branchTransaction)
+          return sendData(false, "You have provided an invalid hash as a trunk/branch: " + branchTransaction, &callback)
+        end
+
+        # Check if minweight is integer
+        if !@validator.isValue(minWeightMagnitude)
+          return sendData(false, "Invalid inputs provided", &callback)
+        end
+
+        # Check if array of trytes
+        if !@validator.isArrayOfTrytes(trytes)
+          return sendData(false, "Invalid Trytes provided", &callback)
+        end
+
+        command = @commands.attachToTangle(trunkTransaction, branchTransaction, minWeightMagnitude, trytes)
+
+        sendCommand(command, &callback)
+      end
+
+      def interruptAttachingToTangle(&callback)
+        this.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
+
+      private
+      def sendData(status, data, &callback)
+        callback ? callback.call(status, data) : [status, data]
+      end
+    end
+  end
+end

data/lib/iota/api/commands.rb

@@ -0,0 +1,99 @@
+module IOTA
+  module API
+    class Commands
+      def findTransactions(searchValues)
+        command = {
+          command: 'findTransactions'
+        }
+
+        searchValues.each { |k, v| command[k] = v }
+
+        command
+      end
+
+      def getBalances(addresses, threshold)
+        {
+          command: 'getBalances',
+          addresses: addresses,
+          threshold: threshold
+        }
+      end
+
+      def getTrytes(hashes)
+        {
+          command: 'getTrytes',
+          hashes: hashes
+        }
+      end
+
+      def getInclusionStates(transactions, tips)
+        {
+          command: 'getInclusionStates',
+          transactions: transactions,
+          tips: tips
+        }
+      end
+
+      def getNodeInfo
+        { command: 'getNodeInfo'}
+      end
+
+      def getNeighbors
+        { command: 'getNeighbors' }
+      end
+
+      def addNeighbors(uris)
+        {
+          command: 'addNeighbors',
+          uris: uris
+        }
+      end
+
+      def removeNeighbors(uris)
+        {
+          command: 'removeNeighbors',
+          uris: uris
+        }
+      end
+
+      def getTips
+        { command: 'getTips' }
+      end
+
+      def getTransactionsToApprove(depth)
+        {
+          command: 'getTransactionsToApprove',
+          depth: depth
+        }
+      end
+
+      def attachToTangle(trunkTransaction, branchTransaction, minWeightMagnitude, trytes)
+        {
+          command: 'attachToTangle',
+          trunkTransaction: trunkTransaction,
+          branchTransaction: branchTransaction,
+          minWeightMagnitude: minWeightMagnitude,
+          trytes: trytes
+        }
+      end
+
+      def interruptAttachingToTangle
+        { command: 'interruptAttachingToTangle' }
+      end
+
+      def broadcastTransactions(trytes)
+        {
+          command: 'broadcastTransactions',
+          trytes: trytes
+        }
+      end
+
+      def storeTransactions(trytes)
+        {
+          command: 'storeTransactions',
+          trytes: trytes
+        }
+      end
+    end
+  end
+end