RCLValidations.h

#pragma once
 
#include <xrpl/basics/base_uint.h>
#include <xrpl/basics/chrono.h>
#include <xrpl/beast/utility/Journal.h>
#include <xrpl/consensus/Validations.h>
#include <xrpl/ledger/Ledger.h>
#include <xrpl/protocol/Protocol.h>
#include <xrpl/protocol/PublicKey.h>
#include <xrpl/protocol/RippleLedgerHash.h>
#include <xrpl/protocol/SField.h>
#include <xrpl/protocol/STValidation.h>
#include <xrpl/protocol/UintTypes.h>
 
#include <cstdint>
#include <memory>
#include <mutex>
#include <optional>
#include <string>
#include <utility>
#include <vector>
 
namespace xrpl {
 
class Application;
 
enum class BypassAccept : bool { No = false, Yes };

class RCLValidation
{
    std::shared_ptr<STValidation> val_;
 
public:
    using NodeKey = xrpl::PublicKey;
    using NodeID = xrpl::NodeID;

    RCLValidation(std::shared_ptr<STValidation> v) : val_{std::move(v)}
    {
    }

    [[nodiscard]] uint256
    ledgerID() const
    {
        return val_->getLedgerHash();
    }

    [[nodiscard]] std::uint32_t
    seq() const
    {
        return val_->getFieldU32(sfLedgerSequence);
    }

    [[nodiscard]] NetClock::time_point
    signTime() const
    {
        return val_->getSignTime();
    }

    [[nodiscard]] NetClock::time_point
    seenTime() const
    {
        return val_->getSeenTime();
    }

    [[nodiscard]] PublicKey
    key() const
    {
        return val_->getSignerPublic();
    }

    [[nodiscard]] NodeID
    nodeID() const
    {
        return val_->getNodeID();
    }

    [[nodiscard]] bool
    trusted() const
    {
        return val_->isTrusted();
    }
 
    void
    setTrusted()
    {
        val_->setTrusted();
    }
 
    void
    setUntrusted()
    {
        val_->setUntrusted();
    }

    [[nodiscard]] bool
    full() const
    {
        return val_->isFull();
    }

    [[nodiscard]] std::optional<std::uint32_t>
    loadFee() const
    {
        return ~(*val_)[~sfLoadFee];
    }

    [[nodiscard]] std::uint64_t
    cookie() const
    {
        return (*val_)[sfCookie];
    }

    [[nodiscard]] std::shared_ptr<STValidation>
    unwrap() const
    {
        return val_;
    }
};

class RCLValidatedLedger
{
public:
    using ID = LedgerHash;
    using Seq = LedgerIndex;
    struct MakeGenesis
    {
        explicit MakeGenesis() = default;
    };
 
    RCLValidatedLedger(MakeGenesis);
 
    RCLValidatedLedger(std::shared_ptr<Ledger const> const& ledger, beast::Journal j);

    [[nodiscard]] Seq
    seq() const;

    [[nodiscard]] ID
    id() const;

    ID
    operator[](Seq const& s) const;

    friend Seq
    mismatch(RCLValidatedLedger const& a, RCLValidatedLedger const& b);
 
    [[nodiscard]] Seq
    minSeq() const;
 
private:
    ID ledgerID_;
    Seq ledgerSeq_;
    std::vector<uint256> ancestors_;
    beast::Journal j_;
};

class RCLValidationsAdaptor
{
public:
    // Type definitions for generic Validation
    using Mutex = std::mutex;
    using Validation = RCLValidation;
    using Ledger = RCLValidatedLedger;
 
    RCLValidationsAdaptor(Application& app, beast::Journal j);

    [[nodiscard]] NetClock::time_point
    now() const;

    std::optional<RCLValidatedLedger>
    acquire(LedgerHash const& id);
 
    [[nodiscard]] beast::Journal
    journal() const
    {
        return j_;
    }
 
private:
    Application& app_;
    beast::Journal j_;
};

using RCLValidations = Validations<RCLValidationsAdaptor>;

void
handleNewValidation(
    Application& app,
    std::shared_ptr<STValidation> const& val,
    std::string const& source,
    BypassAccept const bypassAccept = BypassAccept::No,
    std::optional<beast::Journal> j = std::nullopt);
 
}  // namespace xrpl