Class: Nanook::Block

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

Overview

The Nanook::Block class contains methods to discover publicly-available information about blocks on the nano network.

A block is represented by a unique id like this:

"FBF8B0E6623A31AB528EBD839EEAA91CAFD25C12294C46754E45FD017F7939EB"

Initialize this class through the convenient Nanook#block method:

nanook = Nanook.new
block = nanook.block("FBF8B0E...")

Or compose the longhand way like this:

rpc_conn = Nanook::Rpc.new
block = Nanook::Block.new(rpc_conn, "FBF8B0E...")

Instance Method Summary collapse

Constructor Details

#initialize(rpc, block) ⇒ Block

Returns a new instance of Block.


21
22
23
24
25
# File 'lib/nanook/block.rb', line 21

def initialize(rpc, block)
  @rpc = rpc
  @block = block
  block_required! # All methods expect a block
end

Instance Method Details

#accountNanook::Account

Returns the Account of the block.

Example:

block. # => Nanook::Account

Returns:


33
34
35
# File 'lib/nanook/block.rb', line 33

def 
  Nanook::Account.new(@rpc, rpc(:block_account, :hash)[:account])
end

#cancel_workBoolean

Stop generating work for a block.

Example:

block.cancel_work # => true

Returns:

  • (Boolean)

    signalling if the action was successful


44
45
46
# File 'lib/nanook/block.rb', line 44

def cancel_work
  rpc(:work_cancel, :hash).empty?
end

#chain(limit: 1000) ⇒ Object

Returns an Array of block hashes in the account chain starting at this block.

See also #successors.

Example:

block.chain(limit: 2)

Example reponse:

[
  "36A0FB717368BA8CF8D255B63DC207771EABC6C6FFC22A7F455EC2209464897E",
  "FBF8B0E6623A31AB528EBD839EEAA91CAFD25C12294C46754E45FD017F7939EB"
]

Parameters:

  • limit (Integer) (defaults to: 1000)

    maximum number of block hashes to return (default is 1000)


64
65
66
67
# File 'lib/nanook/block.rb', line 64

def chain(limit: 1000)
  response = rpc(:chain, :block, count: limit)[:blocks]
  Nanook::Util.coerce_empty_string_to_type(response, Array)
end

#confirmBoolean

Request confirmation for a block from online representative nodes. Will return immediately with a boolean to indicate if the request for confirmation was successful. Note that this boolean does not indicate the confirmation status of the block. If confirmed, your block should appear in Node#confirmation_history within a short amount of time, or you can use the convenience method #confirmed_recently?

Example:

block.confirm # => true

Returns:

  • (Boolean)

    if the confirmation request was sent successful


80
81
82
# File 'lib/nanook/block.rb', line 80

def confirm
  rpc(:block_confirm, :hash)[:started] == 1
end

#confirmed_recently?Boolean Also known as: recently_confirmed?

Check if the block appears in the list of recently confirmed blocks by online representatives. The full list of blocks can be queried for with Node#confirmation_history.

This method can work in conjunction with #confirm, whereby you can send any block (old or new) out to online representatives to confirm. The confirmation process can take up to a couple of minutes.

The method returning false can indicate that the block is still in the process of being confirmed and that you should call the method again soon, or that it was confirmed earlier than the list available in Node#confirmation_history, or that it was not confirmed.

Example:

block.confirmed_recently? # => true

Returns:

  • (Boolean)

    true if the block has been recently confirmed by online representatives.


101
102
103
# File 'lib/nanook/block.rb', line 101

def confirmed_recently?
  @rpc.call(:confirmation_history)[:confirmations].map{|h| h[:hash]}.include?(@block)
end

#generate_work(use_peers: false) ⇒ String

Generate work for a block.

Example:

block.generate_work # => "2bf29ef00786a6bc"

Parameters:

  • use_peers (Boolean) (defaults to: false)

    if set to true, then the node will query its work peers (if it has any, see WorkPeer#list). When false, the node will only generate work locally (default is false)

Returns:

  • (String)

    the work id of the work completed.


115
116
117
# File 'lib/nanook/block.rb', line 115

def generate_work(use_peers: false)
  rpc(:work_generate, :hash, use_peers: use_peers)[:work]
end

#history(limit: 1000) ⇒ Object

Returns Array of Hashes containing information about a chain of send/receive blocks, starting from this block.

Example:

block.history(limit: 1)

Example response:

[
  {
    :account=>"xrb_3x7cjioqahgs5ppheys6prpqtb4rdknked83chf97bot1unrbdkaux37t31b",
    :amount=>539834279601145558517940224,
    :hash=>"36A0FB717368BA8CF8D255B63DC207771EABC6C6FFC22A7F455EC2209464897E",
    :type=>"send"
  }
]

Parameters:

  • limit (Integer) (defaults to: 1000)

    maximum number of send/receive block hashes to return in the chain (default is 1000)


139
140
141
# File 'lib/nanook/block.rb', line 139

def history(limit: 1000)
  rpc(:history, :hash, count: limit)[:history]
end

#idString

Returns the block hash id.

Example:

block.id #=> "FBF8B0E..."

Returns:

  • (String)

    the block hash id


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

def id
  @block
end

#info(allow_unchecked: false) ⇒ Object

Returns a Hash of information about the block.

Examples:

block.info
block.info(allow_unchecked: true)

Example response:

{
  :id=>"36A0FB717368BA8CF8D255B63DC207771EABC6C6FFC22A7F455EC2209464897E",
  :type=>"send",
  :previous=>"FBF8B0E6623A31AB528EBD839EEAA91CAFD25C12294C46754E45FD017F7939EB",
  :destination=>"xrb_3x7cjioqahgs5ppheys6prpqtb4rdknked83chf97bot1unrbdkaux37t31b",
  :balance=>"00000000000000000000000000000000",
  :work=>"44cc24b60705083a",
  :signature=>"42ADFEFE7C3FFF188AE92A202F8A5734DE91779C454613E446EEC93D001D6C953E9FD16730AF32C891791BA8EDAECEB059A213E2FE1EEB7ADF9D5D0815464D06"
}

Parameters:

  • allow_unchecked (Boolean) (defaults to: false)

    (default is false). If true, information can be returned about blocks that are unchecked (unverified).


175
176
177
178
179
180
181
182
183
184
185
186
# File 'lib/nanook/block.rb', line 175

def info(allow_unchecked: false)
  if allow_unchecked
    response = rpc(:unchecked_get, :hash)
    unless response.has_key?(:error)
      return _parse_info_response(response)
    end
    # If unchecked not found, continue to checked block
  end

  response = rpc(:block, :hash)
  _parse_info_response(response)
end

#inspectObject


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

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

#is_valid_work?(work) ⇒ Boolean

Example:

block.is_valid_work?("2bf29ef00786a6bc") # => true

Parameters:

  • work (String)

    the work id to check is valid

Returns:

  • (Boolean)

    signalling if work is valid for the block


194
195
196
197
# File 'lib/nanook/block.rb', line 194

def is_valid_work?(work)
  response = rpc(:work_validate, :hash, work: work)
  !response.empty? && response[:valid] == 1
end

#pending?Boolean

Example:

block.pending? #=> false

Returns:

  • (Boolean)

    signalling if the block is a pending block.


230
231
232
233
# File 'lib/nanook/block.rb', line 230

def pending?
  response = rpc(:pending_exists, :hash)
  !response.empty? && response[:exists] == 1
end

#publishString Also known as: process

Publish the block to the nano network.

Note, if block has previously been published, use #republish instead.

Examples:

block.publish # => "FBF8B0E..."

Returns:

  • (String)

    the block hash, or false.


244
245
246
# File 'lib/nanook/block.rb', line 244

def publish
  rpc(:process, :block)[:hash] || false
end

#republish(destinations: nil, sources: nil) ⇒ Array<String>

Republish blocks starting at this block up the account chain back to the nano network.

Example:

block.republish

Example response:

["36A0FB717368BA8CF8D255B63DC207771EABC6C6FFC22A7F455EC2209464897E"]

Returns:

  • (Array<String>)

    block hashes that were republished


211
212
213
214
215
216
217
218
219
220
221
222
223
# File 'lib/nanook/block.rb', line 211

def republish(destinations:nil, sources:nil)
  if !destinations.nil? && !sources.nil?
    raise ArgumentError.new("You must provide either destinations or sources but not both")
  end

  # Add in optional arguments
  params = {}
  params[:destinations] = destinations unless destinations.nil?
  params[:sources] = sources unless sources.nil?
  params[:count] = 1 unless params.empty?

  rpc(:republish, :hash, params)[:blocks]
end

#successors(limit: 1000) ⇒ Array<String>

Returns an Array of block hashes in the account chain ending at this block.

See also #chain.

Example:

block.successors

Example response:

["36A0FB717368BA8CF8D255B63DC207771EABC6C6FFC22A7F455EC2209464897E"]

Parameters:

  • limit (Integer) (defaults to: 1000)

    maximum number of send/receive block hashes to return in the chain (default is 1000)

Returns:

  • (Array<String>)

    block hashes in the account chain ending at this block


265
266
267
268
# File 'lib/nanook/block.rb', line 265

def successors(limit: 1000)
  response = rpc(:successors, :block, count: limit)[:blocks]
  Nanook::Util.coerce_empty_string_to_type(response, Array)
end