altintegration::BaseBlockTree< Block > Struct Template Reference

Base block tree that stores all blocks, maintains tree tips, maintains active chain. More...

Detailed Description

template<typename Block>
struct altintegration::BaseBlockTree< Block >

Template Parameters

Block

Definition at line 35 of file base_block_tree.hpp.

#include <base_block_tree.hpp>

Inheritance diagram for altintegration::BaseBlockTree< Block >:

Collaboration diagram for altintegration::BaseBlockTree< Block >:

Public Types
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
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...

Public Attributes
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...

Protected Member Functions
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
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_

Member Typedef Documentation

block_height_t

template<typename Block >

using altintegration::BaseBlockTree< Block >::block_height_t = typename block_t::height_t

Definition at line 37 of file base_block_tree.hpp.

block_index_t

template<typename Block >

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

Definition at line 43 of file base_block_tree.hpp.

block_t

template<typename Block >

using altintegration::BaseBlockTree< Block >::block_t = Block

Definition at line 36 of file base_block_tree.hpp.

hash_t

template<typename Block >

using altintegration::BaseBlockTree< Block >::hash_t = typename Block::hash_t

Definition at line 38 of file base_block_tree.hpp.

index_t

template<typename Block >

using altintegration::BaseBlockTree< Block >::index_t = BlockIndex<Block>

Definition at line 40 of file base_block_tree.hpp.

on_invalidate_t

template<typename Block >

using altintegration::BaseBlockTree< Block >::on_invalidate_t = void(const index_t&)

Definition at line 42 of file base_block_tree.hpp.

prev_block_hash_t

template<typename Block >

using altintegration::BaseBlockTree< Block >::prev_block_hash_t = typename Block::prev_hash_t

Definition at line 39 of file base_block_tree.hpp.

stored_index_t

template<typename Block >

using altintegration::BaseBlockTree< Block >::stored_index_t = StoredBlockIndex<Block>

Definition at line 41 of file base_block_tree.hpp.

Constructor & Destructor Documentation

~BaseBlockTree()

template<typename Block >

virtual altintegration::BaseBlockTree< Block >::~BaseBlockTree ( )

inlinevirtual

Definition at line 69 of file base_block_tree.hpp.

                           {
    if (!isBootstrapped()) {
      return;
    }
 
    deallocateTree(getRoot());
  }

BaseBlockTree()

template<typename Block >

altintegration::BaseBlockTree< Block >::BaseBlockTree ( const BlockReader &  blockProvider )

inline

Definition at line 77 of file base_block_tree.hpp.

      : blockProvider_(blockProvider) {}

Member Function Documentation

deallocateBlock()

template<typename Block >

void altintegration::BaseBlockTree< Block >::deallocateBlock ( index_t &  block )

inlineprotected

Invariant

should be the only function that deallocates blocks.

erased block must be a tip.

erased block must be "deleted".

erased block must exist in block tree.

Definition at line 497 of file base_block_tree.hpp.

                                       {
    VBK_TRACE_ZONE_SCOPED;
    VBK_ASSERT_MSG(block.isDeleted(),
                   "cannot erase a block that is not deleted %s",
                   block.toPrettyString());
    VBK_ASSERT_MSG(
        block.isTip(),
        "cannot erase a block that has ancestors as that would split "
        "the tree: %s",
        block.toPrettyString());
 
    onBlockBeforeDeallocated.emit(block);
    auto shortHash = makePrevHash(block.getHash());
    auto count = blocks_.erase(shortHash);
    VBK_ASSERT_MSG(count == 1,
                   "state corruption: block %s is not in the store",
                   block.toPrettyString());
  }

decreaseAppliedBlockCount() [1/2]

template<typename Block >

void altintegration::BaseBlockTree< Block >::decreaseAppliedBlockCount ( size_t  erasedBlocks )

inlineprotected

Definition at line 857 of file base_block_tree.hpp.

                                                             {
    VBK_ASSERT_MSG(appliedBlockCount >= erasedBlocks,
                   "Tree: %s, Applied: %d, erased: %d",
                   block_t::name(),
                   appliedBlockCount,
                   erasedBlocks);
    appliedBlockCount -= erasedBlocks;
  }

decreaseAppliedBlockCount() [2/2]

void altintegration::BaseBlockTree< BtcBlock >::decreaseAppliedBlockCount ( size_t  )

inlineprotected

Definition at line 25 of file vbk_block_tree.hpp.

                                                                     {
  // do nothing
  // BTC tree is not protected
}

deferForkResolutionGuard()

template<typename Block >

DeferForkResolutionGuard altintegration::BaseBlockTree< Block >::deferForkResolutionGuard ( )

inline

Definition at line 816 of file base_block_tree.hpp.

                                                      {
    return DeferForkResolutionGuard(*this);
  }

findBlockIndex() [1/2]

template<typename Block >

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 * altintegration::BaseBlockTree< Block >::findBlockIndex ( const T &  hash )

inline

Template Parameters

T	block type

Parameters

[in]

hash

block hash

Returns

nullptr if block is not found, or ptr to block otherwise.

Definition at line 139 of file base_block_tree.hpp.

                                         {
    const auto& t = as_const(*this);
    return const_cast<index_t*>(t.findBlockIndex(hash));
  }

findBlockIndex() [2/2]

template<typename Block >

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 * altintegration::BaseBlockTree< Block >::findBlockIndex ( const T &  hash ) const

inline

Definition at line 149 of file base_block_tree.hpp.

                                                     {
    VBK_TRACE_ZONE_SCOPED;
    auto shortHash = makePrevHash(hash);
    auto it = blocks_.find(shortHash);
    return it == blocks_.end() ? nullptr : it->second.get();
  }

getAllBlocks()

template<typename Block >

std::vector< index_t * > altintegration::BaseBlockTree< Block >::getAllBlocks ( ) const

inline

Definition at line 58 of file base_block_tree.hpp.

                                           {
    std::vector<index_t*> blocks;
    blocks.reserve(blocks_.size());
    for (const auto& el : blocks_) {
      blocks.push_back(el.second.get());
    }
    return blocks;
  }

getBestChain()

template<typename Block >

const Chain< index_t > & altintegration::BaseBlockTree< Block >::getBestChain ( ) const

inline

Returns

reference for current chain.

Definition at line 94 of file base_block_tree.hpp.

{ return this->activeChain_; }

getBlockIndex() [1/2]

template<typename Block >

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 * altintegration::BaseBlockTree< Block >::getBlockIndex ( const T &  hash )

inline

Template Parameters

T	block type

Parameters

[in]

hash

block hash

Returns

nullptr if block is not found, or ptr to block otherwise.

Definition at line 113 of file base_block_tree.hpp.

                                        {
    const auto& t = as_const(*this);
    return const_cast<index_t*>(t.getBlockIndex(hash));
  }

getBlockIndex() [2/2]

template<typename Block >

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 * altintegration::BaseBlockTree< Block >::getBlockIndex ( const T &  hash ) const

inline

Definition at line 123 of file base_block_tree.hpp.

                                                    {
    auto blockIndex = findBlockIndex(hash);
    return blockIndex != nullptr && blockIndex->isDeleted() ? nullptr
                                                            : blockIndex;
  }

getBlockProvider()

template<typename Block >

const BlockReader & altintegration::BaseBlockTree< Block >::getBlockProvider ( ) const

inline

Definition at line 67 of file base_block_tree.hpp.

{ return blockProvider_; }

getBlocks()

template<typename Block >

std::vector< index_t * > altintegration::BaseBlockTree< Block >::getBlocks ( ) const

inline

Definition at line 47 of file base_block_tree.hpp.

                                        {
    std::vector<index_t*> blocks;
    blocks.reserve(blocks_.size());
    for (const auto& el : blocks_) {
      if (!el.second->isDeleted()) {
        blocks.push_back(el.second.get());
      }
    }
    return blocks;
  }

getFinalizedPayloadsIndex()

template<typename Block >

const FinalizedPayloadsIndex< index_t > & altintegration::BaseBlockTree< Block >::getFinalizedPayloadsIndex ( ) const

inline

Definition at line 779 of file base_block_tree.hpp.

                                                                           {
    return finalizedPayloadsIndex_;
  }

getPayloadsIndex()

template<typename Block >

const PayloadsIndex< index_t > & altintegration::BaseBlockTree< Block >::getPayloadsIndex ( ) const

inline

Definition at line 783 of file base_block_tree.hpp.

                                                         {
    return payloadsIndex_;
  }

getRoot()

template<typename Block >

index_t & altintegration::BaseBlockTree< Block >::getRoot ( ) const

inline

Definition at line 422 of file base_block_tree.hpp.

                           {
    VBK_ASSERT_MSG(isBootstrapped(), "must be bootstrapped");
    auto* root = getBestChain().first();
    VBK_ASSERT_MSG(root, "must be bootstrapped");
    return *root;
  }

getTips()

template<typename Block >

const std::unordered_set< index_t * > & altintegration::BaseBlockTree< Block >::getTips ( ) const

inline

Definition at line 46 of file base_block_tree.hpp.

{ return tips_; }

invalidateSubtree() [1/2]

template<typename Block >

void altintegration::BaseBlockTree< Block >::invalidateSubtree ( const hash_t &  toBeInvalidated, enum BlockValidityStatus  reason, bool  shouldDetermineBestChain = true  )

inline

Invariant

block must exist in a tree

Definition at line 320 of file base_block_tree.hpp.

                                                               {
    auto* index = getBlockIndex(toBeInvalidated);
    VBK_ASSERT(index && "cannot find the subtree to invalidate");
    return invalidateSubtree(*index, reason, shouldDetermineBestChain);
  }

invalidateSubtree() [2/2]

template<typename Block >

void altintegration::BaseBlockTree< Block >::invalidateSubtree ( index_t &  toBeInvalidated, enum BlockValidityStatus  reason, bool  shouldDetermineBestChain = true  )

inline

Also marks all successors as FAILED_CHILD.

Parameters

[in]	toBeInvalidated	block to be invalidated
[in]	reason	invalidation reason. BLOCK_FAILED_BLOCK is used to indicate that block is invalid because of consensus rules (altchain decided to invalidate it). BLOCK_FAILED_POP is used to indicate that block is invalid because it contains invalid POP data.
[in]	shouldDetermineBestChain	when true, will trigger fork resolution with all tips. If it is known that block is on a fork (not on active chain), it is safe to omit fork resolution here. Otherwise, leaves tree in undefined state.

Definition at line 265 of file base_block_tree.hpp.

                                                               {
    VBK_TRACE_ZONE_SCOPED;
    VBK_LOG_DEBUG("Invalidating %s subtree: reason=%d block=%s",
                  block_t::name(),
                  (int)reason,
                  toBeInvalidated.toShortPrettyString());
 
    VBK_ASSERT_MSG(!toBeInvalidated.isRoot(),
                   "cannot invalidate the root block");
 
    VBK_ASSERT(isValidInvalidationReason(reason) &&
               "invalid invalidation reason");
 
    if (toBeInvalidated.hasFlags(reason)) {
      return;
    }
 
    // all descendants of an invalid block are already flagged as
    // BLOCK_FAILED_CHILD
    if (!toBeInvalidated.isValid()) {
      doInvalidate(toBeInvalidated, reason);
      return;
    }
 
    bool isOnMainChain = activeChain_.contains(&toBeInvalidated);
    if (isOnMainChain) {
      ValidationState dummy;
      bool success = this->setState(*toBeInvalidated.pprev, dummy);
      VBK_ASSERT(success);
    }
 
    doInvalidate(toBeInvalidated, reason);
 
    // flag the child subtrees (excluding current block) as BLOCK_FAILED_CHILD
    for (auto* ptr : toBeInvalidated.pnext) {
      auto* pnext = ptr;
      forEachNodePreorder<block_t>(*pnext, [&](index_t& index) {
        bool failed = index.isFailed();
        doInvalidate(index, BLOCK_FAILED_CHILD);
        return !failed;
      });
    }
 
    // after invalidation, the previous block might have become a tip
    tryAddTip(toBeInvalidated.pprev);
 
    if (shouldDetermineBestChain) {
      updateTips();
    }
  }

isBootstrapped()

template<typename Block >

bool altintegration::BaseBlockTree< Block >::isBootstrapped ( ) const

inline

Returns

true if the blockchain is bootstrapped, false otherwise

Definition at line 386 of file base_block_tree.hpp.

                              {
    if (!blocks_.empty() && activeChain_.tip() != nullptr) {
      return true;
    }
 
    if (blocks_.empty() && activeChain_.tip() == nullptr) {
      return false;
    }
 
    VBK_ASSERT_MSG(
        false,
        "state corruption: the blockchain is neither bootstrapped nor empty");
    return false;
  }

loadBlockForward()

template<typename Block >

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

inlinevirtual

Parameters

[in]	index	block to be connected
[in]	fast_load	flag
[out]	state	validation state

Returns

true if block is valid and successfully loaded, false otherwise.

Invariant

NOT atomic. If returned false, leaves BaseBlockTree in undefined state.

Reimplemented in altintegration::AltBlockTree, altintegration::BlockTree< Block, ChainParams >, altintegration::BlockTree< VbkBlock, VbkChainParams >, and altintegration::VbkBlockTree.

Definition at line 189 of file base_block_tree.hpp.

                                                        {
    return loadBlockInner(index, true, fast_load, state);
  }

loadTip()

template<typename Block >

virtual bool altintegration::BaseBlockTree< Block >::loadTip ( const hash_t &  hash, ValidationState &  state  )

inlinevirtual

Definition at line 156 of file base_block_tree.hpp.

                                                                   {
    VBK_TRACE_ZONE_SCOPED;
    VBK_ASSERT_MSG(this->isLoadingBlocks_,
                   "%s tree must be in LoadingBlocks state!",
                   block_t::name());
    VBK_ASSERT_MSG(
        !this->isLoaded_, "%s tree is already loaded!", block_t::name());
 
    auto* tip = getBlockIndex(hash);
    if (tip == nullptr) {
      return state.Invalid(
          block_t::name() + "-no-tip",
          format("tip {} doesn't exist in block tree", HexStr(hash)));
    }
 
    this->overrideTip(*tip);
 
    // we no longer can execute loadTip/loadBlocks
    this->isLoaded_ = true;
    this->isLoadingBlocks_ = false;
    return true;
  }

makePrevHash() [1/2]

BaseBlockTree< VbkBlock >::prev_block_hash_t altintegration::BaseBlockTree< VbkBlock >::makePrevHash< BaseBlockTree< VbkBlock >::hash_t > ( const hash_t &  h ) const

inline

In this weird case, when Block=VbkBlock, we may call getBlockIndex(block->previousBlock), it is a call getBlockIndex(Blob<12>). But whengetBlockIndex` accepts it, it does an implicit cast to full hash (hash_t), adding zeroes in the end. Then, .trimLE returns 12 zeroes.

This hack allows us to inject explicit conversion hash_t (Blob<24>) -> prev_block_hash_t (Blob<12>).

Definition at line 305 of file vbk_block_tree.hpp.

                           {
  // do an explicit cast from hash_t -> prev_block_hash_t
  return h.template trimLE<prev_block_hash_t::size()>();
}

makePrevHash() [2/2]

template<typename Block >

template<typename T >

prev_block_hash_t altintegration::BaseBlockTree< Block >::makePrevHash ( const T &  h ) const

inline

Definition at line 98 of file base_block_tree.hpp.

                                                          {
    // given any type T, just return an implicit cast to prev_block_hash_t
    return h;
  }

overrideTip()

template<typename Block >

virtual void altintegration::BaseBlockTree< Block >::overrideTip ( index_t &  to )

inlinevirtual

Definition at line 416 of file base_block_tree.hpp.

                                        {
    onBeforeOverrideTip.emit(to);
    activeChain_.setTip(&to);
    appliedBlockCount = activeChain_.blocksCount();
  }

removeLeaf()

template<typename Block >

void altintegration::BaseBlockTree< Block >::removeLeaf ( index_t &  toRemove )

inline

Definition at line 243 of file base_block_tree.hpp.

                                     {
    auto nondeletedDescendantCount = toRemove.nondeletedDescendantCount();
 
    VBK_ASSERT_MSG(nondeletedDescendantCount == 0,
                   "not a leaf block %s, has %d non-deleted descendants",
                   toRemove.toPrettyString(),
                   nondeletedDescendantCount);
    return this->removeSubtree(toRemove);
  }

removeSubtree() [1/2]

template<typename Block >

void altintegration::BaseBlockTree< Block >::removeSubtree ( const hash_t &  toRemove )

inline

Invariant

block must exist in a tree

Definition at line 235 of file base_block_tree.hpp.

                                             {
    auto* index = getBlockIndex(toRemove);
    VBK_ASSERT_MSG(
        index, "cannot find the subtree to remove: %s", HexStr(toRemove));
    return this->removeSubtree(*index);
  }

removeSubtree() [2/2]

template<typename Block >

void altintegration::BaseBlockTree< Block >::removeSubtree ( index_t &  toRemove )

inline

Parameters

toRemove

block to be removed.

Warning

fails on assert if unknown hash is provided

Definition at line 200 of file base_block_tree.hpp.

                                        {
    VBK_TRACE_ZONE_SCOPED;
    VBK_LOG_DEBUG("remove subtree %s", toRemove.toPrettyString());
 
    VBK_ASSERT_MSG(!toRemove.isRoot(), "cannot remove the root block");
    // save the pointer to the previous block
    auto* prev = toRemove.pprev;
 
    bool isOnMainChain = activeChain_.contains(&toRemove);
    if (isOnMainChain) {
      ValidationState dummy;
      bool success = this->setState(*prev, dummy);
      VBK_ASSERT_MSG(success, "err: %s", dummy.toString());
    }
 
    forEachNodePostorder<block_t>(
        toRemove,
        [&](index_t& next) {
          onBeforeLeafRemoved(next);
          tips_.erase(&next);
          VBK_ASSERT(!next.isDeleted());
          next.deleteTemporarily();
        },
        [&](index_t& next) { return !next.isDeleted(); });
 
    // after removal, try to add tip
    tryAddTip(prev);
 
    if (isOnMainChain) {
      updateTips();
    }
  }

revalidateSubtree() [1/2]

template<typename Block >

void altintegration::BaseBlockTree< Block >::revalidateSubtree ( const hash_t &  hash, enum BlockValidityStatus  reason, bool  shouldDetermineBestChain = true  )

inline

Definition at line 328 of file base_block_tree.hpp.

                                                               {
    auto* index = this->getBlockIndex(hash);
    VBK_ASSERT(index && "cannot find the subtree to revalidate");
    revalidateSubtree(*index, reason, shouldDetermineBestChain);
  }

revalidateSubtree() [2/2]

template<typename Block >

void altintegration::BaseBlockTree< Block >::revalidateSubtree ( index_t &  toBeValidated, enum BlockValidityStatus  reason, bool  shouldDetermineBestChain = true  )

inline

Definition at line 340 of file base_block_tree.hpp.

                                                               {
    VBK_TRACE_ZONE_SCOPED;
    VBK_LOG_DEBUG("Revalidating %s subtree: reason=%d block=%s",
                  block_t::name(),
                  (int)reason,
                  toBeValidated.toShortPrettyString());
 
    VBK_ASSERT_MSG(!toBeValidated.isRoot(), "cannot revalidate the root block");
 
    VBK_ASSERT_MSG(isValidInvalidationReason(reason),
                   "invalid revalidation reason");
 
    if (!toBeValidated.hasFlags(reason)) {
      return;
    }
 
    // if the block has any invalidity flags other than `reason`, its
    // descendants are already flagged as BLOCK_FAILED_CHILD and should stay so
    if (toBeValidated.hasFlags(static_cast<enum BlockValidityStatus>(
            BLOCK_FAILED_MASK & ~reason))) {
      doReValidate(toBeValidated, reason);
      return;
    }
 
    doReValidate(toBeValidated, reason);
 
    for (auto* pnext : toBeValidated.pnext) {
      forEachNodePreorder<block_t>(*pnext, [&](index_t& index) -> bool {
        doReValidate(index, BLOCK_FAILED_CHILD);
        bool failed = index.isFailed();
        return !failed;
      });
    }
 
    if (shouldDetermineBestChain) {
      updateTips();
    }
  }

setState() [1/2]

template<typename Block >

virtual bool altintegration::BaseBlockTree< Block >::setState ( const hash_t &  block, ValidationState &  state  )

inlinevirtual

Definition at line 401 of file base_block_tree.hpp.

                                                                     {
    auto* index = getBlockIndex(block);
    if (index == nullptr) {
      return state.Invalid(block_t::name() + "-setstate-unknown-block",
                           "could not find the block to set the state to");
    }
    return setState(*index, state);
  }

setState() [2/2]

template<typename Block >

virtual bool altintegration::BaseBlockTree< Block >::setState ( index_t &  index, ValidationState &    )

inlinevirtual

Reimplemented in altintegration::AltBlockTree.

Definition at line 410 of file base_block_tree.hpp.

                                                          {
    VBK_TRACE_ZONE_SCOPED;
    overrideTip(index);
    return true;
  }

toPrettyString()

template<typename Block >

std::string altintegration::BaseBlockTree< Block >::toPrettyString ( size_t  level = 0 ) const

inlineprotected

Definition at line 742 of file base_block_tree.hpp.

                                                   {
    auto tip = activeChain_.tip();
    std::string pad(level, ' ');
 
    std::string blocksStr{};
    // sort blocks by height
    std::vector<std::pair<int, index_t*>> byheight;
    byheight.reserve(blocks_.size());
    for (const auto& p : blocks_) {
      // FIXME: ugly hack due to trees being compared via toPrettyString in
      // tests
      if (!p.second->isDeleted()) {
        byheight.emplace_back(p.second->getHeight(), p.second.get());
      }
    }
    std::sort(byheight.rbegin(), byheight.rend());
    for (const auto& p : byheight) {
      blocksStr += (p.second->toPrettyString(level + 2) + "\n");
    }
 
    std::string tipsStr{};
    for (const auto* _tip : tips_) {
      tipsStr += (_tip->toPrettyString(level + 2) + "\n");
    }
 
    return format("{}{{tip={}}}\n{}{{blocks=\n{}{}}}\n{}{{tips=\n{}{}}}",
                  pad,
                  (tip ? tip->toPrettyString() : "<empty>"),
                  pad,
                  blocksStr,
                  pad,
                  pad,
                  tipsStr,
                  pad);
  }

Member Data Documentation

activeChain_

template<typename Block >

Chain<index_t> altintegration::BaseBlockTree< Block >::activeChain_

protected

Definition at line 1158 of file base_block_tree.hpp.

blockProvider_

template<typename Block >

const BlockReader& altintegration::BaseBlockTree< Block >::blockProvider_

protected

Definition at line 1167 of file base_block_tree.hpp.

blocks_

template<typename Block >

block_index_t altintegration::BaseBlockTree< Block >::blocks_

protected

Definition at line 1154 of file base_block_tree.hpp.

finalizedPayloadsIndex_

template<typename Block >

FinalizedPayloadsIndex<index_t> altintegration::BaseBlockTree< Block >::finalizedPayloadsIndex_

protected

For BTC tree does nothing. stores payloads only from finalized blocks.

Definition at line 1162 of file base_block_tree.hpp.

isLoaded_

template<typename Block >

bool altintegration::BaseBlockTree< Block >::isLoaded_ = false

protected

Definition at line 1152 of file base_block_tree.hpp.

isLoadingBlocks_

template<typename Block >

bool altintegration::BaseBlockTree< Block >::isLoadingBlocks_ = false

protected

Definition at line 1150 of file base_block_tree.hpp.

onBeforeOverrideTip

template<typename Block >

signals::Signal<void(const index_t& index)> altintegration::BaseBlockTree< Block >::onBeforeOverrideTip

Definition at line 1146 of file base_block_tree.hpp.

onBlockBeforeDeallocated

template<typename Block >

signals::Signal<void(const index_t&)> altintegration::BaseBlockTree< Block >::onBlockBeforeDeallocated

Definition at line 1142 of file base_block_tree.hpp.

onBlockValidityChanged

template<typename Block >

signals::Signal<on_invalidate_t> altintegration::BaseBlockTree< Block >::onBlockValidityChanged

Definition at line 1144 of file base_block_tree.hpp.

payloadsIndex_

template<typename Block >

PayloadsIndex<index_t> altintegration::BaseBlockTree< Block >::payloadsIndex_

protected

For BTC tree does nothing.

Definition at line 1165 of file base_block_tree.hpp.

tips_

template<typename Block >

std::unordered_set<index_t*> altintegration::BaseBlockTree< Block >::tips_

protected

Definition at line 1156 of file base_block_tree.hpp.

---

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

• include/veriblock/pop/blockchain/base_block_tree.hpp