vbk_block_tree.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_VBK_BLOCK_TREE_HPP_
#define ALT_INTEGRATION_INCLUDE_VERIBLOCK_BLOCKCHAIN_VBK_BLOCK_TREE_HPP_
 
#include <unordered_map>
#include <utility>
 
#include "veriblock/pop/blockchain/blocktree.hpp"
#include "veriblock/pop/blockchain/commands/vbk_command_group_store.hpp"
#include "veriblock/pop/blockchain/pop/fork_resolution.hpp"
#include "veriblock/pop/blockchain/pop/pop_state_machine.hpp"
#include "veriblock/pop/blockchain/vbk_block_addon.hpp"
#include "veriblock/pop/blockchain/vbk_chain_params.hpp"
#include "veriblock/pop/entities/btcblock.hpp"
#include "veriblock/pop/finalizer.hpp"
#include "veriblock/pop/storage/block_reader.hpp"
 
namespace altintegration {
 
template <>
inline void BaseBlockTree<BtcBlock>::decreaseAppliedBlockCount(size_t) {
  // do nothing
  // BTC tree is not protected
}
 
// defined in vbk_block_tree.cpp
extern template struct BlockIndex<BtcBlock>;
extern template struct BlockTree<BtcBlock, BtcChainParams>;
extern template struct BaseBlockTree<BtcBlock>;
extern template struct BlockIndex<VbkBlock>;
extern template struct BlockTree<VbkBlock, VbkChainParams>;
extern template struct BaseBlockTree<VbkBlock>;
 
using BtcBlockTree = BlockTree<BtcBlock, BtcChainParams>;
 
struct VbkBlockTree : public BlockTree<VbkBlock, VbkChainParams> {
  using VbkTree = BlockTree<VbkBlock, VbkChainParams>;
  using BtcTree = BtcBlockTree;
  using index_t = VbkTree::index_t;
  using stored_index_t = VbkTree::stored_index_t;
  using payloads_t = typename index_t::payloads_t;
  using pid_t = typename payloads_t::id_t;
  using endorsement_t = typename index_t::endorsement_t;
  using command_group_store_t = VbkCommandGroupStore;
  using PopForkComparator = PopAwareForkResolutionComparator<VbkBlock,
                                                             VbkChainParams,
                                                             BtcTree,
                                                             VbkBlockTree>;
 
  ~VbkBlockTree() override = default;
 
  VbkBlockTree(const VbkChainParams& vbkp,
               const BtcChainParams& btcp,
               PayloadsStorage& payloadsProvider,
               BlockReader& blockProvider);
 
  bool loadBlockForward(const stored_index_t& index,
                        bool fast_load,
                        ValidationState& state) override;
 
  BtcTree& btc() { return cmp_.getProtectingBlockTree(); }
  const BtcTree& btc() const { return cmp_.getProtectingBlockTree(); }
 
  PopForkComparator& getComparator() { return cmp_; }
  const PopForkComparator& getComparator() const { return cmp_; }
  VbkCommandGroupStore& getCommandGroupStore() { return commandGroupStore_; }
  const VbkCommandGroupStore& getCommandGroupStore() const {
    return commandGroupStore_;
  }
 
  bool loadTip(const hash_t& hash, ValidationState& state) override;
 
  // Calculates an approximate amount of missed PopTxs in provided VbkBlock index
  uint32_t estimateMissedNumberOfVTBs(const index_t& index) const;
 
  bool addPayloads(const VbkBlock::hash_t& hash,
                   const std::vector<payloads_t>& payloads,
                   ValidationState& state);
 
  void removePayloads(const hash_t& hash, const std::vector<pid_t>& pids);
  void removePayloads(index_t& index, const std::vector<pid_t>& pids);
 
  void unsafelyRemovePayload(const Blob<24>& hash, const pid_t& pid);
  void unsafelyRemovePayload(index_t& index,
                             const pid_t& pid,
                             bool shouldDetermineBestChain = true);
 
  std::string toPrettyString(size_t level = 0) const;
 
  using base::setState;
  bool setState(index_t& to, ValidationState& state) override;
 
  void overrideTip(index_t& to) override;
 
  void finalizeBlocks();
 
 private:
  bool loadBlockInner(const stored_index_t& index,
                      bool fast_load,
                      ValidationState& state);
 
  bool validateBTCContext(const payloads_t& vtb, ValidationState& state);
  bool addPayloadToAppliedBlock(index_t& index,
                                const payloads_t& payload,
                                ValidationState& state);
 
  void determineBestChain(index_t& candidate, ValidationState& state) override;
 
  PopForkComparator cmp_;
  PayloadsStorage& payloadsProvider_;
  command_group_store_t commandGroupStore_;
};
 
template <>
void assertBlockCanBeRemoved(const BlockIndex<BtcBlock>& index);
template <>
void assertBlockCanBeRemoved(const BlockIndex<VbkBlock>& index);
 
template <>
void assertBlockSanity(const VbkBlock& block);
 
template <>
std::vector<CommandGroup> payloadsToCommandGroups(
    VbkBlockTree& tree,
    const std::vector<VTB>& pop,
    const std::vector<uint8_t>& containinghash);
 
template <>
void payloadToCommands(VbkBlockTree& tree,
                       const VTB& pop,
                       const std::vector<uint8_t>& containingHash,
                       std::vector<CommandPtr>& cmds);
 
template <typename JsonValue>
JsonValue ToJSON(const BlockIndex<VbkBlock>& i) {
  auto obj = json::makeEmptyObject<JsonValue>();
  json::putStringKV(obj, "chainWork", i.chainWork.toHex());
 
  std::vector<uint256> endorsements;
  for (const auto& e : i.getContainingEndorsements()) {
    endorsements.push_back(e.first);
  }
  json::putArrayKV(obj, "containingEndorsements", endorsements);
 
  std::vector<uint256> endorsedBy;
  for (const auto* e : i.getEndorsedBy()) {
    endorsedBy.push_back(e->id);
  }
  json::putArrayKV(obj, "endorsedBy", endorsedBy);
  json::putIntKV(obj, "height", i.getHeight());
  json::putKV(obj, "header", ToJSON<JsonValue>(i.getHeader()));
  json::putIntKV(obj, "status", i.getStatus());
  json::putIntKV(obj, "altrefs", i.refCount());
 
  auto stored = json::makeEmptyObject<JsonValue>();
  json::putArrayKV(stored, "vtbids", i.getPayloadIds<VTB>());
  json::putKV(obj, "stored", stored);
 
  auto bopEndorsements = json::makeEmptyArray<JsonValue>();
  for (const auto* e : i.getBlockOfProofEndorsement()) {
    if (e == nullptr) {
      continue;
    }
    json::arrayPushBack(bopEndorsements, ToJSON<JsonValue>(e->getId()));
  }
  json::putKV(obj, "blockOfProofEndorsements", bopEndorsements);
 
  return obj;
}
 
template <typename JsonValue>
JsonValue ToJSON(const BlockIndex<BtcBlock>& i) {
  auto obj = json::makeEmptyObject<JsonValue>();
  json::putStringKV(obj, "chainWork", i.chainWork.toHex());
  json::putIntKV(obj, "height", i.getHeight());
  json::putKV(obj, "header", ToJSON<JsonValue>(i.getHeader()));
  json::putIntKV(obj, "status", i.getStatus());
  json::putArrayKV(obj, "vbkrefs", i.getRefs());
 
  auto bopEndorsements = json::makeEmptyArray<JsonValue>();
  for (const auto* e : i.getBlockOfProofEndorsement()) {
    if (e == nullptr) {
      continue;
    }
    json::arrayPushBack(bopEndorsements, ToJSON<JsonValue>(e->getId()));
  }
  json::putKV(obj, "blockOfProofEndorsements", bopEndorsements);
 
  return obj;
}
 
template <>
template <>
inline BaseBlockTree<VbkBlock>::prev_block_hash_t
BaseBlockTree<VbkBlock>::makePrevHash<BaseBlockTree<VbkBlock>::hash_t>(
    const hash_t& h) const {
  // do an explicit cast from hash_t -> prev_block_hash_t
  return h.template trimLE<prev_block_hash_t::size()>();
}
 
inline void PrintTo(const VbkBlockTree& tree, std::ostream* os) {
  *os << tree.toPrettyString();
}
 
}  // namespace altintegration
 
#endif  // ALT_INTEGRATION_INCLUDE_VERIBLOCK_BLOCKCHAIN_VBK_BLOCK_TREE_HPP_