LedgerHistory.h

#pragma once
 
#include <xrpld/app/main/Application.h>
 
#include <xrpl/basics/base_uint.h>
#include <xrpl/beast/insight/Collector.h>
#include <xrpl/beast/insight/Counter.h>
#include <xrpl/beast/utility/Journal.h>
#include <xrpl/json/json_value.h>
#include <xrpl/ledger/Ledger.h>
#include <xrpl/protocol/Protocol.h>
#include <xrpl/protocol/RippleLedgerHash.h>
 
#include <map>
#include <memory>
#include <optional>
 
namespace xrpl {
 
// VFALCO TODO Rename to OldLedgers ?

class LedgerHistory
{
public:
    LedgerHistory(beast::insight::Collector::ptr const& collector, Application& app);

    bool
    insert(std::shared_ptr<Ledger const> const& ledger, bool validated);

    float
    getCacheHitRate()
    {
        return ledgersByHash_.getHitRate();
    }

    std::shared_ptr<Ledger const>
    getLedgerBySeq(LedgerIndex ledgerIndex);

    std::shared_ptr<Ledger const>
    getLedgerByHash(LedgerHash const& ledgerHash);

    LedgerHash
    getLedgerHash(LedgerIndex ledgerIndex);

    void
    sweep()
    {
        ledgersByHash_.sweep();
        consensusValidated_.sweep();
    }

    void
    builtLedger(std::shared_ptr<Ledger const> const&, uint256 const& consensusHash, json::Value);

    void
    validatedLedger(
        std::shared_ptr<Ledger const> const&,
        std::optional<uint256> const& consensusHash);

    bool
    fixIndex(LedgerIndex ledgerIndex, LedgerHash const& ledgerHash);
 
    void
    clearLedgerCachePrior(LedgerIndex seq);
 
private:
    void
    handleMismatch(
        LedgerHash const& built,
        LedgerHash const& valid,
        std::optional<uint256> const& builtConsensusHash,
        std::optional<uint256> const& validatedConsensusHash,
        json::Value const& consensus);
 
    Application& app_;
    beast::insight::Collector::ptr collector_;
    beast::insight::Counter mismatchCounter_;
 
    using LedgersByHash = TaggedCache<LedgerHash, Ledger const>;
 
    LedgersByHash ledgersByHash_;
 
    // Maps ledger indexes to the corresponding hashes
    // For debug and logging purposes
    struct CvEntry
    {
        // Hash of locally built ledger
        std::optional<LedgerHash> built;
        // Hash of the validated ledger
        std::optional<LedgerHash> validated;
        // Hash of locally accepted consensus transaction set
        std::optional<uint256> builtConsensusHash;
        // Hash of validated consensus transaction set
        std::optional<uint256> validatedConsensusHash;
        // Consensus metadata of built ledger
        std::optional<json::Value> consensus;
    };
    using ConsensusValidated = TaggedCache<LedgerIndex, CvEntry>;
    ConsensusValidated consensusValidated_;
 
    // Maps ledger indexes to the corresponding hash.
    std::map<LedgerIndex, LedgerHash> ledgersByIndex_;  // validated ledgers
 
    beast::Journal j_;
};
 
}  // namespace xrpl