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).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).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
 
# 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

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

#inspect ⇒ String

Returns:

  • (String) 


216
217
218
 
# File 'lib/nanook/node.rb', line 216

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

#peers ⇒ Object 



220
221
222
 
# File 'lib/nanook/node.rb', line 220

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

Raises:

  • (ArgumentError) 


239
240
241
242
243
244
245
246
247
248
249
250
251
252
 
# File 'lib/nanook/node.rb', line 239

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

  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



263
264
265
 
# File 'lib/nanook/node.rb', line 263

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



270
271
272
 
# File 'lib/nanook/node.rb', line 270

def stop
  rpc(:stop).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



293
294
295
296
297
298
299
300
301
 
# File 'lib/nanook/node.rb', line 293

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



314
315
316
317
 
# File 'lib/nanook/node.rb', line 314

def synced?
  warn '[DEPRECATION] `synced?` is deprecated and will be removed in 3.0'
  (rpc(:block_count)[:unchecked]).zero?
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



276
277
278
279
280
281
282
 
# File 'lib/nanook/node.rb', line 276

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



306
307
308
 
# File 'lib/nanook/node.rb', line 306

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



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

def version
  rpc(:version)
end