cached_tree.hpp

Go to the documentation of this file.

#ifndef KAGOME_BLOCKCHAIN_TREE_NODE_HPP
#define KAGOME_BLOCKCHAIN_TREE_NODE_HPP

#include <memory>
#include <unordered_set>

#include "consensus/babe/common.hpp"
#include "consensus/babe/types/epoch_digest.hpp"
#include "primitives/block_id.hpp"
#include "primitives/justification.hpp"

namespace kagome::blockchain {

  class TreeNode : public std::enable_shared_from_this<TreeNode> {
   public:
    enum class Error { NO_CHAIN_BETWEEN_BLOCKS = 1 };

    TreeNode(const primitives::BlockHash &hash,
             primitives::BlockNumber depth,
             bool finalized = false);

    TreeNode(const primitives::BlockHash &hash,
             primitives::BlockNumber depth,
             const std::shared_ptr<TreeNode> &parent,
             bool finalized = false);

    primitives::BlockHash block_hash;
    primitives::BlockNumber depth;
    std::weak_ptr<TreeNode> parent;
    bool finalized;

    std::vector<std::shared_ptr<TreeNode>> children{};

    std::shared_ptr<const TreeNode> findByHash(
        const primitives::BlockHash &hash) const;

    std::shared_ptr<TreeNode> findByHash(const primitives::BlockHash &hash) {
      return std::const_pointer_cast<TreeNode>(
          std::as_const(*this).findByHash(hash));
    }

    enum class ExitToken { EXIT, CONTINUE };

    outcome::result<void> applyToChain(
        const primitives::BlockInfo &chain_end,
        std::function<outcome::result<ExitToken>(TreeNode const &node)> const
            &op) const;

    primitives::BlockInfo getBlockInfo() const {
      return {depth, block_hash};
    }

    bool operator==(const TreeNode &other) const;
    bool operator!=(const TreeNode &other) const;
  };

  struct TreeMeta {
    explicit TreeMeta(
        const std::shared_ptr<TreeNode> &subtree_root_node,
        std::optional<primitives::Justification> last_finalized_justification);

    TreeMeta(std::unordered_set<primitives::BlockHash> leaves,
             const std::shared_ptr<TreeNode> &deepest_leaf,
             const std::shared_ptr<TreeNode> &last_finalized,
             primitives::Justification last_finalized_justification);

    std::unordered_set<primitives::BlockHash> leaves;
    std::weak_ptr<TreeNode> deepest_leaf;

    std::weak_ptr<TreeNode> last_finalized;
    std::optional<primitives::Justification> last_finalized_justification;
  };

  class CachedTree {
   public:
    explicit CachedTree(std::shared_ptr<TreeNode> root,
                        std::shared_ptr<TreeMeta> metadata)
        : root_{std::move(root)}, metadata_{std::move(metadata)} {
      BOOST_ASSERT(root_ != nullptr);
      BOOST_ASSERT(metadata_ != nullptr);
    }
    void updateTreeRoot(std::shared_ptr<TreeNode> new_trie_root,
                        primitives::Justification justification);

    void updateMeta(const std::shared_ptr<TreeNode> &new_node);

    void removeFromMeta(const std::shared_ptr<TreeNode> &node);

    TreeNode const &getRoot() const;
    TreeNode &getRoot();

    TreeMeta const &getMetadata() const;

   private:
    std::shared_ptr<TreeNode> root_;
    std::shared_ptr<TreeMeta> metadata_;
  };
}  // namespace kagome::blockchain

OUTCOME_HPP_DECLARE_ERROR(kagome::blockchain, TreeNode::Error);

#endif  // KAGOME_BLOCKCHAIN_TREE_NODE_HPP