nimiq-client 1.2.5

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 796ee1f34af9be69a84e3b1b59aff71840401276475d5efb516fc2189774a466
+  data.tar.gz: 747a9f96b6ec8c9f6d583501431bfc784dd55b7d938e2b1fac2525031f047c2a
+SHA512:
+  metadata.gz: 0a89a336e05db570df2d0c3ec7cdddcbf34109e5b4a6d893b92275828e33216a15b74f4419128b4297f30f67c5e49248a397e1d4d58499cf606609203fb57243
+  data.tar.gz: ef2e503c718ff2def5a9460733c58fd653c4ab47ce6fe9c354e4f8c127316889ce67410a204a13490050bc6914cc9d0b8c254e5c073bf1c0b86f2ce663497be9

data/bin/console

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+require "bundler/setup"
+require "nimiq"
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,6 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install

data/lib/api.rb

@@ -0,0 +1,397 @@
+=begin
+  Copyright 2020 Nimiq community.
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+=end
+
+require "sorbet-runtime"
+require_relative "types"
+
+module Api
+  attr_accessor :rpc
+  extend T::Sig
+
+  # accounts - Returns a list of addresses owned by client.
+  sig { returns(T::Array[Types::Account]) }
+
+  def accounts
+    result = @rpc.request("accounts")
+    return result
+  end
+
+  # block_number - Returns the height of most recent block.
+  sig { returns(Integer) }
+
+  def block_number
+    result = @rpc.request("blockNumber")
+    return result
+  end
+
+  # consensus - Returns information on the current consensus state.
+  sig { returns(String) }
+
+  def consensus
+    result = @rpc.request("consensus")
+    return result
+  end
+
+  # constant - Returns or overrides a constant value.
+  # When no parameter is given, it returns the value of the constant.
+  # When giving a value as parameter, it sets the constant to the given value.
+  # To reset the constant to the default value, the parameter "reset" should be used.
+  # - @param [String] name - The class and name of the constant. (format should be Class.CONSTANT)
+  # - @param [Integer] value - The new value of the constant or "reset". (optional)
+  sig { params(name: String, value: T.nilable(Integer)).returns(Integer) }
+
+  def constant(name, value = nil)
+    if value
+      result = @rpc.request("constant", name, value)
+    else
+      result = @rpc.request("constant", name)
+    end
+    return result
+  end
+
+  # create_account - Creates a new account and stores its private key in the client store.
+  sig { returns(Types::Wallet) }
+
+  def create_account
+    result = @rpc.request("createAccount")
+    return result
+  end
+
+  # create_raw_transaction - Creates and signs a transaction without sending it.
+  # The transaction can then be send via `send_raw_transaction` without accidentally replaying it.
+  # - @param [TransactionObject] transaction - The transaction object.
+  sig { params(transaction: Types::TransactionOutgoing).returns(String) }
+
+  def create_raw_transaction(transaction)
+    result = @rpc.request("createRawTransaction", transaction)
+    return result
+  end
+
+  # NEW
+  # get_raw_transaction_info - Checks signed_transaction raw information.
+  # - @param [String] signed_transaction - The hex encoded signed transaction.
+  sig { params(signed_transaction: String).returns(Object) }
+
+  def get_raw_transaction_info(signed_transaction)
+    result = @rpc.request("getRawTransactionInfo", signed_transaction)
+    return result
+  end
+
+  # get_account - Returns details for the account of given address.
+  # - @param [String] address - Address to get account details.
+  sig { params(address: String).returns(Types::Account) }
+
+  def get_account(address)
+    result = @rpc.request("getAccount", address)
+    return result
+  end
+
+  # get_balance - Returns the balance of the account of given address.
+  # - @param [String] address - Address to check for balance.
+  sig { params(address: String).returns(Integer) }
+
+  def get_balance(address)
+    result = @rpc.request("getBalance", address)
+    return result
+  end
+
+  # get_block_by_hash - Returns information about a block by hash.
+  # - @param [String] block_hash - Hash of the block to gather information on.
+  # - @param [Boolean] full_transactions (optional) - If true it returns the full transaction objects, if false only the hashes of the transactions. (default false)
+  sig { params(block_hash: String, full_transactions: T.nilable(T::Boolean)).returns(Types::Block) }
+
+  def get_block_by_hash(block_hash, full_transactions = nil)
+    if full_transactions
+      result = @rpc.request("getBlockByHash", block_hash, full_transactions)
+    else
+      result = @rpc.request("getBlockByHash", block_hash)
+    end
+    return result
+  end
+
+  # get_block_by_number - Returns information about a block by block number.
+  # - @param [Integer] block_number - The height of the block to gather information on.
+  # - @param [Boolean] full_transactions (optional) - If true it returns the full transaction objects, if false only the hashes of the transactions. (default false)
+  sig { params(block_number: Integer, full_transactions: T.nilable(T::Boolean)).returns(Types::Block) }
+
+  def get_block_by_number(block_number, full_transactions = nil)
+    if full_transactions
+      result = @rpc.request("getBlockByNumber", block_number, full_transactions)
+    else
+      result = @rpc.request("getBlockByNumber", block_number)
+    end
+    return result
+  end
+
+  # get_block_template - Returns a template to build the next block for mining.
+  # This will consider pool instructions when connected to a pool.
+  # - @param [String] address (optional) - Address to use as a miner for this block. This overrides the address provided during startup or from the pool.
+  # - @param [String] data_field (optional) - Hex-encoded value for the extra data field. This overrides the address provided during startup or from the pool.
+  sig { params(address: T.nilable(Integer), data_field: T.nilable(String)).returns(Types::BlockTemplate) }
+
+  def get_block_template(address = nil, data_field = nil)
+    result = @rpc.request("getBlockTemplate")
+    return result
+  end
+
+  # get_block_transaction_count_by_hash - Returns the number of transactions in a block from a block matching the given block hash.
+  # - @param [String] block_hash - Hash of the block.
+  sig { params(block_hash: String).returns(Integer) }
+
+  def get_block_transaction_count_by_hash(block_hash)
+    result = @rpc.request("getBlockTransactionCountByHash", block_hash)
+    return result
+  end
+
+  # get_block_transaction_count_by_number - Returns the number of transactions in a block matching the given block number.
+  # - @param [Integer] block_number - Height of the block.
+  sig { params(block_number: Integer).returns(Integer) }
+
+  def get_block_transaction_count_by_number(block_number)
+    result = @rpc.request("getBlockTransactionCountByNumber", block_number)
+    return result
+  end
+
+  # get_transaction_by_block_hash_and_index - Returns information about a transaction by block hash and transaction index position.
+  # - @param [String] block_hash - Hash of the block containing the transaction.
+  # - @param [Integer] transaction_index - Index of the transaction in the block.
+  sig { params(block_hash: String, transaction_index: Integer).returns(T.nilable(Types::Transaction)) }
+
+  def get_transaction_by_block_hash_and_index(block_hash, transaction_index)
+    result = @rpc.request("getTransactionByBlockHashAndIndex", block_hash, transaction_index)
+    return result
+  end
+
+  # get_transaction_by_block_number_and_index - Returns information about a transaction by block number and transaction index position.
+  # - @param [Integer] block_hash_index - Height of the block containing the transaction.
+  # - @param [Integer] transaction_index - Index of the transaction in the block.
+  sig { params(block_hash_index: Integer, transaction_index: Integer).returns(T.nilable(Types::Transaction)) }
+
+  def get_transaction_by_block_number_and_index(block_hash_index, transaction_index)
+    result = @rpc.request("getTransactionByBlockNumberAndIndex", block_hash_index, transaction_index)
+    return result
+  end
+
+  # get_transaction_by_hash - Returns the information about a transaction requested by transaction hash.
+  # - @param [String] transaction_hash - Hash of a transaction.
+  sig { params(transaction_hash: String).returns(T.nilable(Types::Transaction)) }
+
+  def get_transaction_by_hash(transaction_hash)
+    result = @rpc.request("getTransactionByHash", transaction_hash)
+    return result
+  end
+
+  # get_transaction_receipt - Returns the receipt of a transaction by transaction hash.
+  # Note That the receipt is not available for pending transactions.
+  # - @param [String] transaction_hash - Hash of a transaction.
+  sig { params(transaction_hash: String).returns(T.nilable(Types::TransactionReceipt)) }
+
+  def get_transaction_receipt(transaction_hash)
+    result = @rpc.request("getTransactionReceipt", transaction_hash)
+    return result
+  end
+
+  # get_transactions_by_address - Returns the latest transactions successfully performed by or for an address.
+  # - @param [String] address - Address of which transactions should be gathered.
+  # - @param [Integer] transactions_number (optional) - Number of transactions that shall be returned. (default 1000)
+  sig { params(address: String, transactions_number: T.nilable(Integer)).returns(T.nilable(T::Array[Types::Transaction])) }
+
+  def get_transactions_by_address(address, transactions_number = nil)
+    if transactions_number
+      result = @rpc.request("getTransactionsByAddress", address, transactions_number)
+    else
+      result = @rpc.request("getTransactionsByAddress", address)
+    end
+    return result
+  end
+
+  # get_work - Returns instructions to mine the next block. This will consider pool instructions when connected to a pool.
+  # - @param [String] address (optional) - Address to use as a miner for this block. This overrides the address provided during startup or from the pool.
+  # - @param [String] data_field (optional) - Hex-encoded value for the extra data field. This overrides the address provided during startup or from the pool.
+  sig { params(address: T.nilable(String), data_field: T.nilable(String)).returns(Types::MiningWork) }
+
+  def get_work(address = nil, data_field = nil)
+    result = @rpc.request("getWork", address, data_field)
+    return result
+  end
+
+  # hashrate - Returns the number of hashes per second that the node is mining with.
+  sig { returns(T.any(Integer, Float)) }
+
+  def hashrate
+    result = @rpc.request("hashrate")
+    return result
+  end
+
+  # log - Sets the log level of the node.
+  # - @param [String] tag - If the tag is '*' the log level will be set globally, otherwise the log level is applied only on this tag.
+  # - @param [String] log_level - Log levels valid options: `trace`, `verbose`, `debug`, `info`, `warn`, `error`, `assert`.
+  sig { params(tag: String, log_level: String).returns(T::Boolean) }
+
+  def log(tag, log_level)
+    result = @rpc.request("log", tag, log_level)
+    return result
+  end
+
+  # mempool - Returns information on the current mempool situation. This will provide an overview of the number of transactions sorted into buckets based on their fee per byte (in smallest unit).
+  sig { returns(Object) }
+
+  def mempool
+    result = @rpc.request("mempool")
+    return result
+  end
+
+  # mempool_content - Returns transactions that are currently in the mempool.
+  sig { params(include_full_transactions: T.nilable(T::Boolean)).returns(T.any(T.nilable(T::Array[Types::Transaction]), T.nilable(T::Array))) }
+
+  def mempool_content(include_full_transactions = nil)
+    result = @rpc.request("mempoolContent")
+    return result
+  end
+
+  # miner_address - Returns the miner address.
+  sig { returns(String) }
+
+  def miner_address
+    result = @rpc.request("minerAddress")
+    return result
+  end
+
+  # miner_threads - Returns or sets the number of CPU threads for the miner.
+  # - @param [Integer] set_threads (optional) - The number of threads to allocate for mining.
+  sig { params(set_threads: T.nilable(Integer)).returns(Integer) }
+
+  def miner_threads(set_threads = nil)
+    if set_threads
+      result = @rpc.request("minerThreads", set_threads)
+    else
+      result = @rpc.request("minerThreads")
+    end
+    return result
+  end
+
+  # min_fee_per_byte - Returns or sets the minimum fee per byte.
+  # - @param [Integer] set_min_fee (optional) - The new minimum fee per byte.
+  sig { params(set_min_fee: T.nilable(Integer)).returns(Integer) }
+
+  def min_fee_per_byte(set_min_fee = nil)
+    if set_min_fee
+      result = @rpc.request("minFeePerByte", set_min_fee)
+    else
+      result = @rpc.request("minFeePerByte")
+    end
+    return result
+  end
+
+  # mining - Returns `true` if client is actively mining new blocks.
+  sig { returns(T::Boolean) }
+
+  def mining
+    result = @rpc.request("mining")
+    return result
+  end
+
+  # peer_count - Returns number of peers currently connected to the client.
+  sig { returns(Integer) }
+
+  def peer_count
+    result = @rpc.request("peerCount")
+    return result
+  end
+
+  # peer_list - Returns list of peers known to the client.
+  sig { returns(T::Array[Types::Peer]) }
+
+  def peer_list
+    result = @rpc.request("peerList")
+    return result
+  end
+
+  # peer_state - Returns the state of the peer.
+  # - @param [String] peer_address - The address of the peer.
+  sig { params(peer_address: String).returns(Types::Peer) }
+
+  def peer_state(peer_address)
+    result = @rpc.request("peerState", peer_address)
+    return result
+  end
+
+  # pool - Returns or sets the mining pool.
+  # When no parameter is given, it returns the current mining pool. When a value is given as parameter, it sets the mining pool to that value.
+  # - @param [String/Boolean] pool_address (optional) - The mining pool connection string (url:port) or boolean to enable/disable pool mining.
+  sig { params(pool_address_or_action: T.nilable(T.any(String, T::Boolean))).returns(T.nilable(String)) }
+
+  def pool(pool_address_or_action = nil)
+    if pool_address_or_action
+      result = @rpc.request("pool", pool_address_or_action)
+    else
+      result = @rpc.request("pool")
+    end
+    return result
+  end
+
+  # pool_confirmed_balance - Returns the confirmed mining pool balance.
+  sig { returns(Integer) }
+
+  def pool_confirmed_balance
+    result = @rpc.request("poolConfirmedBalance")
+    return result
+  end
+
+  # pool_connection_state - Returns the connection state to mining pool.
+  sig { returns(Integer) }
+
+  def pool_connection_state
+    result = @rpc.request("poolConnectionState")
+    return result
+  end
+
+  # send_raw_transaction - Sends a signed message call transaction or a contract creation, if the data field contains code.
+  # - @param [String] signed_transaction - The hex encoded signed transaction.
+  sig { params(signed_transaction: String).returns(Object) }
+
+  def send_raw_transaction(signed_transaction)
+    result = @rpc.request("sendRawTransaction", signed_transaction)
+    return result
+  end
+
+  # send_transaction - Creates new message call transaction or a contract creation, if the data field contains code.
+  # - @param [TransactionObject] transaction - The transaction object.
+  sig { params(transaction: Types::TransactionOutgoing).returns(String) }
+
+  def send_transaction(transaction)
+    result = @rpc.request("sendTransaction", transaction)
+    return result
+  end
+
+  # submit_block - Submits a block to the node. When the block is valid, the node will forward it to other nodes in the network.
+  # When submitting work from getWork, remember to include the suffix.
+  # - @param [String] block - Hex-encoded full block (including header, interlink and body).
+  sig { params(block: String) }
+
+  def submit_block(block)
+    result = @rpc.request("submitBlock", block)
+    return result
+  end
+
+  # syncing - Returns an object with data about the sync status or `false`.
+  sig { returns(T.any(Object, T::Boolean)) }
+
+  def syncing
+    result = @rpc.request("syncing")
+    return result
+  end
+end

data/lib/nimiq-client.rb

@@ -0,0 +1,46 @@
+=begin
+  Copyright 2020 Nimiq community.
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+=end
+
+require_relative "nimiq/version"
+require_relative "rpc"
+require_relative "api"
+require "json"
+
+module Nimiq
+  class Error < StandardError; end # :nodoc: all
+
+  attr_reader :rpc # :nodoc: all
+
+  class Client
+    include Api
+
+    def initialize(opts)
+      puts "Connecting to #{opts[:host]}:#{opts[:port]}"
+      return @rpc = ClientRPC::Connect.new(opts)
+    end
+
+    # Sends a raw request to the Nimiq node.
+    def request(name, params = nil)
+      return @rpc.request(name, params)
+    end
+
+    # Ping the Nimiq node.
+    def ping
+      @rpc.ping_node
+      @pingres = @rpc.instance_variable_get(:@pingres)
+    end
+  end
+end

data/lib/nimiq/version.rb

@@ -0,0 +1,3 @@
+module Nimiq # :nodoc: all
+  VERSION = "1.2.5"
+end

data/lib/rpc.rb

@@ -0,0 +1,123 @@
+=begin
+  Copyright 2020 Nimiq community.
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+=end
+
+require "oj"
+require "net/http"
+
+# :nodoc: all
+module ClientRPC
+  class Connect
+    attr_accessor :options, :uri, :ssl
+
+    DEFAULTS = {
+      host: "localhost",
+      port: 18332,
+    # dev: true,
+    }.freeze
+
+    def initialize(host)
+      @options = DEFAULTS.dup.merge(host.dup)
+      @uri = @options[:uri] ? URI(@options[:uri]) : URI(uri_check())
+    end
+
+    def request(name, *args)
+      puts "\n> #{name}: #{args.join(",")}" if options[:dev]
+      response = request_http_post(name, args)
+      puts "< #{response.code} #{response.message}" if options[:dev]
+      raise Error, response.message unless (200...300).cover?(response.code.to_i)
+      begin
+        response = Oj.load(response.body, symbol_keys: true, bigdecimal_load: true)
+      rescue StandardError => e
+        puts "WARN < Failed to parse JSON response: #{e}" if options[:dev]
+        raise
+      end
+      puts "\n> #{name}: #{args.join(",")}" if options[:dev]
+      puts response[:result] if options[:dev]
+      raise Error, response[:error] if response[:error]
+      response[:result]
+    end
+
+    def ping_node
+      user = uri.user
+      pass = uri.password
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = true if @ssl
+      request = Net::HTTP::Get.new(uri.request_uri)
+      request.basic_auth(user, pass)
+      request.body = request_body("", nil)
+      request["Content-Type"] = "application/json".freeze
+      response = http.request(request)
+      @pingres = (response.code).to_i.dup
+    end
+
+    private
+
+    def request_http_post(name, params)
+      user = URI.decode(uri.user)
+      pass = URI.decode(uri.password)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = true if @ssl
+      request = Net::HTTP::Post.new(uri)
+      request.basic_auth(user, pass)
+      request.body = request_body(name, params)
+      request["Content-Type"] = "application/json".freeze
+      http.request(request)
+    end
+
+    def request_body(name, params)
+      Oj.dump({
+        id: 0,
+        jsonrpc: "2.0",
+        method: name,
+        params: params,
+      }, mode: :compat)
+    end
+
+    def uri_check
+      if (options[:host].include? "http://" or options[:host].include? "https://")
+        host = options[:host]
+        newhost = url_strip(host.dup)
+        if (options[:host].include? "https")
+          @ssl = true
+          if options[:pass]
+            return "https://#{options[:user]}:#{URI.encode(options[:pass])}@#{newhost}:#{options[:port]}"
+          else
+            return "https://#{options[:user]}:@#{newhost}:#{options[:port]}"
+          end
+        else
+          if options[:pass]
+            return "http://#{options[:user]}:#{URI.encode(options[:pass])}@#{newhost}:#{options[:port]}"
+          else
+            return "http://#{options[:user]}:@#{newhost}:#{options[:port]}"
+          end
+        end
+      else
+        if options[:pass]
+          return "http://#{options[:user]}:#{URI.encode(options[:pass])}@#{options[:host]}:#{options[:port]}"
+        else
+          return "http://#{options[:user]}:@#{options[:host]}:#{options[:port]}"
+        end
+      end
+    end
+
+    def url_strip(url)
+      return url.to_s.sub!(/https?(\:)?(\/)?(\/)?(www\.)?/, "") if url.include?("http")
+      url.to_s.sub!(/(www\.)?/, "") if url.include?("www")
+    end
+
+    class Error < RuntimeError; end
+  end
+end

data/lib/types.rb

@@ -0,0 +1,111 @@
+require "sorbet-runtime"
+
+# :nodoc: all
+module Types
+  extend T::Sig
+
+  Block = {
+    number: Integer,
+    hash: String,
+    pow: String,
+    parentHash: String,
+    nonce: Integer,
+    bodyHash: String,
+    accountsHash: String,
+    miner: String,
+    minerAddress: String,
+    difficulty: String,
+    extraData: String,
+    size: Integer,
+    timestamp: Integer,
+    transactions: Array,
+    confirmations: T.nilable(Integer),
+  }
+
+  BlockTemplate = {
+    header: {
+      version: Integer,
+      prevHash: String,
+      interlinkHash: String,
+      accountsHash: String,
+      nBits: Integer,
+      height: Integer,
+    },
+    interlink: String,
+    body: {
+      hash: String,
+      minerAddr: String,
+      extraData: String,
+      transactions: T::Array[String],
+      prunedAccounts: T::Array[String],
+      merkleHashes: T::Array[String],
+    },
+    target: Integer,
+  }
+
+  Wallet = {
+    id: String,
+    address: String,
+    publicKey: String,
+  }
+
+  Account = {
+    id: String,
+    address: String,
+    balance: Integer,
+    type: Integer,
+  }
+
+  Transaction = {
+    hash: String,
+    blockHash: T.nilable(String),
+    blockNumber: T.nilable(Integer),
+    timestamp: T.nilable(Integer),
+    confirmations: T.nilable(Integer),
+    transactionIndex: T.nilable(Integer),
+    from: String,
+    fromAddress: String,
+    to: String,
+    toAddress: String,
+    value: Integer,
+    fee: Integer,
+    data: T.nilable(String),
+    flags: Integer,
+  }
+
+  TransactionOutgoing = {
+    from: String,
+    to: String,
+    value: Integer,
+    fee: Integer,
+  }
+
+  TransactionReceipt = {
+    transactionHash: String,
+    transactionIndex: Integer,
+    blockNumber: Integer,
+    blockHash: String,
+    confirmations: Integer,
+    timestamp: Integer,
+  }
+
+  MiningWork = {
+    data: String,
+    suffix: String,
+    target: Integer,
+    algorithm: String,
+  }
+
+  Peer = {
+    id: String,
+    address: String,
+    addressState: Integer,
+    connectionState: T.nilable(Integer),
+    version: T.nilable(Integer),
+    timeOffset: T.nilable(Integer),
+    headHash: T.nilable(String),
+    latency: T.nilable(Integer),
+    rx: T.nilable(Integer),
+    tx: T.nilable(Integer),
+  }
+end

data/spec/client_spec.rb

@@ -0,0 +1,301 @@
+=begin
+  Copyright 2020 Nimiq community.
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+=end
+
+$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
+require "ruby-client"
+
+describe "Nimiq", type: :request do
+
+  # Initialize
+  before(:all) do
+    options = {
+      host: "localhost",
+      port: "8648",
+    # user: "user",
+    # pass: "pass",
+    # dev: true,
+    }
+    @main_addr = "NQ70 46LN 1SKC KGFN VV8U G92N XC4X 9VFB SBVJ" # Node address
+    @seco_addr = "NQ27 B9ED 98G5 3VH7 FY8D BFP0 XNF4 BD8L TN4B" # Some address
+    @signed_transaction = "000000.......1A84FA23" # get this by running Makes @signed_transaction
+    @nimiq = Nimiq::Client.new(options)
+  end
+
+  # Test suite for client
+  describe "RPC Client" do
+
+    # Test suite for client version
+    it "Must have a version." do
+      expect(::Nimiq::VERSION).not_to eq(nil)
+    end
+
+    # Test suite for client connection
+    it "Must be able to connect to the Nimiq node." do
+      expect(@nimiq.ping).to eq(200)
+    end
+
+    # Test suite for client to send raw requests
+    it "Must be able to send raw requests." do
+      expect(@nimiq.request("consensus")).to be_a_kind_of(String)
+    end
+  end
+
+  # Test suite for API
+  describe "Api" do
+
+    # Test suite for client to retrieve the addresses owned by client.
+    it "Must be able to retrieve addresses owned by client." do
+      expect(@nimiq.accounts()).to be_a_kind_of(Object)
+    end
+
+    # Test suite for client to retrieve height of most recent block.
+    it "Must be able to retrieve height of most recent block." do
+      expect(@nimiq.block_number()).to be_a_kind_of(Object)
+    end
+
+    # Test suite for client to retrieve the consensus status.
+    it "Must be able to retrieve the consensus status." do
+      expect(@nimiq.consensus()).to be_a_kind_of(String)
+    end
+
+    # Test suite for client to override a constant value.
+    it "Must be able to override a constant value." do
+      constant_value = 10
+      expect(@nimiq.constant("BaseConsensus.MAX_ATTEMPTS_TO_FETCH", constant_value)).to eq(constant_value)
+    end
+
+    # Test suite for client to retrieve a constant value.
+    it "Must be able to retrieve a constant value." do
+      expect(@nimiq.constant("BaseConsensus.MAX_ATTEMPTS_TO_FETCH")).to eq(10)
+    end
+
+    # Test suite for client to create a new account.
+    it "Must be able to create a new account." do
+      expect(@nimiq.create_account()).to be_a_kind_of(Object)
+    end
+
+    # Test suite for client to retrieve information related to an account.
+    it "Must be able to retrieve information related to an account." do
+      expect(@nimiq.get_account(@seco_addr)).to be_a_kind_of(Object)
+    end
+
+    # Test suite for client to retrieve balance of account.
+    it "Must be able to retrieve balance of account." do
+      expect(@nimiq.get_balance(@main_addr)).to be_a_kind_of(Integer)
+    end
+
+    # Test suite for client to retrieve block by hash.
+    it "Must be able to retrieve block by hash." do
+      expect(@nimiq.get_block_by_hash("14c91f6d6f3a0b62271e546bb09461231ab7e4d1ddc2c3e1b93de52d48a1da87", false)).to be_a_kind_of(Object)
+    end
+
+    # Test suite for client to retrieve block by hash, full transactions included.
+    it "Must be able to retrieve block by hash, full transactions included." do
+      expect(@nimiq.get_block_by_hash("14c91f6d6f3a0b62271e546bb09461231ab7e4d1ddc2c3e1b93de52d48a1da87", true)).to be_a_kind_of(Object)
+    end
+
+    # Test suite for client to retrieve block by number.
+    it "Must be able to retrieve block by number." do
+      expect(@nimiq.get_block_by_number(76415, false)).to be_a_kind_of(Object)
+    end
+
+    # Test suite for client to retrieve block by number, full transactions included.
+    it "Must be able to retrieve block by number, full transactions included." do
+      expect(@nimiq.get_block_by_number(76415, true)).to be_a_kind_of(Object)
+    end
+
+    # Test suite for client to retrieve block template.
+    it "Must be able to retrieve block template." do
+      expect(@nimiq.get_block_template()).to be_a_kind_of(Object)
+    end
+
+    # Test suite for client to retrieve the number of transactions in a block by block hash.
+    it "Must be able to retrieve the number of transactions in a block by block hash." do
+      expect(@nimiq.get_block_transaction_count_by_hash("dfe7d166f2c86bd10fa4b1f29cd06c13228f893167ce9826137c85758645572f")).to be_a_kind_of(Integer)
+    end
+
+    # Test suite for client to retrieve the number of transactions in a block by block number.
+    it "Must be able to retrieve the number of transactions in a block by block number." do
+      expect(@nimiq.get_block_transaction_count_by_number(76415)).to be_a_kind_of(Integer)
+    end
+
+    # Test suite for client to retrieve information about a transaction by block hash and transaction index position.
+    it "Must be able to retrieve information about a transaction by block hash and transaction index position." do
+      expect(@nimiq.get_transaction_by_block_hash_and_index("dfe7d166f2c86bd10fa4b1f29cd06c13228f893167ce9826137c85758645572f", 20)).to be_a_kind_of(Object)
+    end
+
+    # Test suite for client to retrieve information about a transaction by block number and transaction index position.
+    it "Must be able to retrieve information about a transaction by block number and transaction index position." do
+      expect(@nimiq.get_transaction_by_block_number_and_index(76415, 20)).to be_a_kind_of(Object)
+    end
+
+    # Test suite for client to retrieve the information about a transaction requested by transaction hash.
+    it "Must be able to retrieve the information about a transaction requested by transaction hash." do
+      expect(@nimiq.get_transaction_by_hash("465a63b73aa0b9b54b777be9a585ea00b367a17898ad520e1f22cb2c986ff554")).to be_a_kind_of(Object)
+    end
+
+    # Test suite for client to retrieve the receipt of a transaction by transaction hash.
+    it "Must be able to retrieve the receipt of a transaction by transaction hash." do
+      expect(@nimiq.get_transaction_receipt("465a63b73aa0b9b54b777be9a585ea00b367a17898ad520e1f22cb2c986ff554")).to be_a_kind_of(Object)
+    end
+
+    # Test suite for client to retrieve the latest transactions successfully performed by or for an address.
+    it "Must be able to retrieve the latest transactions successfully performed by or for an address." do
+      expect(@nimiq.get_transactions_by_address("NQ699A4AMB83HXDQ4J46BH5R4JFFQMA9C3GN", 100)).to be_a_kind_of(Object)
+    end
+
+    # Test suite for client to retrieve instructions to mine the next block.
+    it "Must be able to retrieve instructions to mine the next block." do
+      expect(@nimiq.get_work()).to be_a_kind_of(Object)
+    end
+
+    # Test suite for client to retrieve the number of hashes per second that the node is mining with.
+    it "Must be able to retrieve the number of hashes per second that the node is mining with." do
+      expect(@nimiq.hashrate()).to be_a_kind_of(Integer)
+    end
+
+    # Test suite for client to set the log level of the node.
+    it "Must be able to set the log level of the node." do
+      expect(@nimiq.log("BaseConsensus", "debug")).to be(true).or be(false)
+    end
+
+    # Test suite for client to retrieve information on the current mempool situation.
+    it "Must be able to retrieve information on the current mempool situation." do
+      expect(@nimiq.mempool()).to be_a_kind_of(Object)
+    end
+
+    # Test suite for client to retrieve transactions that are currently in the mempool.
+    it "Must be able to retrieve transactions that are currently in the mempool." do
+      expect(@nimiq.mempool_content()).to be_a_kind_of(Object)
+    end
+
+    # Test suite for client to retrieve miner address.
+    it "Must be able to retrieve miner address." do
+      expect(@nimiq.miner_address()).to be_a_kind_of(String)
+    end
+
+    # Test suite for client to set the number of CPU threads for the miner.
+    it "Must be able to set the number of CPU threads for the miner." do
+      expect(@nimiq.miner_threads(2)).to be_a_kind_of(Integer)
+    end
+
+    # Test suite for client to retrieve the number of CPU threads for the miner.
+    it "Must be able to retrieve the number of CPU threads for the miner." do
+      expect(@nimiq.miner_threads()).to be_a_kind_of(Integer)
+    end
+
+    # Test suite for client to set the minimum fee per byte.
+    it "Must be able to set the minimum fee per byte." do
+      expect(@nimiq.min_fee_per_byte(1)).to be_a_kind_of(Integer)
+    end
+
+    # Test suite for client to retrieve the minimum fee per byte.
+    it "Must be able to retrieve the minimum fee per byte." do
+      expect(@nimiq.min_fee_per_byte()).to be_a_kind_of(Integer)
+    end
+
+    # Test suite for client to retrieve if client is actively mining new blocks.
+    it "Must be able to retrieve if client is actively mining new blocks." do
+      expect(@nimiq.mining()).to be(true).or be(false)
+    end
+
+    # Test suite for client to retrieve the number of peers currently connected to the client.
+    it "Must be able to retrieve the number of peers currently connected to the client." do
+      expect(@nimiq.peer_count()).to be_a_kind_of(Integer)
+    end
+
+    # Test suite for client to retrieve the list of peers known to the client.
+    it "Must be able to retrieve the list of peers known to the client." do
+      expect(@nimiq.peer_list()).to be_a_kind_of(Object)
+    end
+
+    # Test suite for client to retrieve the state of the peer.
+    it "Must be able to retrieve the state of the peer." do
+      expect(@nimiq.peer_state("wss://seed-1.nimiq.com:8443/dfd55fe967d6c0ca707d3a73ec31e4ac")).to be_a_kind_of(Object)
+    end
+
+    # Test suite for client to set the mining pool.
+    it "Must be able to set the mining pool." do
+      expect(@nimiq.pool("eu.nimpool.io:8444")).to be_a_kind_of(String).or be(nil)
+    end
+
+    # Test suite for client to retrieve the mining pool.
+    it "Must be able to retrieve the mining pool." do
+      expect(@nimiq.pool()).to be_a_kind_of(String).or be(nil)
+    end
+
+    # Test suite for client to retrieve the confirmed mining pool balance.
+    it "Must be able to retrieve the confirmed mining pool balance." do
+      expect(@nimiq.pool_confirmed_balance()).to be_a_kind_of(Integer)
+    end
+
+    # Test suite for client to retrieve the connection state to mining pool.
+    it "Must be able to retrieve the connection state to mining pool." do
+      expect(@nimiq.pool_connection_state()).to be_a_kind_of(Integer)
+    end
+
+    # Makes @signed_transaction
+    # Test suite for client to create a transaction without sending it.
+    it "Must be able to create a transaction without sending it." do
+      transaction = {
+        "from": @main_addr,
+        "to": @seco_addr,
+        "value": 100,
+        "fee": 0,
+      }
+      @signed_transaction = @nimiq.create_raw_transaction(transaction)
+      expect(@signed_transaction).to be_a_kind_of(Object)
+    end
+
+    # NEW
+    # Test suite for client to retrieve a transaction information.
+    it "Must be able to retrieve a transaction information." do
+      #   expect(@nimiq.get_raw_transaction_info(@signed_transaction)).to be_a_kind_of(Object)
+      expect(@nimiq.get_raw_transaction_info("009de5aeefe9fa3b4017cbf460e863831808d121b614ae034337a69cdabbeeb4185a5cd4a2051f6277fd0d5bee0f59e45b514dd88b000000000000006400000000000000000007f8642afa9861e3dd9c708318aba517f0d40882af99579841cc78afd395927de3913b88c87990659a6c55b2ee28c073559520fe685c051f2daa7cc63ffb9caa9ac9e20f")).to be_a_kind_of(Object)
+    end
+
+    # Test suite for client to retrieve an object with data about the sync status.
+    it "Must be able to retrieve an object with data about the sync status." do
+      expect(@nimiq.syncing()[:startingBlock]).to be > 0
+    end
+
+    # # Must have at least some NIM to be able to send it to another address
+    # # Test suite for client to send a signed message call transaction or a contract creation, if the data field contains code.
+    # it "Must be able to send a signed message call transaction or a contract creation, if the data field contains code." do
+    #   expect(@nimiq.send_raw_transaction(@signed_transaction)).to be_a_kind_of(Object)
+    # end
+
+    # # Must have at least some NIM to be able to send it to another address
+    # # Test suite for client to create new message call transaction or a contract creation, if the data field contains code.
+    # it "Must be able to create new message call transaction or a contract creation, if the data field contains code." do
+    #   transaction = {
+    #     "from": @main_addr,
+    #     "to": @seco_addr,
+    #     "value": 100,
+    #     "fee": 0,
+    #   }
+    #   expect(@nimiq.send_transaction(transaction)).to be_a_kind_of(Object)
+    # end
+
+    # # Must have a valid generated block for the blockchain to accept, returns nothing if block is valid
+    # # Test suite for client to submit a block to the node.
+    # it "Must be able to submit a block to the node." do
+    #   block = "14c91f6d6f3a0b62271e546bb09461231ab7e4d1ddc2c3e1b93de52d48a1da87"
+    #   expect(@nimiq.submit_block(block)).to be("")
+    # end
+
+  end
+end

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification
+name: nimiq-client
+version: !ruby/object:Gem::Version
+  version: 1.2.5
+platform: ruby
+authors:
+- jxdv
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2020-08-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: oj
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.15'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.15'
+description: Ruby implementation of the Nimiq RPC client specification.
+email:
+- root@localhost
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/console
+- bin/setup
+- lib/api.rb
+- lib/nimiq-client.rb
+- lib/nimiq/version.rb
+- lib/rpc.rb
+- lib/types.rb
+- spec/client_spec.rb
+homepage: https://github.com/nimiq-community/ruby-client
+licenses:
+- Apache-2.0
+metadata:
+  homepage_uri: https://github.com/nimiq-community/ruby-client
+  source_code_uri: https://github.com/nimiq-community/ruby-client
+  changelog_uri: https://github.com/nimiq-community/ruby-client/readme.md
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.4
+signing_key: 
+specification_version: 4
+summary: Ruby implementation of the Nimiq RPC client specification.
+test_files: []