cryptonote::HardFork Class Reference

#include <hardfork.h>

Classes
struct	Params

Public Types
enum	State { LikelyForked , UpdateNeeded , Ready }

Public Member Functions
	HardFork (cryptonote::BlockchainDB &db, uint8_t original_version=1, uint64_t original_version_till_height=DEFAULT_ORIGINAL_VERSION_TILL_HEIGHT, time_t forked_time=DEFAULT_FORKED_TIME, time_t update_time=DEFAULT_UPDATE_TIME, uint64_t window_size=DEFAULT_WINDOW_SIZE, uint8_t default_threshold_percent=DEFAULT_THRESHOLD_PERCENT)
	creates a new HardFork object
bool	add_fork (uint8_t version, uint64_t height, uint8_t threshold, time_t time)
	add a new hardfork height
bool	add_fork (uint8_t version, uint64_t height, time_t time)
	add a new hardfork height
void	init ()
	initialize the object
bool	check (const cryptonote::block &block) const
	check whether a new block would be accepted
bool	check_for_height (const cryptonote::block &block, uint64_t height) const
	same as check, but for a particular height, rather than the top
bool	add (const cryptonote::block &block, uint64_t height)
	add a new block
bool	reorganize_from_block_height (uint64_t height)
	called when the blockchain is reorganized
bool	reorganize_from_chain_height (uint64_t height)
void	on_block_popped (uint64_t new_chain_height)
	called when one or more blocks are popped from the blockchain
State	get_state (time_t t) const
	returns current state at the given time
State	get_state () const
uint8_t	get (uint64_t height) const
	returns the hard fork version for the given block height
uint8_t	get_ideal_version () const
	returns the latest "ideal" version
uint8_t	get_ideal_version (uint64_t height) const
	returns the "ideal" version for a given height
uint8_t	get_next_version () const
	returns the next version
uint8_t	get_current_version () const
	returns the current version
uint64_t	get_earliest_ideal_height_for_version (uint8_t version) const
	returns the earliest block a given version may activate
bool	get_voting_info (uint8_t version, uint32_t &window, uint32_t &votes, uint32_t &threshold, uint64_t &earliest_height, uint8_t &voting) const
	returns information about current voting state
uint64_t	get_window_size () const
	returns the size of the voting window in blocks

Static Public Attributes
static const uint64_t	DEFAULT_ORIGINAL_VERSION_TILL_HEIGHT = 0
static const time_t	DEFAULT_FORKED_TIME = 31557600
static const time_t	DEFAULT_UPDATE_TIME = 31557600 / 2
static const uint64_t	DEFAULT_WINDOW_SIZE = 10080
static const uint8_t	DEFAULT_THRESHOLD_PERCENT = 80

Detailed Description

Definition at line 39 of file hardfork.h.

Member Enumeration Documentation

State

enum cryptonote::HardFork::State

Enumerator
LikelyForked
UpdateNeeded
Ready

Definition at line 42 of file hardfork.h.

                 {
      LikelyForked,
      UpdateNeeded,
      Ready,
    } State;

Constructor & Destructor Documentation

HardFork()

HardFork::HardFork	(	cryptonote::BlockchainDB &	db,
		uint8_t	original_version = 1,
		uint64_t	original_version_till_height = DEFAULT_ORIGINAL_VERSION_TILL_HEIGHT,
		time_t	forked_time = DEFAULT_FORKED_TIME,
		time_t	update_time = DEFAULT_UPDATE_TIME,
		uint64_t	window_size = DEFAULT_WINDOW_SIZE,
		uint8_t	default_threshold_percent = DEFAULT_THRESHOLD_PERCENT )

creates a new HardFork object

Parameters

original_version	the block version for blocks 0 through to the first fork
forked_time	the time in seconds before thinking we're forked
update_time	the time in seconds before thinking we need to update
window_size	the size of the window in blocks to consider for version voting
default_threshold_percent	the size of the majority in percents

Definition at line 58 of file hardfork.cpp.

                                                                                                                                                                                                              :
  db(db),
  forked_time(forked_time),
  update_time(update_time),
  window_size(window_size),
  default_threshold_percent(default_threshold_percent),
  original_version(original_version),
  original_version_till_height(original_version_till_height),
  current_fork_index(0)
{
  if (window_size == 0)
    throw "window_size needs to be strictly positive";
  if (default_threshold_percent > 100)
    throw "default_threshold_percent needs to be between 0 and 100";
}

Member Function Documentation

add()

bool HardFork::add	(	const cryptonote::block &	block,
		uint64_t	height )

add a new block

returns true if no error, false otherwise

Parameters

block

the new block

Definition at line 164 of file hardfork.cpp.

{
  return add(::get_block_version(block), ::get_block_vote(block), height);
}

Here is the call graph for this function:

Here is the caller graph for this function:

add_fork() [1/2]

bool HardFork::add_fork	(	uint8_t	version,
		uint64_t	height,
		time_t	time )

add a new hardfork height

returns true if no error, false otherwise

Parameters

version	the major block version for the fork
height	The height the hardfork takes effect
time	Approximate time of the hardfork (seconds since epoch)

Definition at line 95 of file hardfork.cpp.

{
  return add_fork(version, height, default_threshold_percent, time);
}

Here is the call graph for this function:

add_fork() [2/2]

bool HardFork::add_fork	(	uint8_t	version,
		uint64_t	height,
		uint8_t	threshold,
		time_t	time )

add a new hardfork height

returns true if no error, false otherwise

Parameters

version	the major block version for the fork
height	The height the hardfork takes effect
threshold	The threshold of votes needed for this fork (0-100)
time	Approximate time of the hardfork (seconds since epoch)

Definition at line 74 of file hardfork.cpp.

{
  CRITICAL_REGION_LOCAL(lock);
 
  // add in order
  if (version == 0)
    return false;
  if (!heights.empty()) {
    if (version <= heights.back().version)
      return false;
    if (height <= heights.back().height)
      return false;
    if (time <= heights.back().time)
      return false;
  }
  if (threshold > 100)
    return false;
  heights.push_back(Params(version, height, threshold, time));
  return true;
}

Here is the caller graph for this function:

check()

bool HardFork::check

(

const cryptonote::block &

block

)

const

check whether a new block would be accepted

returns true if the block is accepted, false otherwise

Parameters

block

the new block

This check is made by add. It is exposed publicly to allow the caller to inexpensively check whether a block would be accepted or rejected by its version number. Indeed, if this check could only be done as part of add, the caller would either have to add the block to the blockchain first, then call add, then have to pop the block from the blockchain if its version did not satisfy the hard fork requirements, or call add first, then, if the hard fork requirements are met, add the block to the blockchain, upon which a failure (the block being invalid, double spending, etc) would cause the hardfork object to reorganize.

Definition at line 116 of file hardfork.cpp.

{
  CRITICAL_REGION_LOCAL(lock);
  return do_check(::get_block_version(block), ::get_block_vote(block));
}

check_for_height()

bool HardFork::check_for_height	(	const cryptonote::block &	block,
		uint64_t	height ) const

same as check, but for a particular height, rather than the top

NOTE: this does not play well with voting, and relies on voting to be disabled (that is, forks happen on the scheduled date, whether or not enough blocks have voted for the fork).

returns true if no error, false otherwise

Parameters

block	the new block
height	which height to check for

Definition at line 129 of file hardfork.cpp.

{
  CRITICAL_REGION_LOCAL(lock);
  return do_check_for_height(::get_block_version(block), ::get_block_vote(block), height);
}

Here is the caller graph for this function:

get()

uint8_t HardFork::get

(

uint64_t

height

)

const

returns the hard fork version for the given block height

Parameters

height

height of the block to check

Definition at line 348 of file hardfork.cpp.

{
  CRITICAL_REGION_LOCAL(lock);
  if (height > db.height()) {
    assert(false);
    return 255;
  }
  if (height == db.height()) {
    return get_current_version();
  }
  return db.get_hard_fork_version(height);
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_current_version()

uint8_t HardFork::get_current_version

(

)

const

returns the current version

This is the latest version that's past its trigger date and had enough votes at one point in the past.

Definition at line 361 of file hardfork.cpp.

{
  CRITICAL_REGION_LOCAL(lock);
  return heights[current_fork_index].version;
}

Here is the caller graph for this function:

get_earliest_ideal_height_for_version()

uint64_t HardFork::get_earliest_ideal_height_for_version

(

uint8_t

version

)

const

returns the earliest block a given version may activate

Definition at line 384 of file hardfork.cpp.

{
  uint64_t height = std::numeric_limits<uint64_t>::max();
  for (auto i = heights.rbegin(); i != heights.rend(); ++i) {
    if (i->version >= version) {
      height = i->height;
    } else {
      break;
    }
  }
  return height;
}

Here is the caller graph for this function:

get_ideal_version() [1/2]

uint8_t HardFork::get_ideal_version

(

)

const

returns the latest "ideal" version

This is the latest version that's been scheduled

Definition at line 367 of file hardfork.cpp.

{
  CRITICAL_REGION_LOCAL(lock);
  return heights.back().version;
}

Here is the caller graph for this function:

get_ideal_version() [2/2]

uint8_t HardFork::get_ideal_version

(

uint64_t

height

)

const

returns the "ideal" version for a given height

Parameters

height

height of the block to check

Definition at line 373 of file hardfork.cpp.

{
  CRITICAL_REGION_LOCAL(lock);
  for (unsigned int n = heights.size() - 1; n > 0; --n) {
    if (height >= heights[n].height) {
      return heights[n].version;
    }
  }
  return original_version;
}

get_next_version()

uint8_t HardFork::get_next_version

(

)

const

returns the next version

This is the version which will we fork to next

Definition at line 397 of file hardfork.cpp.

{
  CRITICAL_REGION_LOCAL(lock);
  uint64_t height = db.height();
  for (auto i = heights.rbegin(); i != heights.rend(); ++i) {
    if (height >= i->height) {
      return (i == heights.rbegin() ? i : (i - 1))->version;
    }
  }
  return original_version;
}

Here is the caller graph for this function:

get_state() [1/2]

HardFork::State HardFork::get_state

(

)

const

Definition at line 343 of file hardfork.cpp.

{
  return get_state(time(NULL));
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_state() [2/2]

HardFork::State HardFork::get_state

(

time_t

t

)

const

returns current state at the given time

Based on the approximate time of the last known hard fork, estimate whether we need to update, or if we're way behind

Parameters

t	the time to consider

Definition at line 327 of file hardfork.cpp.

{
  CRITICAL_REGION_LOCAL(lock);
 
  // no hard forks setup yet
  if (heights.size() <= 1)
    return Ready;
 
  time_t t_last_fork = heights.back().time;
  if (t >= t_last_fork + forked_time)
    return LikelyForked;
  if (t >= t_last_fork + update_time)
    return UpdateNeeded;
  return Ready;
}

Here is the caller graph for this function:

get_voting_info()

bool HardFork::get_voting_info	(	uint8_t	version,
		uint32_t &	window,
		uint32_t &	votes,
		uint32_t &	threshold,
		uint64_t &	earliest_height,
		uint8_t &	voting ) const

returns information about current voting state

returns true if the given version is enabled (ie, the current version is at least the passed version), false otherwise

Parameters

version	the version to check voting for
window	the number of blocks considered in voting
votes	number of votes for next version
threshold	number of votes needed to switch to next version
earliest_height	earliest height at which the version can take effect

Definition at line 409 of file hardfork.cpp.

{
  CRITICAL_REGION_LOCAL(lock);
 
  const uint8_t current_version = heights[current_fork_index].version;
  const bool enabled = current_version >= version;
  window = versions.size();
  votes = 0;
  for (size_t n = version; n < 256; ++n)
      votes += last_versions[n];
  threshold = (window * heights[current_fork_index].threshold + 99) / 100;
  //assert((votes >= threshold) == enabled);
  earliest_height = get_earliest_ideal_height_for_version(version);
  voting = heights.back().version;
  return enabled;
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_window_size()

uint64_t cryptonote::HardFork::get_window_size ( ) const

inline

returns the size of the voting window in blocks

Definition at line 232 of file hardfork.h.

{ return window_size; }

init()

void HardFork::init

(

)

initialize the object

Must be done after adding all the required hardforks via add above

Definition at line 169 of file hardfork.cpp.

{
  CRITICAL_REGION_LOCAL(lock);
 
  // add a placeholder for the default version, to avoid special cases
  if (heights.empty())
    heights.push_back(Params(original_version, 0, 0, 0));
 
  versions.clear();
  for (size_t n = 0; n < 256; ++n)
    last_versions[n] = 0;
  current_fork_index = 0;
 
  // restore state from DB
  uint64_t height = db.height();
  if (height > window_size)
    height -= window_size - 1;
  else
    height = 1;
 
  rescan_from_chain_height(height);
  MDEBUG("init done");
}

Here is the caller graph for this function:

on_block_popped()

void HardFork::on_block_popped

(

uint64_t

new_chain_height

)

called when one or more blocks are popped from the blockchain

The current fork will be updated by looking up the db, which is much cheaper than recomputing everything

Parameters

new_chain_height

the height of the chain after popping

Definition at line 287 of file hardfork.cpp.

{
  CHECK_AND_ASSERT_THROW_MES(nblocks > 0, "nblocks must be greater than 0");
 
  CRITICAL_REGION_LOCAL(lock);
 
  const uint64_t new_chain_height = db.height();
  const uint64_t old_chain_height = new_chain_height + nblocks;
  uint8_t version;
  for (uint64_t height = old_chain_height - 1; height >= new_chain_height; --height)
  {
    version = versions.back();
    last_versions[version]--;
    versions.pop_back();
    version = db.get_hard_fork_version(height);
    versions.push_front(version);
    last_versions[version]++;
  }
 
  // does not take voting into account
  for (current_fork_index = heights.size() - 1; current_fork_index > 0; --current_fork_index)
    if (new_chain_height >= heights[current_fork_index].height)
      break;
}

reorganize_from_block_height()

bool HardFork::reorganize_from_block_height

(

uint64_t

height

)

called when the blockchain is reorganized

This will rescan the blockchain to determine which hard forks have been triggered

returns true if no error, false otherwise

Parameters

blockchain	the blockchain
height	of the last block kept from the previous blockchain

Definition at line 202 of file hardfork.cpp.

{
  CRITICAL_REGION_LOCAL(lock);
  if (height >= db.height())
    return false;
 
  bool stop_batch = db.batch_start();
 
  versions.clear();
 
  for (size_t n = 0; n < 256; ++n)
    last_versions[n] = 0;
  const uint64_t rescan_height = height >= (window_size - 1) ? height - (window_size  -1) : 0;
  const uint8_t start_version = height == 0 ? original_version : db.get_hard_fork_version(height);
  while (current_fork_index > 0 && heights[current_fork_index].version > start_version) {
    --current_fork_index;
  }
  for (uint64_t h = rescan_height; h <= height; ++h) {
    cryptonote::block b = db.get_block_from_height(h);
    const uint8_t v = get_effective_version(get_block_vote(b));
    last_versions[v]++;
    versions.push_back(v);
  }
 
  uint8_t voted = get_voted_fork_index(height + 1);
  if (voted > current_fork_index) {
    current_fork_index = voted;
  }
 
  const uint64_t bc_height = db.height();
  for (uint64_t h = height + 1; h < bc_height; ++h) {
    add(db.get_block_from_height(h), h);
  }
 
  if (stop_batch)
    db.batch_stop();
 
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

reorganize_from_chain_height()

bool HardFork::reorganize_from_chain_height

(

uint64_t

height

)

Definition at line 242 of file hardfork.cpp.

{
  if (height == 0)
    return false;
  return reorganize_from_block_height(height - 1);
}

Here is the call graph for this function:

Member Data Documentation

DEFAULT_FORKED_TIME

const time_t cryptonote::HardFork::DEFAULT_FORKED_TIME = 31557600

static

Definition at line 49 of file hardfork.h.

DEFAULT_ORIGINAL_VERSION_TILL_HEIGHT

const uint64_t cryptonote::HardFork::DEFAULT_ORIGINAL_VERSION_TILL_HEIGHT = 0

static

Definition at line 48 of file hardfork.h.

DEFAULT_THRESHOLD_PERCENT

const uint8_t cryptonote::HardFork::DEFAULT_THRESHOLD_PERCENT = 80

static

Definition at line 52 of file hardfork.h.

DEFAULT_UPDATE_TIME

const time_t cryptonote::HardFork::DEFAULT_UPDATE_TIME = 31557600 / 2

static

Definition at line 50 of file hardfork.h.

DEFAULT_WINDOW_SIZE

const uint64_t cryptonote::HardFork::DEFAULT_WINDOW_SIZE = 10080

static

Definition at line 51 of file hardfork.h.

---

The documentation for this class was generated from the following files:

• /home/abuild/rpmbuild/BUILD/electroneum-5.1.3.1-build/electroneum-5.1.3.1/src/cryptonote_basic/hardfork.h
• /home/abuild/rpmbuild/BUILD/electroneum-5.1.3.1-build/electroneum-5.1.3.1/src/cryptonote_basic/hardfork.cpp