alt_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_ALT_BLOCK_TREE_HPP_
#define ALT_INTEGRATION_INCLUDE_VERIBLOCK_BLOCKCHAIN_ALT_BLOCK_TREE_HPP_
 
#include <memory>
#include <set>
#include <string>
#include <unordered_map>
#include <vector>
#include <veriblock/pop/blockchain/commands/alt_command_group_store.hpp>
#include <veriblock/pop/entities/altblock.hpp>
#include <veriblock/pop/entities/btcblock.hpp>
#include <veriblock/pop/entities/popdata.hpp>
#include <veriblock/pop/entities/vbkblock.hpp>
#include <veriblock/pop/fmt.hpp>
#include <veriblock/pop/storage/block_reader.hpp>
#include <veriblock/pop/storage/payloads_provider.hpp>
#include <veriblock/pop/trace.hpp>
#include <veriblock/pop/validation_state.hpp>
 
#include "alt_chain_params.hpp"
#include "base_block_tree.hpp"
#include "chain.hpp"
#include "pop/fork_resolution.hpp"
#include "pop/vbk_block_tree.hpp"
namespace altintegration {
 
// defined in alt_block_tree.cpp
extern template struct BlockIndex<AltBlock>;
extern template struct BaseBlockTree<AltBlock>;
 
// clang-format off
 
// clang-format on
struct AltBlockTree : public BaseBlockTree<AltBlock> {
  using base = BaseBlockTree<AltBlock>;
  using alt_config_t = AltChainParams;
  using vbk_config_t = VbkChainParams;
  using btc_config_t = BtcChainParams;
  using index_t = base::index_t;
  using stored_index_t = base::stored_index_t;
  using endorsement_t = typename index_t::endorsement_t;
  using eid_t = typename endorsement_t::id_t;
  using hash_t = typename AltBlock::hash_t;
  using command_group_store_t = AltCommandGroupStore;
 
  using PopForkComparator = PopAwareForkResolutionComparator<AltBlock,
                                                             AltChainParams,
                                                             VbkBlockTree,
                                                             AltBlockTree>;
 
  ~AltBlockTree() override = default;
 
  explicit AltBlockTree(const alt_config_t& alt_config,
                        const vbk_config_t& vbk_config,
                        const btc_config_t& btc_config,
                        PayloadsStorage& payloadsProvider,
                        BlockReader& blockProvider);
 
  void bootstrap();
 
  VBK_CHECK_RETURN bool acceptBlockHeader(const AltBlock& block,
                                          ValidationState& state);
 
  void acceptBlock(const hash_t& block, const PopData& payloads);
  void acceptBlock(index_t& index,
                   const PopData& payloads,
                   ValidationState& state);
  void acceptBlock(index_t& index, const PopData& payloads);
 
  struct BlockPayloadMutator {
    using tree_t = AltBlockTree;
    using block_index_t = typename tree_t::index_t;
    using id_vector_t = std::vector<uint8_t>;
 
    BlockPayloadMutator(tree_t& tree,
                        block_index_t& block,
                        PayloadsIndex<block_index_t>& pl,
                        FinalizedPayloadsIndex<block_index_t>& fpl);
 
    bool isStatefulDuplicate(const id_vector_t& payload_id);
    bool isStatelessDuplicate(const id_vector_t& payload_id);
 
    template <typename Payload>
    bool add(const Payload& payload, ValidationState& state);
 
    block_index_t& getBlock() { return block_; }
 
   private:
    tree_t& tree_;
    block_index_t& block_;
    std::unordered_set<std::vector<uint8_t>> ids_;
    Chain<block_index_t> chain_;
    PayloadsIndex<block_index_t>& pl_;
    FinalizedPayloadsIndex<block_index_t>& fpl_;
  };
 
  BlockPayloadMutator makeConnectedLeafPayloadMutator(index_t& block);
 
  std::vector<const index_t*> getConnectedTipsAfter(const index_t& index) const;
 
  signals::Signal<void(index_t& index, ValidationState&)>
      onInvalidBlockConnected;
 
  signals::Signal<void(index_t& index)> onBlockConnected;
 
  VBK_CHECK_RETURN bool loadBlockForward(const stored_index_t& index,
                                         bool fast_load,
                                         ValidationState& state) override;
 
  VBK_CHECK_RETURN bool loadTip(const hash_t& hash,
                                ValidationState& state) override;
 
  VBK_CHECK_RETURN int comparePopScore(const AltBlock::hash_t& A,
                                       const AltBlock::hash_t& B);
 
  VBK_CHECK_RETURN bool setState(index_t& to, ValidationState& state) override;
  using base::setState;
 
  void finalizeBlocks();
 
  void removePayloads(const hash_t& hash);
 
  // clang-format off
  VbkBlockTree& vbk() { return cmp_.getProtectingBlockTree(); }
  const VbkBlockTree& vbk() const { return cmp_.getProtectingBlockTree(); }
  VbkBlockTree::BtcTree& btc() { return cmp_.getProtectingBlockTree().btc(); }
  const VbkBlockTree::BtcTree& btc() const { return cmp_.getProtectingBlockTree().btc(); }
  const PopForkComparator& getComparator() const { return cmp_; }
  const AltChainParams& getParams() const { return alt_config_; }
  PayloadsStorage& getPayloadsProvider()  { return payloadsProvider_; }
  const PayloadsStorage& getPayloadsProvider() const { return payloadsProvider_; }
  AltCommandGroupStore& getCommandGroupStore()  { return commandGroupStore_; }
  const AltCommandGroupStore& getCommandGroupStore() const { return commandGroupStore_; }
 
  // clang-format on
 
  std::string toPrettyString(size_t level = 0) const;
 
  void overrideTip(index_t& to) override;
 
  friend struct MemPoolBlockTree;
 
  using base::removeLeaf;
 
 private:
  const alt_config_t& alt_config_;
  PopForkComparator cmp_;
  PayloadsStorage& payloadsProvider_;
  command_group_store_t commandGroupStore_;
 
  bool loadBlockInner(const stored_index_t& index,
                      bool fast_load,
                      ValidationState& state);
 
  void determineBestChain(index_t& candidate, ValidationState& state) override;
 
  void onBeforeLeafRemoved(const index_t& block) override;
  void setPayloads(index_t& index, const PopData& payloads);
 
  bool connectBlock(index_t& index, ValidationState& state);
 
  void removeAllPayloads(index_t& index);
};
 
template <typename JsonValue>
JsonValue ToJSON(const BlockIndex<AltBlock>& i) {
  auto obj = json::makeEmptyObject<JsonValue>();
  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, "status", i.getStatus());
 
  auto stored = json::makeEmptyObject<JsonValue>();
  json::putArrayKV(stored, "vbkblocks", i.getPayloadIds<VbkBlock>());
  json::putArrayKV(stored, "vtbs", i.getPayloadIds<VTB>());
  json::putArrayKV(stored, "atvs", i.getPayloadIds<ATV>());
 
  json::putKV(obj, "stored", stored);
 
  return obj;
}
 
inline void PrintTo(const AltBlockTree& tree, std::ostream* os) {
  *os << tree.toPrettyString();
}
 
}  // namespace altintegration
 
#endif  // !