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

#inspect ⇒ String

Returns:

  • (String) 


94
95
96
 
# File 'lib/nanook/node.rb', line 94

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

#peers ⇒ Object 



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

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:

{
  xrb_1111111111111111111111111111111111111111111111111117353trpda: 3822372327060170000000000000000000000,
  xrb_1111111111111111111111111111111111111111111111111awsq94gtecn: 30999999999999999999999999000000,
  xrb_114nk4rwjctu6n6tr6g6ps61g1w3hdpjxfas4xj1tq6i8jyomc5d858xr1xi: 0
}

Returns:

  • (Hash{Symbol=>Integer}) —

    known representatives and their voting weight



117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
 
# File 'lib/nanook/node.rb', line 117

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 # => ["xrb_111...", "xrb_222"]

Returns:

  • (Array<String>) —

    array of representative account ids



143
144
145
 
# File 'lib/nanook/node.rb', line 143

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

#stop ⇒ Boolean

Safely shuts down the node.

Returns:

  • (Boolean) —

    indicating if action was successful



150
151
152
 
# File 'lib/nanook/node.rb', line 150

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



173
174
175
176
177
178
179
180
181
 
# File 'lib/nanook/node.rb', line 173

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



187
188
189
190
 
# File 'lib/nanook/node.rb', line 187

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) —

    number of synchronizing blocks to return

Returns:

  • (Hash{Symbol=>String}) —

    information about the synchronizing blocks for this node



156
157
158
159
160
161
162
 
# File 'lib/nanook/node.rb', line 156

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

#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



193
194
195
 
# File 'lib/nanook/node.rb', line 193

def version
  rpc(:version)
end