util.hpp

// Copyright (c) 2019-2022 Xenios SEZC
// https://www.veriblock.org
// Distributed under the MIT software license, see the accompanying
// file LICENSE or http://www.opensource.org/licenses/mit-license.php.
 
#ifndef VERIBLOCK_POP_CPP_STORAGE_UTIL_HPP
#define VERIBLOCK_POP_CPP_STORAGE_UTIL_HPP
 
#include <vector>
#include <veriblock/pop/blockchain/alt_block_tree.hpp>
#include <veriblock/pop/logger.hpp>
#include <veriblock/pop/storage/block_reader.hpp>
#include <veriblock/pop/validation_state.hpp>
 
#include "block_batch.hpp"
 
namespace altintegration {
 
template <typename BlockTreeT>
bool loadTree(BlockTreeT& tree,
              const typename BlockTreeT::hash_t& tiphash,
              std::vector<typename BlockTreeT::stored_index_t>& blocks,
              bool fast_load,
              ValidationState& state) {
  using stored_index_t = typename BlockTreeT::stored_index_t;
 
  if (blocks.size() == 0) return true;
 
  VBK_LOG_INFO("Loading %d %s blocks with tip %s",
               blocks.size(),
               BlockTreeT::block_t::name(),
               HexStr(tiphash));
  VBK_ASSERT(tree.isBootstrapped() && "tree must be bootstrapped");
 
  // first, sort them by height
  std::sort(blocks.begin(),
            blocks.end(),
            [](const stored_index_t& a, const stored_index_t& b) {
              return a.height < b.height;
            });
 
  for (const auto& block : blocks) {
    // load blocks one by one
    if (!tree.loadBlockForward(block, fast_load, state)) {
      return state.Invalid("load-tree");
    }
  }
 
  if (!tree.loadTip(tiphash, state)) {
    return state.Invalid("load-tree");
  }
 
  auto* t = tree.getBestChain().tip();
  VBK_ASSERT(t != nullptr);
 
  return true;
}
 
template <typename BlockIndexT>
void validateBlockIndex(const BlockIndexT&);
 
template <typename BlockTreeT>
void saveTree(
    BlockTreeT& tree,
    BlockBatch& batch,
    std::function<void(const typename BlockTreeT::index_t&)> validator) {
  using index_t = typename BlockTreeT::index_t;
  std::vector<const index_t*> dirty_indices;
 
  // map pair<hash, shared_ptr<index_t>> to vector<index_t*>
  for (auto& index : tree.getAllBlocks()) {
    if (index->isDirty()) {
      index->unsetDirty();
      dirty_indices.push_back(index);
    }
  }
 
  // sort by height in descending order, because we need to calculate index hash
  // during saving. this is needed to be progpow-cache friendly, as cache will
  // be warm for last blocks.
  std::sort(dirty_indices.begin(),
            dirty_indices.end(),
            [](const index_t* a, const index_t* b) {
              return b->getHeight() < a->getHeight();
            });
 
  // write indices
  for (const index_t* index : dirty_indices) {
    validator(*index);
    batch.writeBlock(index->getHash(),
                     tree.makePrevHash(index->getHash()),
                     index->toStoredBlockIndex());
  }
 
  batch.writeTip(tree.getBestChain().tip()->getHash());
}
 
template <typename BlockTreeT>
void saveTree(BlockTreeT& tree, BlockBatch& batch) {
  saveTree(tree, batch, &validateBlockIndex<typename BlockTreeT::index_t>);
}
 
struct AltBlockTree;
 
void saveTrees(const AltBlockTree& tree, BlockBatch& batch);
 
bool loadTrees(AltBlockTree& tree, bool fast_load, ValidationState& state);
 
}  // namespace altintegration
 
#endif  // VERIBLOCK_POP_CPP_STORAGE_UTIL_HPP