ruby-client 1.2.1 → 1.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a9cbceaff727c1601dbbf78879035b2c50b39eb5ef4b7fed087f5a2f7f0d4407
-  data.tar.gz: bd246520a81e9b9e49b7cbc633b63d864e52f14e75b8a4172f50265198435321
+  metadata.gz: 4711b6ed9140348c52a5e03c44e1b11d62e57215388e2132caaf2accf6645b64
+  data.tar.gz: d97fe8bb83867f89123ed94985ef0dcc0a1edd1cce46fba8d9933c4958189a83
 SHA512:
-  metadata.gz: b9cdb891227cdf90368e0c946cd0e462547c440f05568c7d2188fccf569f602510345da6249ed88890bef3ff2daecc78527a928d976235dafb6061546b251b39
-  data.tar.gz: c2de54be6a948a5d4db0fbbc9d796a74f3e69503da3c7879c7daf3e86c8ff05bac306db1ea92b2b92b60faf39b05fd97a3c2dcdcf9bee4e937d7e37fe5001e28
+  metadata.gz: 8965bb208ef3de7dd5dd638e4c0e7e75a52bcda0effe8640e33f4a4bc6fbebdaf9431b358361bc7b15e2b1785884577c94d4bd802e2d0ba16fdd19c4da08fd56
+  data.tar.gz: bb0874200c64eb473b20dde0b0afe04db15ae0ab228b3dbec460e5b93fbef69fa708786700c6c7c301795ddb22267cf8312307eeab4903ed7e7823bd4e1dfb13

data/lib/api.rb

@@ -14,22 +14,32 @@
   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
@@ -41,6 +51,8 @@ module Api
   # 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)
@@ -51,6 +63,8 @@ module Api
   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
@@ -59,21 +73,27 @@ module Api
   # 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: update with more info
-  # # get_raw_transaction_info - Checks signed_transaction raw information.
-  # # - @param [String] signed_transaction - The hex encoded signed transaction.
-  # def get_raw_transaction_info(signed_transaction)
-  #   result = @rpc.request("getRawTransactionInfo", signed_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
@@ -81,6 +101,8 @@ module Api
 
   # 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
@@ -89,6 +111,8 @@ module Api
   # 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)
@@ -101,6 +125,8 @@ module Api
   # 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)
@@ -113,14 +139,18 @@ module Api
   # 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] dada_field (optional) - Hex-encoded value for the extra data field. This overrides the address provided during startup or from the pool.
-  def get_block_template(address = nil, dada_field = nil)
+  # - @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
@@ -128,29 +158,37 @@ module Api
 
   # 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 [Integer] block_hash - Hash of the block containing the transaction.
+  # - @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_height - Height of the block containing the transaction.
+  # - @param [Integer] block_hash_index - Height of the block containing the transaction.
   # - @param [Integer] transaction_index - Index of the transaction in the block.
-  def get_transaction_by_block_number_and_index(block_height, transaction_index)
-    result = @rpc.request("getTransactionByBlockNumberAndIndex", block_height, transaction_index)
+  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
@@ -159,6 +197,8 @@ module Api
   # 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
@@ -167,6 +207,8 @@ module Api
   # 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)
@@ -178,13 +220,17 @@ module Api
 
   # 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] dada_field (optional) - Hex-encoded value for the extra data field. This overrides the address provided during startup or from the pool.
-  def get_work(address = nil, dada_field = nil)
-    result = @rpc.request("getWork", address, dada_field)
+  # - @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
@@ -193,24 +239,32 @@ module Api
   # 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.
-  def mempool_content
+  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
@@ -218,6 +272,8 @@ module Api
 
   # 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)
@@ -229,6 +285,8 @@ module Api
 
   # 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)
@@ -239,18 +297,24 @@ module Api
   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
@@ -258,6 +322,8 @@ module Api
 
   # 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
@@ -266,9 +332,11 @@ module Api
   # 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.
-  def pool(pool_address = nil)
-    if pool_address
-      result = @rpc.request("pool", pool_address)
+  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
@@ -276,12 +344,16 @@ module Api
   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
@@ -289,6 +361,8 @@ module Api
 
   # 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
@@ -296,6 +370,8 @@ module Api
 
   # 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
@@ -304,12 +380,16 @@ module Api
   # 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

data/lib/nimiq/version.rb

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

data/lib/types.rb

@@ -0,0 +1,110 @@
+require "sorbet-runtime"
+
+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

@@ -16,20 +16,24 @@
 
 $LOAD_PATH.unshift File.expand_path("../lib", __dir__)
 require "ruby-client"
-# require "minitest/autorun"
 
 describe "Nimiq", type: :request do
 
   # Initialize
   before(:all) do
     options = {
+      #   host: "https://rpc.nimiq.observer/",
+      #   port: 433,
+
       host: "localhost",
       port: 8005,
       user: "user",
       pass: "pass",
     # dev: true,
     }
-    @signed_transaction = "010000...abcdef"
+    @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
 
@@ -52,7 +56,7 @@ describe "Nimiq", type: :request do
     end
   end
 
-  # Test suite for api
+  # Test suite for API
   describe "Api" do
 
     # Test suite for client to retrieve the addresses owned by client.
@@ -86,32 +90,14 @@ describe "Nimiq", type: :request do
       expect(@nimiq.create_account()).to be_a_kind_of(Object)
     end
 
-    # 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": "NQ94 VESA PKTA 9YQ0 XKGC HVH0 Q9DF VSFU STSP",
-        "to": "NQ16 61ET MB3M 2JG6 TBLK BR0D B6EA X6XQ L91U",
-        "value": 100000,
-        "fee": 0,
-      }
-      expect(@nimiq.create_raw_transaction(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
-    #   # signed_transaction = "010000...abcdef"
-    #   expect(@nimiq.get_raw_transaction_info(@signed_transaction)).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("NQ30 JLD6 U347 DFVU 40J3 F93V 9TCF YMMX RKY3")).to be_a_kind_of(Object)
+      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("NQ30 JLD6 U347 DFVU 40J3 F93V 9TCF YMMX RKY3")).to be_a_kind_of(Numeric)
+      expect(@nimiq.get_balance(@main_addr)).to be_a_kind_of(Integer)
     end
 
     # Test suite for client to retrieve block by hash.
@@ -141,12 +127,12 @@ describe "Nimiq", type: :request do
 
     # 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(Numeric)
+      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(Numeric)
+      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.
@@ -161,7 +147,7 @@ describe "Nimiq", type: :request do
 
     # 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("9eb228482138a8e64c5bb60608979904aa2be5721c115a9e3db54a0c481bb398")).to be_a_kind_of(Object)
+      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.
@@ -181,7 +167,7 @@ describe "Nimiq", type: :request do
 
     # 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(Numeric)
+      expect(@nimiq.hashrate()).to be_a_kind_of(Integer)
     end
 
     # Test suite for client to set the log level of the node.
@@ -206,22 +192,22 @@ describe "Nimiq", type: :request do
 
     # 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(Numeric)
+      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(Numeric)
+      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(Numeric)
+      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(Numeric)
+      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.
@@ -231,7 +217,7 @@ describe "Nimiq", type: :request do
 
     # 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(Numeric)
+      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.
@@ -246,50 +232,73 @@ describe "Nimiq", type: :request do
 
     # 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)
+      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)
+      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(Numeric)
+      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(Numeric)
+      expect(@nimiq.pool_connection_state()).to be_a_kind_of(Integer)
     end
 
-    # 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
-      # signed_transaction = "010000...abcdef"
-      expect(@nimiq.send_raw_transaction(@signed_transaction)).to be_a_kind_of(Object)
-    end
-
-    # 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
+    # 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": "NQ94 VESA PKTA 9YQ0 XKGC HVH0 Q9DF VSFU STSP",
-        "to": "NQ16 61ET MB3M 2JG6 TBLK BR0D B6EA X6XQ L91U",
-        "value": 100000,
+        "from": @main_addr,
+        "to": @seco_addr,
+        "value": 100,
         "fee": 0,
       }
-      expect(@nimiq.send_transaction(transaction)).to be_a_kind_of(Object)
+      @signed_transaction = @nimiq.create_raw_transaction(transaction)
+      expect(@signed_transaction).to be_a_kind_of(Object)
     end
 
-    # Test suite for client to submit a block to the node.
-    it "Must be able to submit a block to the node." do
-      block = "00000000"
-      expect(@nimiq.submit_block(block)).to be_a_kind_of(Numeric)
+    # 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()).to be(true).or be(false)
+      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

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-client
 version: !ruby/object:Gem::Version
-  version: 1.2.1
+  version: 1.2.2
 platform: ruby
 authors:
 - jxdv
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-07-20 00:00:00.000000000 Z
+date: 2020-08-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: oj
@@ -37,6 +37,7 @@ files:
 - lib/nimiq/version.rb
 - lib/rpc.rb
 - lib/ruby-client.rb
+- lib/types.rb
 - spec/client_spec.rb
 homepage: https://github.com/jxdv/ruby-client
 licenses: