ledgers.h

#pragma once
 
#include <xrpl/basics/chrono.h>
#include <xrpl/basics/tagged_integer.h>
#include <xrpl/json/json_value.h>
#include <xrpl/ledger/LedgerTiming.h>
 
#include <boost/bimap/bimap.hpp>
 
#include <csf/Tx.h>
 
#include <cassert>
#include <cstddef>
#include <cstdint>
#include <functional>
#include <optional>
#include <set>
#include <string>
#include <tuple>
#include <unordered_map>
#include <vector>
 
namespace xrpl::test::csf {

class Ledger
{
    friend class LedgerOracle;
 
public:
    struct SeqTag;
    using Seq = TaggedInteger<std::uint32_t, SeqTag>;
 
    struct IdTag;
    using ID = TaggedInteger<std::uint32_t, IdTag>;
 
    struct MakeGenesis
    {
    };
 
private:
    // The instance is the common immutable data that will be assigned a unique
    // ID by the oracle
    struct Instance
    {
        Instance() = default;
 
        // Sequence number
        Seq seq{0};
 
        // Transactions added to generate this ledger
        TxSetType txs;
 
        // Resolution used to determine close time
        NetClock::duration closeTimeResolution = kLedgerDefaultTimeResolution;

        NetClock::time_point closeTime;

        bool closeTimeAgree = true;

        ID parentID{0};

        NetClock::time_point parentCloseTime;

        std::vector<Ledger::ID> ancestors;
 
        [[nodiscard]] auto
        asTie() const
        {
            return std::tie(
                seq,
                txs,
                closeTimeResolution,
                closeTime,
                closeTimeAgree,
                parentID,
                parentCloseTime);
        }
 
        friend bool
        operator==(Instance const& a, Instance const& b)
        {
            return a.asTie() == b.asTie();
        }
 
        friend bool
        operator!=(Instance const& a, Instance const& b)
        {
            return a.asTie() != b.asTie();
        }
 
        friend bool
        operator<(Instance const& a, Instance const& b)
        {
            return a.asTie() < b.asTie();
        }
 
        template <class Hasher>
        friend void
        hash_append(
            Hasher& h,
            Ledger::Instance const& instance)  // NOLINT(readability-identifier-naming)
        {
            using beast::hash_append;
            hash_append(h, instance.asTie());
        }
    };
 
    // Single common genesis instance
    static Instance const kGenesis;
 
    Ledger(ID id, Instance const* i) : id_{id}, instance_{i}
    {
    }
 
public:
    Ledger(MakeGenesis) : instance_(&kGenesis)
    {
    }
 
    // This is required by the generic Consensus for now and should be
    // migrated to the MakeGenesis approach above.
    Ledger() : Ledger(MakeGenesis{})
    {
    }
 
    [[nodiscard]] ID
    id() const
    {
        return id_;
    }
 
    [[nodiscard]] Seq
    seq() const
    {
        return instance_->seq;
    }
 
    [[nodiscard]] NetClock::duration
    closeTimeResolution() const
    {
        return instance_->closeTimeResolution;
    }
 
    [[nodiscard]] bool
    closeAgree() const
    {
        return instance_->closeTimeAgree;
    }
 
    [[nodiscard]] NetClock::time_point
    closeTime() const
    {
        return instance_->closeTime;
    }
 
    [[nodiscard]] NetClock::time_point
    parentCloseTime() const
    {
        return instance_->parentCloseTime;
    }
 
    [[nodiscard]] ID
    parentID() const
    {
        return instance_->parentID;
    }
 
    [[nodiscard]] TxSetType const&
    txs() const
    {
        return instance_->txs;
    }

    [[nodiscard]] bool
    isAncestor(Ledger const& ancestor) const;

    ID
    operator[](Seq seq) const;

    friend Ledger::Seq
    mismatch(Ledger const& a, Ledger const& o);
 
    [[nodiscard]] json::Value
    getJson() const;
 
    friend bool
    operator<(Ledger const& a, Ledger const& b)
    {
        return a.id() < b.id();
    }
 
private:
    ID id_{0};
    Instance const* instance_;
};

class LedgerOracle
{
    using InstanceMap = boost::bimaps::bimap<
        boost::bimaps::set_of<Ledger::Instance, std::less<>>,
        boost::bimaps::set_of<Ledger::ID, std::less<>>>;
    using InstanceEntry = InstanceMap::value_type;
 
    // Set of all known ledgers; note this is never pruned
    InstanceMap instances_;
 
    // ID for the next unique ledger
    [[nodiscard]] Ledger::ID
    nextID() const;
 
public:
    LedgerOracle();

    [[nodiscard]] std::optional<Ledger>
    lookup(Ledger::ID const& id) const;

    Ledger
    accept(
        Ledger const& curr,
        TxSetType const& txs,
        NetClock::duration closeTimeResolution,
        NetClock::time_point const& consensusCloseTime);
 
    Ledger
    accept(Ledger const& curr, Tx tx)
    {
        using namespace std::chrono_literals;
        return accept(curr, TxSetType{tx}, curr.closeTimeResolution(), curr.closeTime() + 1s);
    }

    static std::size_t
    branches(std::set<Ledger> const& ledgers);
};

struct LedgerHistoryHelper
{
    LedgerOracle oracle;
    Tx::ID nextTx{0};
    std::unordered_map<std::string, Ledger> ledgers;
    std::set<char> seen;
 
    LedgerHistoryHelper()
    {
        ledgers[""] = Ledger{Ledger::MakeGenesis{}};
    }

    Ledger const&
    operator[](std::string const& s)
    {
        auto it = ledgers.find(s);
        if (it != ledgers.end())
            return it->second;
 
        // enforce that the new suffix has never been seen
        assert(seen.emplace(s.back()).second);
 
        Ledger const& parent = (*this)[s.substr(0, s.size() - 1)];
        return ledgers.emplace(s, oracle.accept(parent, Tx{++nextTx})).first->second;
    }
};
 
}  // namespace xrpl::test::csf