RCLValidations.h

#ifndef XRPL_APP_CONSENSUSS_VALIDATIONS_H_INCLUDED
#define XRPL_APP_CONSENSUSS_VALIDATIONS_H_INCLUDED
 
#include <xrpld/app/ledger/Ledger.h>
#include <xrpld/consensus/Validations.h>
 
#include <xrpl/protocol/Protocol.h>
#include <xrpl/protocol/RippleLedgerHash.h>
#include <xrpl/protocol/STValidation.h>
 
#include <optional>
#include <vector>
 
namespace ripple {
 
class Application;
 
enum class BypassAccept : bool { no = false, yes };
 
class RCLValidation
{
    std::shared_ptr<STValidation> val_;
 
public:
    using NodeKey = ripple::PublicKey;
    using NodeID = ripple::NodeID;
 
    RCLValidation(std::shared_ptr<STValidation> const& v) : val_{v}
    {
    }
 
    uint256
    ledgerID() const
    {
        return val_->getLedgerHash();
    }
 
    std::uint32_t
    seq() const
    {
        return val_->getFieldU32(sfLedgerSequence);
    }
 
    NetClock::time_point
    signTime() const
    {
        return val_->getSignTime();
    }
 
    NetClock::time_point
    seenTime() const
    {
        return val_->getSeenTime();
    }
 
    PublicKey
    key() const
    {
        return val_->getSignerPublic();
    }
 
    NodeID
    nodeID() const
    {
        return val_->getNodeID();
    }
 
    bool
    trusted() const
    {
        return val_->isTrusted();
    }
 
    void
    setTrusted()
    {
        val_->setTrusted();
    }
 
    void
    setUntrusted()
    {
        val_->setUntrusted();
    }
 
    bool
    full() const
    {
        return val_->isFull();
    }
 
    std::optional<std::uint32_t>
    loadFee() const
    {
        return ~(*val_)[~sfLoadFee];
    }
 
    std::uint64_t
    cookie() const
    {
        return (*val_)[sfCookie];
    }
 
    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);
 
    Seq
    seq() const;
 
    ID
    id() const;
 
    ID
    operator[](Seq const& s) const;
 
    friend Seq
    mismatch(RCLValidatedLedger const& a, RCLValidatedLedger const& b);
 
    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);
 
    NetClock::time_point
    now() const;
 
    std::optional<RCLValidatedLedger>
    acquire(LedgerHash const& id);
 
    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 ripple
 
#endif