BlockTree is a tree of blocks with single "bootstrap" block as root. More...

Detailed Description

template<typename Block, typename ChainParams>
struct altintegration::BlockTree< Block, ChainParams >

Template Parameters

Block

Definition at line 30 of file blocktree.hpp.

#include <blocktree.hpp>

Inheritance diagram for altintegration::BlockTree< Block, ChainParams >:

Collaboration diagram for altintegration::BlockTree< Block, ChainParams >:

Public Types
using	base = BaseBlockTree< Block >

using	block_t = Block

using	params_t = ChainParams

using	index_t = typename base::index_t

using	stored_index_t = typename base::stored_index_t

using	hash_t = typename Block::hash_t

using	prev_block_hash_t = typename Block::prev_hash_t

using	height_t = typename Block::height_t

Public Types inherited from altintegration::BaseBlockTree< Block >
using	block_t = Block

using	block_height_t = typename block_t::height_t

using	hash_t = typename Block::hash_t

using	prev_block_hash_t = typename Block::prev_hash_t

using	index_t = BlockIndex< Block >

using	stored_index_t = StoredBlockIndex< Block >

using	on_invalidate_t = void(const index_t &)

using	block_index_t = std::unordered_map< prev_block_hash_t, std::unique_ptr< index_t > >

Public Member Functions
	BlockTree (const ChainParams &param, const BlockReader &blockProvider)

const ChainParams &	getParams () const

virtual void	bootstrapWithGenesis (const block_t &block)
	Bootstrap blockchain with a single genesis block. More...

virtual void	bootstrapWithChain (height_t startHeight, const std::vector< block_t > &chain)
	Bootstrap network with a chain that starts at 'startHeight'. More...

bool	acceptBlockHeader (const block_t &block, ValidationState &state)

bool	acceptBlockHeader (const std::shared_ptr< block_t > &block, ValidationState &state)

std::string	toPrettyString (size_t level=0) const

bool	loadBlockForward (const stored_index_t &index, bool fast_load, ValidationState &state) override

bool	isBlockOld (height_t height) const
	block is considered old if it is behind current tip further than 'old blocks window' blocks More...

bool	isBlockOld (const hash_t &hash) const
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...

void	finalizeBlocks ()

Public Member Functions inherited from altintegration::BaseBlockTree< Block >
const std::unordered_set< index_t * > &	getTips () const

std::vector< index_t * >	getBlocks () const

std::vector< index_t * >	getAllBlocks () const

const BlockReader &	getBlockProvider () const

	BaseBlockTree (const BlockReader &blockProvider)

	BaseBlockTree (const BaseBlockTree &)=delete

BaseBlockTree &	operator= (const BaseBlockTree &)=delete

	BaseBlockTree (BaseBlockTree &&)=default

BaseBlockTree &	operator= (BaseBlockTree &&)=default

const Chain< index_t > &	getBestChain () const
	Getter for currently Active Chain. More...

template<typename T >
prev_block_hash_t	makePrevHash (const T &h) const

template<typename T , typename = typename std::enable_if< std::is_same<T, hash_t>::value \|\| std::is_same<T, prev_block_hash_t>::value>::type>
index_t *	getBlockIndex (const T &hash)
	Get BlockIndex by block hash. More...

template<typename T , typename = typename std::enable_if< std::is_same<T, hash_t>::value \|\| std::is_same<T, prev_block_hash_t>::value>::type>
const index_t *	getBlockIndex (const T &hash) const
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...

template<typename T , typename = typename std::enable_if< std::is_same<T, hash_t>::value \|\| std::is_same<T, prev_block_hash_t>::value>::type>
index_t *	findBlockIndex (const T &hash)
	Get BlockIndex by block hash. More...

template<typename T , typename = typename std::enable_if< std::is_same<T, hash_t>::value \|\| std::is_same<T, prev_block_hash_t>::value>::type>
const index_t *	findBlockIndex (const T &hash) const
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...

virtual bool	loadTip (const hash_t &hash, ValidationState &state)

virtual bool	loadBlockForward (const stored_index_t &index, bool fast_load, ValidationState &state)
	Efficiently connects BlockIndex to this tree as a leaf, when it is loaded from disk. More...

void	removeSubtree (index_t &toRemove)
	Removes block and all its successors. More...

void	removeSubtree (const hash_t &toRemove)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...

void	removeLeaf (index_t &toRemove)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...

void	invalidateSubtree (index_t &toBeInvalidated, enum BlockValidityStatus reason, bool shouldDetermineBestChain=true)
	Mark given block as invalid. More...

void	invalidateSubtree (const hash_t &toBeInvalidated, enum BlockValidityStatus reason, bool shouldDetermineBestChain=true)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...

void	revalidateSubtree (const hash_t &hash, enum BlockValidityStatus reason, bool shouldDetermineBestChain=true)

void	revalidateSubtree (index_t &toBeValidated, enum BlockValidityStatus reason, bool shouldDetermineBestChain=true)

bool	isBootstrapped () const
	Check if the blockchain is bootstrapped. More...

virtual bool	setState (const hash_t &block, ValidationState &state)

virtual bool	setState (index_t &index, ValidationState &)

virtual void	overrideTip (index_t &to)

index_t &	getRoot () const

const FinalizedPayloadsIndex< index_t > &	getFinalizedPayloadsIndex () const

const PayloadsIndex< index_t > &	getPayloadsIndex () const

DeferForkResolutionGuard	deferForkResolutionGuard ()

BaseBlockTree< VbkBlock >::prev_block_hash_t	makePrevHash (const hash_t &h) const
	HACK: getBlockIndex accepts either hash_t or prev_block_hash_t then, depending on what it received, it should do trim LE on full hash to receive short hash, which is stored inside a map. More...

Protected Member Functions
bool	acceptBlockHeaderImpl (const std::shared_ptr< block_t > &block, ValidationState &state, bool shouldContextuallyCheck)

void	bootstrap (height_t height, const block_t &block, ValidationState &state)

void	bootstrap (height_t height, std::shared_ptr< block_t > block, ValidationState &state)

bool	validateAndAddBlock (const std::shared_ptr< block_t > &block, ValidationState &state, bool shouldContextuallyCheck, index_t **ret)

void	determineBestChain (index_t &candidate, ValidationState &state) override

void	onBlockInserted (index_t *newIndex) final
	whenever new block is inserted, BlockTree has to update its ChainWork More...

Protected Member Functions inherited from altintegration::BaseBlockTree< Block >
void	deallocateBlock (index_t &block)
	Permanently erases block from a block tree. More...

std::string	toPrettyString (size_t level=0) const

void	decreaseAppliedBlockCount (size_t erasedBlocks)

void	decreaseAppliedBlockCount (size_t)

Protected Attributes
const ChainParams *	param_ = nullptr

Protected Attributes inherited from altintegration::BaseBlockTree< Block >
bool	isLoadingBlocks_ = false
	if true, we're in "loading blocks" state More...

bool	isLoaded_ = false
	if true, we can no longer execute loadBlock/loadTip on this tree. More...

block_index_t	blocks_
	stores ALL blocks, including valid and invalid More...

std::unordered_set< index_t * >	tips_
	stores ONLY VALID tips, including currently active tip More...

Chain< index_t >	activeChain_
	currently applied chain More...

FinalizedPayloadsIndex< index_t >	finalizedPayloadsIndex_
	stores mapping of payload id -> its containing ALT/VBK block which are already finalized. More...

PayloadsIndex< index_t >	payloadsIndex_
	stores mapping of payload id -> its containing ALT/VBK blocks which are not yet finalized. More...

const BlockReader &	blockProvider_

Additional Inherited Members
Public Attributes inherited from altintegration::BaseBlockTree< Block >
signals::Signal< void(const index_t &)>	onBlockBeforeDeallocated
	before we deallocate any block index we emit it to this signal More...

signals::Signal< on_invalidate_t >	onBlockValidityChanged
	signals to the end user that block have been invalidated More...

signals::Signal< void(const index_t &index)>	onBeforeOverrideTip
	chain reorg signal - the tip is being changed More...

Member Typedef Documentation

◆ base

template<typename Block , typename ChainParams >

using altintegration::BlockTree< Block, ChainParams >::base = BaseBlockTree<Block>

Definition at line 31 of file blocktree.hpp.

◆ block_t

template<typename Block , typename ChainParams >

using altintegration::BlockTree< Block, ChainParams >::block_t = Block

Definition at line 32 of file blocktree.hpp.

◆ hash_t

template<typename Block , typename ChainParams >

using altintegration::BlockTree< Block, ChainParams >::hash_t = typename Block::hash_t

Definition at line 36 of file blocktree.hpp.

◆ height_t

template<typename Block , typename ChainParams >

using altintegration::BlockTree< Block, ChainParams >::height_t = typename Block::height_t

Definition at line 38 of file blocktree.hpp.

◆ index_t

template<typename Block , typename ChainParams >

using altintegration::BlockTree< Block, ChainParams >::index_t = typename base::index_t

Definition at line 34 of file blocktree.hpp.

◆ params_t

template<typename Block , typename ChainParams >

using altintegration::BlockTree< Block, ChainParams >::params_t = ChainParams

Definition at line 33 of file blocktree.hpp.

◆ prev_block_hash_t

template<typename Block , typename ChainParams >

using altintegration::BlockTree< Block, ChainParams >::prev_block_hash_t = typename Block::prev_hash_t

Definition at line 37 of file blocktree.hpp.

◆ stored_index_t

template<typename Block , typename ChainParams >

using altintegration::BlockTree< Block, ChainParams >::stored_index_t = typename base::stored_index_t

Definition at line 35 of file blocktree.hpp.

Constructor & Destructor Documentation

◆ BlockTree()

template<typename Block , typename ChainParams >

altintegration::BlockTree< Block, ChainParams >::BlockTree	(	const ChainParams &	param,
		const BlockReader &	blockProvider
	)

inline

Definition at line 42 of file blocktree.hpp.

43 : base(blockProvider), param_(&param) {}

Member Function Documentation

◆ acceptBlockHeader() [1/2]

template<typename Block , typename ChainParams >

bool altintegration::BlockTree< Block, ChainParams >::acceptBlockHeader	(	const block_t &	block,
		ValidationState &	state
	)

inline

Definition at line 103 of file blocktree.hpp.

                                                                       {
    return acceptBlockHeaderImpl(std::make_shared<block_t>(block), state, true);
  }

◆ acceptBlockHeader() [2/2]

template<typename Block , typename ChainParams >

bool altintegration::BlockTree< Block, ChainParams >::acceptBlockHeader	(	const std::shared_ptr< block_t > &	block,
		ValidationState &	state
	)

inline

Definition at line 107 of file blocktree.hpp.

                                                 {
    return acceptBlockHeaderImpl(block, state, true);
  }

◆ acceptBlockHeaderImpl()

template<typename Block , typename ChainParams >

bool altintegration::BlockTree< Block, ChainParams >::acceptBlockHeaderImpl	(	const std::shared_ptr< block_t > &	block,
		ValidationState &	state,
		bool	shouldContextuallyCheck
	)

inlineprotected

Definition at line 191 of file blocktree.hpp.

                                                           {
    index_t* index = nullptr;
    if (!validateAndAddBlock(block, state, shouldContextuallyCheck, &index)) {
      return false;
    }
 
    VBK_ASSERT(index);
    if (!shouldContextuallyCheck) {
      // this is a bootstrap block
      index->setFlag(BLOCK_BOOTSTRAP);
    }
 
    base::tryAddTip(index);
 
    // don't defer fork resolution in the acceptBlockHeader+addPayloads flow
    // until the validation hole is plugged
    determineBestChain(*index, state);
 
    return true;
  }

◆ bootstrap() [1/2]

template<typename Block , typename ChainParams >

void altintegration::BlockTree< Block, ChainParams >::bootstrap	(	height_t	height,
		const block_t &	block,
		ValidationState &	state
	)

inlineprotected

Definition at line 214 of file blocktree.hpp.

                                         {
    bootstrap(height, std::make_shared<block_t>(block), state);
  }

◆ bootstrap() [2/2]

template<typename Block , typename ChainParams >

void altintegration::BlockTree< Block, ChainParams >::bootstrap	(	height_t	height,
		std::shared_ptr< block_t >	block,
		ValidationState &	state
	)

inlineprotected

Definition at line 220 of file blocktree.hpp.

                                         {
    bool ok = checkBlock(*block, state, *param_);
    VBK_ASSERT_MSG(ok,
                   "found statelessly invalid bootstrap block in %s tree: %s",
                   block_t::name(),
                   state.toString());
 
    auto* index = base::insertBlockHeader(block, height);
    VBK_ASSERT(index != nullptr &&
               "insertBlockHeader should have never returned nullptr");
 
    index->setHeight(height);
    base::activeChain_ = Chain<index_t>(height, index);
    index->setIsBootstrap(true);
 
    VBK_ASSERT(index->finalized);
    VBK_ASSERT(base::isBootstrapped());
    VBK_ASSERT(base::getBlockIndex(index->getHash()) != nullptr &&
               "getBlockIndex must be able to find the block added by "
               "insertBlockHeader");
 
    base::tryAddTip(index);
    index->setFlag(BLOCK_ACTIVE);
    bool success = index->raiseValidity(BLOCK_CAN_BE_APPLIED);
    VBK_ASSERT(success);
    index->setFlag(BLOCK_BOOTSTRAP);
    base::appliedBlockCount = 1;
  }

◆ bootstrapWithChain()

template<typename Block , typename ChainParams >

virtual void altintegration::BlockTree< Block, ChainParams >::bootstrapWithChain	(	height_t	startHeight,
		const std::vector< block_t > &	chain
	)

inlinevirtual

This function does all blockchain integrity checks, does blockchain cleanup and in general, very slow.

Parameters

[in]	startHeight	start height of the chain
[in]	chain	bootstrap chain

Definition at line 68 of file blocktree.hpp.

                                                                   {
    VBK_ASSERT(!base::isBootstrapped() && "already bootstrapped");
    VBK_ASSERT(!this->isLoadingBlocks_);
    VBK_ASSERT(!this->isLoaded_);
    VBK_ASSERT_MSG(!chain.empty(), "bootstrap chain must not be empty");
    VBK_ASSERT_MSG(
        chain.size() >= param_->numBlocksForBootstrap(),
        "bootstrap chain is too small (%d) expected at least %d blocks",
        chain.size(),
        param_->numBlocksForBootstrap());
 
    ValidationState state;
 
    // pick first block from the chain, bootstrap with a single block
    auto genesis = chain[0];
    this->bootstrap(startHeight, genesis, state);
 
    // apply the rest of the blocks from the chain on top of our bootstrap
    // block. disable difficulty checks, because we have not enough blocks in
    // our store (yet) to check it correctly
    for (size_t i = 1, size = chain.size(); i < size; i++) {
      auto& block = chain[i];
      bool ok = this->acceptBlockHeaderImpl(
          std::make_shared<block_t>(block), state, false);
      VBK_ASSERT_MSG(ok,
                     "found statelssly invalid bootstrap block: %d, %s",
                     i,
                     state.toString());
      auto* index = base::getBlockIndex(block.getHash());
      VBK_ASSERT(index);
      index->setIsBootstrap(true);
    }
  }

◆ bootstrapWithGenesis()

template<typename Block , typename ChainParams >

virtual void altintegration::BlockTree< Block, ChainParams >::bootstrapWithGenesis ( const block_t & block )

inlinevirtual

Definition at line 50 of file blocktree.hpp.

                                                          {
    VBK_ASSERT(!base::isBootstrapped() && "already bootstrapped");
    VBK_ASSERT(!this->isLoaded_);
    VBK_ASSERT(!this->isLoadingBlocks_);
    ValidationState state;
    this->bootstrap(0, block, state);
    this->isLoadingBlocks_ = false;
  }

◆ determineBestChain()

template<typename Block , typename ChainParams >

void altintegration::BlockTree< Block, ChainParams >::determineBestChain	(	index_t &	candidate,
		ValidationState &	state
	)

inlineoverrideprotectedvirtual

important to use this->setState for proper vtable resolution

Implements altintegration::BaseBlockTree< Block >.

Definition at line 293 of file blocktree.hpp.

                                                                               {
    auto bestTip = base::getBestChain().tip();
    VBK_ASSERT(bestTip != nullptr && "must be bootstrapped");
 
    if (bestTip == &candidate) {
      return;
    }
 
    // do not even consider invalid candidates
    if (!candidate.isValid()) {
      return;
    }
 
    if (bestTip->chainWork < candidate.chainWork) {
      this->setState(candidate, state);
    }
  }

◆ finalizeBlocks()

template<typename Block , typename ChainParams >

void altintegration::BlockTree< Block, ChainParams >::finalizeBlocks ( )

inline

Definition at line 182 of file blocktree.hpp.

                        {
    VBK_ASSERT(!this->isLoadingBlocks_);
    base::finalizeBlocks(this->getParams().getMaxReorgBlocks(),
                         this->getParams().preserveBlocksBehindFinal());
  }

◆ getParams()

template<typename Block , typename ChainParams >

const ChainParams & altintegration::BlockTree< Block, ChainParams >::getParams ( ) const

inline

Definition at line 45 of file blocktree.hpp.

45{ return *param_; }

◆ isBlockOld() [1/2]

template<typename Block , typename ChainParams >

bool altintegration::BlockTree< Block, ChainParams >::isBlockOld ( const hash_t & hash ) const

inline

Definition at line 172 of file blocktree.hpp.

                                            {
    auto* index = base::getBlockIndex(hash);
    if (index == nullptr) {
      // block is unknown, so not "old"
      return false;
    }
 
    return isBlockOld(index->getHeight());
  }

◆ isBlockOld() [2/2]

template<typename Block , typename ChainParams >

bool altintegration::BlockTree< Block, ChainParams >::isBlockOld ( height_t height ) const

inline

Definition at line 164 of file blocktree.hpp.

                                         {
    auto* tip = base::getBestChain().tip();
    VBK_ASSERT(tip);
 
    return tip->getHeight() - height > getParams().getOldBlocksWindow();
  }

◆ loadBlockForward()

template<typename Block , typename ChainParams >

bool altintegration::BlockTree< Block, ChainParams >::loadBlockForward	(	const stored_index_t &	index,
		bool	fast_load,
		ValidationState &	state
	)

inlineoverridevirtual

Invariant: NOT atomic.

Reimplemented from altintegration::BaseBlockTree< Block >.

Definition at line 123 of file blocktree.hpp.

                                                         {
    if (!fast_load && !checkBlock(*index.header, state, *param_)) {
      return state.Invalid("bad-header");
    }
 
    const auto hash = index.header->getHash();
    if (!base::loadBlockForward(index, fast_load, state)) {
      return false;
    }
 
    auto* current = base::getBlockIndex(hash);
    VBK_ASSERT(current);
    VBK_ASSERT(!this->isLoaded_);
    VBK_ASSERT(this->isLoadingBlocks_);
 
    // we only check blocks contextually if they are not bootstrap blocks, and
    // previous block exists
    if (!fast_load && !current->isRoot() &&
        !current->hasFlags(BLOCK_BOOTSTRAP) &&
        !contextuallyCheckBlock(
            *current->pprev, current->getHeader(), state, *param_)) {
      return state.Invalid("bad-block-contextually");
    }
 
    // recover chainwork
    current->chainWork = getBlockProof(current->getHeader());
    if (!current->isRoot()) {
      current->chainWork += current->pprev->chainWork;
    }
 
    // clear blockOfProofEndorsements inmem field
    current->clearBlockOfProofEndorsement();
 
    current->raiseValidity(BLOCK_VALID_TREE);
    return true;
  }

◆ onBlockInserted()

template<typename Block , typename ChainParams >

void altintegration::BlockTree< Block, ChainParams >::onBlockInserted ( index_t * newIndex )

inlinefinalprotectedvirtual

Reimplemented from altintegration::BaseBlockTree< Block >.

Definition at line 313 of file blocktree.hpp.

                                                {
    newIndex->chainWork = getBlockProof(newIndex->getHeader());
    if (!newIndex->isRoot()) {
      newIndex->chainWork += newIndex->pprev->chainWork;
    }
  }

◆ toPrettyString()

template<typename Block , typename ChainParams >

std::string altintegration::BlockTree< Block, ChainParams >::toPrettyString ( size_t level = 0 ) const

inline

Definition at line 112 of file blocktree.hpp.

                                                   {
    std::string pad(level, ' ');
    return format("{}{}BlockTree{{blocks={}\n{}\n{}}}",
                  pad,
                  Block::name(),
                  base::getBlocks().size(),
                  base::toPrettyString(level + 2),
                  pad);
  }

◆ validateAndAddBlock()

template<typename Block , typename ChainParams >

bool altintegration::BlockTree< Block, ChainParams >::validateAndAddBlock	(	const std::shared_ptr< block_t > &	block,
		ValidationState &	state,
		bool	shouldContextuallyCheck,
		index_t **	ret
	)

inlineprotected

Definition at line 251 of file blocktree.hpp.

                                          {
    if (!checkBlock(*block, state, *param_)) {
      return state.Invalid(block_t::name() + "-check-block");
    }
 
    // we must know previous block
    auto* prev = base::getBlockIndex(block->getPreviousBlock());
    if (prev == nullptr) {
      return state.Invalid(
          block_t::name() + "-bad-prev-block",
          "can not find previous block: " + HexStr(block->getPreviousBlock()));
    }
 
    if (shouldContextuallyCheck &&
        !contextuallyCheckBlock(*prev, *block, state, *param_)) {
      return state.Invalid(block_t::name() + "-contextually-check-block");
    }
 
    auto index = base::insertBlockHeader(block);
    VBK_ASSERT(index != nullptr &&
               "insertBlockHeader should have never returned nullptr");
 
    if (ret) {
      *ret = index;
    }
 
    index->raiseValidity(BLOCK_CONNECTED);
 
    // if prev block is invalid, mark this block as invalid
    if (!prev->isValid()) {
      index->setFlag(BLOCK_FAILED_CHILD);
      return state.Invalid(
          block_t::name() + "-bad-chain",
          format("Previous block is invalid={}", prev->toPrettyString()));
    }
 
    return true;
  }

Member Data Documentation

◆ param_

template<typename Block , typename ChainParams >

const ChainParams* altintegration::BlockTree< Block, ChainParams >::param_ = nullptr

protected

Definition at line 189 of file blocktree.hpp.

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

include/veriblock/pop/alt-util.hpp
include/veriblock/pop/blockchain/blocktree.hpp

Detailed Description

Public Types

Public Member Functions

Protected Member Functions

Protected Attributes

Additional Inherited Members

Member Typedef Documentation

◆ base

◆ block_t

◆ hash_t

◆ height_t

◆ index_t

◆ params_t

◆ prev_block_hash_t

◆ stored_index_t

Constructor & Destructor Documentation

◆ BlockTree()

Member Function Documentation

◆ acceptBlockHeader() [1/2]

◆ acceptBlockHeader() [2/2]

◆ acceptBlockHeaderImpl()

◆ bootstrap() [1/2]

◆ bootstrap() [2/2]

◆ bootstrapWithChain()

◆ bootstrapWithGenesis()

◆ determineBestChain()

◆ finalizeBlocks()

◆ getParams()

◆ isBlockOld() [1/2]

◆ isBlockOld() [2/2]

◆ loadBlockForward()

◆ onBlockInserted()

◆ toPrettyString()

◆ validateAndAddBlock()

Member Data Documentation

◆ param_