NetworkOPs.h

#pragma once
 
#include <xrpl/basics/base_uint.h>
#include <xrpl/beast/clock/abstract_clock.h>
#include <xrpl/core/ServiceRegistry.h>
#include <xrpl/json/json_value.h>
#include <xrpl/protocol/AccountID.h>
#include <xrpl/protocol/Book.h>
#include <xrpl/protocol/STValidation.h>
#include <xrpl/protocol/TER.h>
#include <xrpl/server/InfoSub.h>
 
#include <boost/asio.hpp>
 
#include <chrono>
#include <cstddef>
#include <cstdint>
#include <memory>
#include <optional>
#include <sstream>
#include <string>
 
namespace xrpl {
 
// Operations that clients may wish to perform against the network
// Master operational handler, server sequencer, network tracker
 
class Peer;
class STTx;
class ReadView;
class LedgerMaster;
class Transaction;
class ValidatorKeys;
class CanonicalTXSet;
class RCLCxPeerPos;
class SHAMap;
 
// This is the primary interface into the "client" portion of the program.
// Code that wants to do normal operations on the network such as
// creating and monitoring accounts, creating transactions, and so on
// should use this interface. The RPC code will primarily be a light wrapper
// over this code.
//
// Eventually, it will check the node's operating mode (synced, unsynced,
// etcetera) and defer to the correct means of processing. The current
// code assumes this node is synced (and will continue to do so until
// there's a functional network.
//

enum class OperatingMode {
    DISCONNECTED = 0,  
    CONNECTED = 1,     
    SYNCING = 2,       
    TRACKING = 3,      
    FULL = 4           
};

class NetworkOPs : public InfoSub::Source
{
public:
    using clock_type = beast::AbstractClock<std::chrono::steady_clock>;
 
    enum class FailHard : unsigned char { No, Yes };
    static FailHard
    doFailHard(bool noMeansDont)
    {
        return noMeansDont ? FailHard::Yes : FailHard::No;
    }
 
public:
    ~NetworkOPs() override = default;
 
    virtual void
    stop() = 0;
 
    //--------------------------------------------------------------------------
    //
    // Network information
    //
 
    [[nodiscard]] virtual OperatingMode
    getOperatingMode() const = 0;
    [[nodiscard]] virtual std::string
    strOperatingMode(OperatingMode const mode, bool const admin = false) const = 0;
    [[nodiscard]] virtual std::string
    strOperatingMode(bool const admin = false) const = 0;
 
    //--------------------------------------------------------------------------
    //
    // Transaction processing
    //
 
    // must complete immediately
    virtual void
    submitTransaction(std::shared_ptr<STTx const> const&) = 0;

    virtual void
    processTransaction(
        std::shared_ptr<Transaction>& transaction,
        bool bUnlimited,
        bool bLocal,
        FailHard failType) = 0;

    virtual void
    processTransactionSet(CanonicalTXSet const& set) = 0;
 
    //--------------------------------------------------------------------------
    //
    // Owner functions
    //
 
    virtual json::Value
    getOwnerInfo(std::shared_ptr<ReadView const> lpLedger, AccountID const& account) = 0;
 
    //--------------------------------------------------------------------------
    //
    // Book functions
    //
 
    virtual void
    getBookPage(
        std::shared_ptr<ReadView const>& lpLedger,
        Book const& book,
        AccountID const& uTakerID,
        bool const bProof,
        unsigned int iLimit,
        json::Value const& jvMarker,
        json::Value& jvResult) = 0;
 
    //--------------------------------------------------------------------------
 
    // ledger proposal/close functions
    virtual bool
    processTrustedProposal(RCLCxPeerPos peerPos) = 0;
 
    virtual bool
    recvValidation(std::shared_ptr<STValidation> const& val, std::string const& source) = 0;
 
    virtual void
    mapComplete(std::shared_ptr<SHAMap> const& map, bool fromAcquire) = 0;
 
    // network state machine
    virtual bool
    beginConsensus(uint256 const& netLCL, std::unique_ptr<std::stringstream> const& clog) = 0;
    virtual void
    endConsensus(std::unique_ptr<std::stringstream> const& clog) = 0;
    virtual void
    setStandAlone() = 0;
    virtual void
    setStateTimer() = 0;
 
    virtual void
    setNeedNetworkLedger() = 0;
    virtual void
    clearNeedNetworkLedger() = 0;
    virtual bool
    isNeedNetworkLedger() = 0;
    virtual bool
    isFull() = 0;
    virtual void
    setMode(OperatingMode om) = 0;
    virtual bool
    isBlocked() = 0;
    virtual bool
    isAmendmentBlocked() = 0;
    virtual void
    setAmendmentBlocked() = 0;
    virtual bool
    isAmendmentWarned() = 0;
    virtual void
    setAmendmentWarned() = 0;
    virtual void
    clearAmendmentWarned() = 0;
    virtual bool
    isUNLBlocked() = 0;
    virtual void
    setUNLBlocked() = 0;
    virtual void
    clearUNLBlocked() = 0;
    virtual void
    consensusViewChange() = 0;
 
    virtual json::Value
    getConsensusInfo() = 0;
    virtual json::Value
    getServerInfo(bool human, bool admin, bool counters) = 0;
    virtual void
    clearLedgerFetch() = 0;
    virtual json::Value
    getLedgerFetchInfo() = 0;

    virtual std::uint32_t
    acceptLedger(std::optional<std::chrono::milliseconds> consensusDelay = std::nullopt) = 0;
 
    virtual void
    reportFeeChange() = 0;
 
    virtual void
    updateLocalTx(ReadView const& newValidLedger) = 0;
    virtual std::size_t
    getLocalTxCount() = 0;
 
    //--------------------------------------------------------------------------
    //
    // Monitoring: publisher side
    //
    virtual void
    pubLedger(std::shared_ptr<ReadView const> const& lpAccepted) = 0;
    virtual void
    pubProposedTransaction(
        std::shared_ptr<ReadView const> const& ledger,
        std::shared_ptr<STTx const> const& transaction,
        TER result) = 0;
    virtual void
    pubValidation(std::shared_ptr<STValidation> const& val) = 0;
 
    virtual void
    stateAccounting(json::Value& obj) = 0;

    virtual std::size_t
    getBookSubscribersCount() = 0;
};
 
}  // namespace xrpl