Class: Nanook::Node

Inherits:
Object
  • Object
show all
Defined in:
lib/nanook/node.rb

Overview

The Nanook::Node class contains methods to manage your nano node and query its data of the nano network.

Your node is constantly syncing data with other nodes on the network. When your node first starts up after being built, its database will be empty and it will begin synchronizing and downloading data of the nano ledger to its local database. The ledger is the central record of all accounts and transactions. Some of the methods in this class query your node's database formed from the nano ledger, and so the responses are determined by the completeness of your node's database.

You can determine how synchronized your node is with the nano ledger with the #sync_progress method.

Initializing

Initialize this class through the convenient #node method:

node = Nanook.new.node

Or compose the longhand way like this:

rpc_conn = Nanook::Rpc.new
node = Nanook::Node.new(rpc_conn)

Instance Method Summary collapse

Constructor Details

#initialize(rpc) ⇒ Node

Returns a new instance of Node.



29
30
31
 
# File 'lib/nanook/node.rb', line 29

def initialize(rpc)
  @rpc = rpc
end

Instance Method Details

#account_count ⇒ Integer Also known as: frontier_count

The number of accounts in the nano ledger–essentially all accounts with open blocks. An open block is the type of block written to the nano ledger when an account receives its first payment (see WalletAccount#receive). All accounts that respond true to Account#exists? have open blocks in the ledger.

Returns:

  • (Integer) —

    number of accounts with open blocks.



40
41
42
 
# File 'lib/nanook/node.rb', line 40

def 
  rpc(:frontier_count)[:count]
end

#block_count ⇒ Hash{Symbol=>Integer}

The count of all blocks downloaded to the node, and blocks still to be synchronized by the node.

Example:

Returns:

  • (Hash{Symbol=>Integer}) —

    number of blocks and unchecked synchronizing blocks



54
55
56
 
# File 'lib/nanook/node.rb', line 54

def block_count
  rpc(:block_count)
end

#block_count_by_type ⇒ Hash{Symbol=>Integer} Also known as: block_count_type

The count of all known blocks by their type.

Example:

node.block_count_by_type

Example response:

{
  send: 1000,
  receive: 900,
  open: 900,
  change: 50
}

Returns:

  • (Hash{Symbol=>Integer}) —

    number of blocks by type



74
75
76
 
# File 'lib/nanook/node.rb', line 74

def block_count_by_type
  rpc(:block_count_type)
end

#bootstrap(address:, port:) ⇒ Boolean

Initialize bootstrap to a specific IP address and port.

Returns:

  • (Boolean) —

    indicating if the action was successful



82
83
84
 
# File 'lib/nanook/node.rb', line 82

def bootstrap(address:, port:)
  rpc(:bootstrap, address: address, port: port).has_key?(:success)
end

#bootstrap_any ⇒ Boolean

Initialize multi-connection bootstrap to random peers

Returns:

  • (Boolean) —

    indicating if the action was successful



89
90
91
 
# File 'lib/nanook/node.rb', line 89

def bootstrap_any
  rpc(:bootstrap_any).has_key?(:success)
end

#bootstrap_lazy(hash, force: false) ⇒ Boolean

Initialize lazy bootstrap with given block hash

Parameters:

  • hash (String)
  • force (Boolean) (defaults to: false) —

    False by default. Manually force closing of all current bootstraps

Returns:

  • (Boolean) —

    indicating if the action was successful



99
100
101
 
# File 'lib/nanook/node.rb', line 99

def bootstrap_lazy(hash, force: false)
  rpc(:bootstrap_lazy, hash: hash, force: force)[:started] == 1
end

#bootstrap_status ⇒ Hash{Symbol=>String|Integer|Boolean}

Returning status of current bootstrap attempt for debug purposes only. This call is for internal diagnostics/debug purposes only. Do not rely on this interface being stable and do not use in a production system.

Example:

node.bootstrap_status

Example response:

{
  clients: 5790,
  pulls: 141065,
  pulling: 3,
  connections: 16,
  idle: 0,
  target_connections: 64,
  total_blocks: 536820,
  lazy_mode: true,
  lazy_blocks: 423388,
  lazy_state_unknown: 2,
  lazy_balances: 0,
  lazy_pulls: 0,
  lazy_stopped: 644,
  lazy_keys: 449,
  lazy_key_1: "A86EB2B479AAF3CD531C8356A1FBE3CB500DFBF5BF292E5E6B8D1048DE199C32"
}

Returns:

  • (Hash{Symbol=>String|Integer|Boolean}) 


133
134
135
 
# File 'lib/nanook/node.rb', line 133

def bootstrap_status
  rpc(:bootstrap_status)
end

#confirmation_history ⇒ Hash{Symbol=>String|Integer}

This call is for internal diagnostics/debug purposes only. Do not rely on this interface being stable and do not use in a production system.

Returns block and tally weight (in raw) election duration (in milliseconds), election confirmation timestamp for recent elections winners.

Example:

node.confirmation_history

Example response:

[
  {
    block: "EA70B32C55C193345D625F766EEA2FCA52D3F2CCE0B3A30838CC543026BB0FEA",
    tally: 80394786589602980996311817874549318248,
    duration: 4000,
    time: 1544819986,
  },
  {
    block: "F2F8DA6D2CA0A4D78EB043A7A29E12BDE5B4CE7DE1B99A93A5210428EE5B8667",
    tally: 68921714529890443063672782079965877749,
    duration: 6000,
    time: 1544819988,
  }
]

Returns:

  • (Hash{Symbol=>String|Integer}) 


167
168
169
170
171
172
173
 
# File 'lib/nanook/node.rb', line 167

def confirmation_history
  rpc(:confirmation_history)[:confirmations].map do |history|
    # Rename hash key to block
    block = history.delete(:hash)
    {block: block}.merge(history)
  end
end

#difficulty(include_trend: false) ⇒ Hash{Symbol=>String|Float|Array}

Returns the difficulty values (16 hexadecimal digits string, 64 bit) for the minimum required on the network (network_minimum) as well as the current active difficulty seen on the network (network_current, 5 minute trended average of adjusted difficulty seen on confirmed transactions) which can be used to perform rework for better prioritization of transaction processing. A multiplier of the network_current from the base difficulty of network_minimum is also provided for comparison.

Example:

node.difficulty(include_trend: true)

Example response:

{
  network_minimum: "ffffffc000000000",
  network_current: "ffffffc1816766f2",
  multiplier: 1.024089858417128,
  difficulty_trend: [
    1.156096135149775,
    1.190133894573061,
    1.135567138563921,
    1.000000000000000,
  ]
}

Parameters:

  • include_trend (Boolean) (defaults to: false) —

    false by default. Also returns the trend of difficulty seen on the network as a list of multipliers. Sampling occurs every 16 to 36 seconds. The list is ordered such that the first value is the most recent sample.

Returns:

  • (Hash{Symbol=>String|Float|Array}) 


207
208
209
210
211
212
213
214
215
 
# File 'lib/nanook/node.rb', line 207

def difficulty(include_trend: false)
  rpc(:active_difficulty, include_trend: include_trend).tap do |response|
    response[:multiplier] = response[:multiplier].to_f

    if response.key?(:difficulty_trend)
      response[:difficulty_trend].map!(&:to_f)
    end
  end
end

#inspect ⇒ String

Returns:

  • (String) 


218
219
220
 
# File 'lib/nanook/node.rb', line 218

def inspect
  "#{self.class.name}(object_id: \"#{"0x00%x" % (object_id << 1)}\")"
end

#peers ⇒ Object 



222
223
224
 
# File 'lib/nanook/node.rb', line 222

def peers
  rpc(:peers)[:peers]
end

#representatives(unit: Nanook.default_unit) ⇒ Hash{Symbol=>Integer}

All representatives and their voting weight.

Example:

node.representatives

Example response:

{
  nano_1111111111111111111111111111111111111111111111111117353trpda: 3822372327060170000000000000000000000,
  nano_1111111111111111111111111111111111111111111111111awsq94gtecn: 30999999999999999999999999000000,
  nano_114nk4rwjctu6n6tr6g6ps61g1w3hdpjxfas4xj1tq6i8jyomc5d858xr1xi: 0
}

Returns:

  • (Hash{Symbol=>Integer}) —

    known representatives and their voting weight



241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
 
# File 'lib/nanook/node.rb', line 241

def representatives(unit: Nanook.default_unit)
  unless Nanook::UNITS.include?(unit)
    raise ArgumentError.new("Unsupported unit: #{unit}")
  end

  response = rpc(:representatives)[:representatives]
  return response if unit == :raw

  r = response.map do |, balance|
    balance = Nanook::Util.raw_to_NANO(balance)

    [, balance]
  end

  Hash[r].to_symbolized_hash
end

#representatives_online ⇒ Array<String>

All online representatives that have voted recently. Note, due to the design of the nano RPC, this method cannot return the voting weight of the representatives.

Example:

node.representatives_online # => ["nano_111...", "nano_222"]

Returns:

  • (Array<String>) —

    array of representative account ids



267
268
269
 
# File 'lib/nanook/node.rb', line 267

def representatives_online
  rpc(:representatives_online)[:representatives].keys.map(&:to_s)
end

#stop ⇒ Boolean

Safely shuts down the node.

Returns:

  • (Boolean) —

    indicating if action was successful



274
275
276
 
# File 'lib/nanook/node.rb', line 274

def stop
  rpc(:stop).has_key?(:success)
end

#sync_progress ⇒ Float

The percentage completeness of the synchronization process for your node as it downloads the nano ledger. Note, it's normal for your progress to not ever reach 100. The closer to 100, the more complete your node's data is, and so the query methods in this class become more reliable.

Returns:

  • (Float) —

    the percentage completeness of the synchronization process for your node



297
298
299
300
301
302
303
304
305
 
# File 'lib/nanook/node.rb', line 297

def sync_progress
  response = rpc(:block_count)

  count = response[:count]
  unchecked = response[:unchecked]
  total =  count + unchecked

  count.to_f * 100 / total.to_f
end

#synced? ⇒ Boolean

This method is deprecated and will be removed in 3.0, as a node never reaches 100% synchronization.

Returns:

  • (Boolean) —

    signalling if this node ever reaches 100% synchronized



318
319
320
321
 
# File 'lib/nanook/node.rb', line 318

def synced?
  warn "[DEPRECATION] `synced?` is deprecated and will be removed in 3.0"
  rpc(:block_count)[:unchecked] == 0
end

#synchronizing_blocks(limit: 1000) ⇒ Hash{Symbol=>String} Also known as: unchecked

Returns information about the synchronizing blocks for this node.

Parameters:

  • limit (Integer) (defaults to: 1000) —

    number of synchronizing blocks to return

Returns:

  • (Hash{Symbol=>String}) —

    information about the synchronizing blocks for this node



280
281
282
283
284
285
286
 
# File 'lib/nanook/node.rb', line 280

def synchronizing_blocks(limit: 1000)
  response = rpc(:unchecked, count: limit)[:blocks]
  response = response.map do |block, info|
    [block, JSON.parse(info).to_symbolized_hash]
  end
  Hash[response.sort].to_symbolized_hash
end

#uptime ⇒ Integer

Returns node uptime in seconds

Returns:

  • (Integer) —

    seconds of uptime



310
311
312
 
# File 'lib/nanook/node.rb', line 310

def uptime
  rpc(:uptime)['seconds']
end

#version ⇒ Hash{Symbol=>Integer|String} Also known as: info

Returns version information for this node.

Returns:

  • (Hash{Symbol=>Integer|String}) —

    version information for this node



324
325
326
 
# File 'lib/nanook/node.rb', line 324

def version
  rpc(:version)
end