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

#account ⇒ Nanook::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_work ⇒ Boolean

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

    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

#generate_work ⇒ String

Generate work for a block.

Example:

block.generate_work # => "2bf29ef00786a6bc"

Returns:

  • (String) —

    the work id of the work completed.



75
76
77
 
# File 'lib/nanook/block.rb', line 75

def generate_work
  rpc(:work_generate, :hash)[: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) —

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



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

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

#id ⇒ String

Returns the block hash id.

Example:

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

Returns:

  • (String) —

    the block hash id



110
111
112
 
# File 'lib/nanook/block.rb', line 110

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

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



135
136
137
138
139
140
141
142
143
144
145
146
 
# File 'lib/nanook/block.rb', line 135

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

#inspect ⇒ Object 



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

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



154
155
156
157
 
# File 'lib/nanook/block.rb', line 154

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.



190
191
192
193
 
# File 'lib/nanook/block.rb', line 190

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

#publish ⇒ String 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.



204
205
206
 
# File 'lib/nanook/block.rb', line 204

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



171
172
173
174
175
176
177
178
179
180
181
182
183
 
# File 'lib/nanook/block.rb', line 171

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

    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



225
226
227
228
 
# File 'lib/nanook/block.rb', line 225

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