blockchain_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 ALT_INTEGRATION_INCLUDE_VERIBLOCK_BLOCKCHAIN_BLOCKCHAIN_UTIL_HPP_
#define ALT_INTEGRATION_INCLUDE_VERIBLOCK_BLOCKCHAIN_BLOCKCHAIN_UTIL_HPP_
 
#include <veriblock/pop/validation_state.hpp>
 
#include "block_index.hpp"
#include "chain.hpp"
#include "command_group.hpp"
 
namespace altintegration {
 
template <typename Block>
void determineBestChain(Chain<Block>& currentBest, BlockIndex<Block>& indexNew);
 
template <typename Block, typename ChainParams>
uint32_t getNextWorkRequired(const BlockIndex<Block>& prevBlock,
                             const Block& block,
                             const ChainParams& params);
 
template <typename Block>
ArithUint256 getBlockProof(const Block& block);
 
template <typename Block>
int64_t getMedianTimePast(const BlockIndex<Block>& prev);
 
template <typename Block, typename ChainParams>
bool checkBlockTime(const BlockIndex<Block>& prev,
                    const Block& block,
                    ValidationState& state,
                    const ChainParams& param);
 
template <typename Block, typename ChainParams>
bool contextuallyCheckBlock(const BlockIndex<Block>& prev,
                            const Block& block,
                            ValidationState& state,
                            const ChainParams& params,
                            bool shouldVerifyNextWork = true);
 
template <typename ProtectedBlockTree>
bool recoverEndorsements(ProtectedBlockTree& ed_,
                         typename ProtectedBlockTree::index_t& toRecover,
                         Chain<typename ProtectedBlockTree::index_t>& chain,
                         ValidationState& state) {
  std::vector<std::function<void()>> actions;
  auto& containingEndorsements = toRecover.getContainingEndorsements();
  actions.reserve(containingEndorsements.size());
  auto& ing = ed_.getComparator().getProtectingBlockTree();
 
  for (const auto& p : containingEndorsements) {
    auto& id = p.first;
    auto& e = *p.second;
 
    if (id != e.id) {
      return state.Invalid("bad-id",
                           format("Key={}, Id={}", HexStr(id), HexStr(e.id)));
    }
 
    auto* endorsed = ed_.getBlockIndex(e.endorsedHash);
    if (endorsed == nullptr) {
      return state.Invalid(
          "no-endorsed",
          format("Can not find endorsed block in {}", e.toPrettyString()));
    }
 
    if (chain[endorsed->getHeight()] == nullptr ||
        chain[endorsed->getHeight()]->getHash() != e.endorsedHash ||
        endorsed->getHash() != e.endorsedHash) {
      return state.Invalid(
          "bad-endorsed",
          format("Endorsed block does not match {}", e.toPrettyString()));
    }
 
    if (e.containingHash != toRecover.getHash()) {
      return state.Invalid(
          "bad-containing",
          format("Containing block does not match {}", e.toPrettyString()));
    }
 
    auto* blockOfProof = as_mut(ing).getBlockIndex(e.blockOfProof);
    // TODO: disable validation for testing
    if (blockOfProof == nullptr) {
      return state.Invalid(
          "bad-blockofproof",
          format("Block Of Proof {} does not exist in SP chain",
                 HexStr(e.blockOfProof)));
    }
 
    // make sure it is accessible in lambda
    const auto* endorsement = &e;
 
    // delay execution. this ensures atomic changes - if any of endorsemens fail
    // validation, no 'action' is actually executed.
    actions.push_back([endorsed, blockOfProof, endorsement] {
      auto& by = endorsed->getEndorsedBy();
      VBK_ASSERT_MSG(std::find(by.begin(), by.end(), endorsement) == by.end(),
                     "same endorsement is added to endorsedBy second time");
      bool isDirty = endorsed->isDirty();
      endorsed->insertEndorsedBy(endorsement);
      // keep dirty flag since recoverEndorsements is used when loading blocks
      // from storage and should not affect dirtyness of the blocks
      if (!isDirty) {
        endorsed->unsetDirty();
      }
 
      const auto& bop = blockOfProof->getBlockOfProofEndorsement();
      VBK_ASSERT_MSG(
          std::find(bop.begin(), bop.end(), endorsement) == bop.end(),
          "same endorsement is added to blockOfProof second time");
      isDirty = blockOfProof->isDirty();
      blockOfProof->insertBlockOfProofEndorsement(endorsement);
      // keep dirty flag
      if (!isDirty) {
        blockOfProof->unsetDirty();
      }
    });
  }
 
  // all actions have been validated
  // commit changes
  for (auto& f : actions) {
    f();
  }
 
  return true;
}
 
template <typename ProtectedBlockTree>
void recoverEndorsementsFast(ProtectedBlockTree& ed_,
                             typename ProtectedBlockTree::index_t& toRecover) {
  std::vector<std::function<void()>> actions;
  auto& containingEndorsements = toRecover.getContainingEndorsements();
  actions.reserve(containingEndorsements.size());
  auto& ing = ed_.getComparator().getProtectingBlockTree();
 
  for (const auto& p : containingEndorsements) {
    auto& e = *p.second;
 
    auto* endorsed = ed_.getBlockIndex(e.endorsedHash);
    auto* blockOfProof = as_mut(ing).getBlockIndex(e.blockOfProof);
 
    // make sure it is accessible in lambda
    const auto* endorsement = &e;
 
    // delay execution. this ensures atomic changes - if any of endorsemens fail
    // validation, no 'action' is actually executed.
    actions.push_back([endorsed, blockOfProof, endorsement] {
      auto& by = endorsed->getEndorsedBy();
      VBK_ASSERT_MSG(std::find(by.begin(), by.end(), endorsement) == by.end(),
                     "same endorsement is added to endorsedBy second time");
      bool isDirty = endorsed->isDirty();
      endorsed->insertEndorsedBy(endorsement);
      // keep dirty flag since recoverEndorsements is used when loading blocks
      // from storage and should not affect dirtyness of the blocks
      if (!isDirty) {
        endorsed->unsetDirty();
      }
 
      const auto& bop = blockOfProof->getBlockOfProofEndorsement();
      VBK_ASSERT_MSG(
          std::find(bop.begin(), bop.end(), endorsement) == bop.end(),
          "same endorsement is added to blockOfProof second time");
      isDirty = blockOfProof->isDirty();
      blockOfProof->insertBlockOfProofEndorsement(endorsement);
      // keep dirty flag
      if (!isDirty) {
        blockOfProof->unsetDirty();
      }
    });
  }
 
  // all actions have been validated
  // commit changes
  for (auto& f : actions) {
    f();
  }
}
 
template <typename Block>
void assertBlockCanBeRemoved(const Block& block);
 
template <typename Block>
void assertBlockSanity(const Block& block) {
  VBK_ASSERT_MSG(block.getHash() != block.getPreviousBlock(),
                 "Previous block hash should NOT be equal to the current block "
                 "hash: %s. A collision in altchain hash?",
                 HexStr(block.getHash()));
}
 
template <typename Tree, typename Pop>
void payloadToCommands(Tree& tree,
                       const Pop& pop,
                       const std::vector<uint8_t>& containingHash,
                       std::vector<CommandPtr>& cmds);
 
struct PopData;
 
template <typename Tree, typename Payload>
void payloadToCommandGroup(Tree& tree,
                           const Payload& payload,
                           const std::vector<uint8_t>& containingHash,
                           CommandGroup& cg) {
  // NOTE: disabled to remove the overhead of querying the unimplemented
  // validity map; uncomment if implemented
 
  // cg.valid = tree.getPayloadsIndex().getValidity(containingHash, cg.id);
 
  cg.payload_type_name = &Payload::name();
  cg.id = payload.getId().asVector();
 
  payloadToCommands(tree, payload, containingHash, cg.commands);
}
 
template <typename Tree, typename PayloadsT>
std::vector<CommandGroup> payloadsToCommandGroups(
    Tree& tree,
    const PayloadsT& pop,
    const std::vector<uint8_t>& containinghash);
 
template <typename Tree, typename Pop>
void vectorPopToCommandGroup(Tree& tree,
                             const std::vector<Pop>& pop,
                             const std::vector<uint8_t>& containingHash,
                             std::vector<CommandGroup>& cgs) {
  for (const auto& b : pop) {
    CommandGroup cg;
    cg.payload_type_name = &Pop::name();
    cg.id = b.getId().asVector();
    payloadToCommands(tree, b, containingHash, cg.commands);
 
    cgs.push_back(std::move(cg));
  }
}
 
template <typename BlockTree>
bool areOnSameChain(const typename BlockTree::block_t& blk1,
                    const typename BlockTree::block_t& blk2,
                    const BlockTree& tree) {
  auto* blk_index1 = tree.getBlockIndex(blk1.getHash());
  auto* blk_index2 = tree.getBlockIndex(blk2.getHash());
 
  VBK_ASSERT_MSG(blk_index1, "unknown block %s", blk1.toPrettyString());
  VBK_ASSERT_MSG(blk_index2, "unknown block %s", blk2.toPrettyString());
 
  if (blk_index1->getHeight() > blk_index2->getHeight()) {
    return blk_index1->getAncestor(blk_index2->getHeight()) == blk_index2;
  } else {
    return blk_index2->getAncestor(blk_index1->getHeight()) == blk_index1;
  }
}
 
}  // namespace altintegration
 
#endif  // ALT_INTEGRATION_INCLUDE_VERIBLOCK_BLOCKCHAIN_BLOCKCHAIN_UTIL_HPP_