ruby-client 1.1.5 → 1.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d72ff7046a39a0d60c6c9df7ac3ef3601b39c59d1a1c4f4ff6294f0bb4501fa3
-  data.tar.gz: d48f8b55d873cc6ef82e6a7ec0e01265468c5dd5016bafb11b81aed227e2fa2c
+  metadata.gz: 4a137cb7c34ec19c512aeba486576004f912971dc22a7ccbba363c20f2151bb7
+  data.tar.gz: 3852d552b5fb140c2c09f54367b6ff0b971e39760da206ea5c2a5c1498ef3fcd
 SHA512:
-  metadata.gz: ac27c100095e7535901bf1e404d9ce36da359cf8586617cf88a4bba6ed1a38718a7d60020593adbe490385b072228f1acb07e2797a40df1b9188e3ce66c6eb7a
-  data.tar.gz: 7936c9d61636c3d9e2c0a68c08c32e747dc2317456f61f0fcafe71c90433ab18e263cf997167dbbb0a06f21dde10814eaaeabf53598bfaddb659c9d73c139cdf
+  metadata.gz: 5afd35c9c9955d3900fb07f938c6e6301220175f11743ea1d9929f5a81f424372319e8a5f8d47ca1c30510ef6cb37b195e29a230467476fbd316f98008d81e54
+  data.tar.gz: 43b2d1cf3f0523b4a975edfe486df8786e1fb8497dab245a008f8adbf381cff24e0c2981e960f7713d379c3f0561c49dc37c058f5dbff80d294fae267d1d5df9

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.1.5"
+  VERSION = "1.2.3"
 end

data/lib/{rpcclient.rb → rpc.rb}

@@ -20,7 +20,7 @@ require "net/http"
 # :nodoc: all
 module ClientRPC
   class Connect
-    attr_accessor :options, :uri
+    attr_accessor :options, :uri, :ssl
 
     DEFAULTS = {
       host: "localhost",
@@ -54,6 +54,7 @@ module ClientRPC
       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)
@@ -68,6 +69,7 @@ module ClientRPC
       user = uri.user
       pass = uri.password
       http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = true if @ssl
       request = Net::HTTP::Post.new(uri.request_uri)
       request.basic_auth(user, pass)
       request.body = request_body(name, params)
@@ -89,6 +91,7 @@ module ClientRPC
         host = options[:host]
         newhost = url_strip(host.dup)
         if (options[:host].include? "https")
+          @ssl = true
           return "https://#{options[:user]}:#{options[:pass]}@#{newhost}:#{options[:port]}"
         else
           return "http://#{options[:user]}:#{options[:pass]}@#{newhost}:#{options[:port]}"

data/lib/ruby-client.rb

@@ -15,7 +15,7 @@
 =end
 
 require_relative "nimiq/version"
-require_relative "rpcclient"
+require_relative "rpc"
 require_relative "api"
 require "json"
 

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