include/xrpl/ledger/Ledger.h

#pragma once
 
#include <xrpl/basics/CountedObject.h>
#include <xrpl/basics/UnorderedContainers.h>
#include <xrpl/basics/base_uint.h>
#include <xrpl/basics/chrono.h>
#include <xrpl/beast/utility/Journal.h>
#include <xrpl/ledger/CachedView.h>
#include <xrpl/ledger/RawView.h>
#include <xrpl/protocol/Fees.h>
#include <xrpl/protocol/Keylet.h>
#include <xrpl/protocol/LedgerHeader.h>
#include <xrpl/protocol/PublicKey.h>
#include <xrpl/protocol/Rules.h>
#include <xrpl/protocol/STLedgerEntry.h>
#include <xrpl/protocol/STObject.h>
#include <xrpl/protocol/STTx.h>
#include <xrpl/protocol/Serializer.h>
#include <xrpl/protocol/XRPAmount.h>
#include <xrpl/shamap/Family.h>
#include <xrpl/shamap/SHAMap.h>
#include <xrpl/shamap/SHAMapItem.h>
 
#include <cstdint>
#include <memory>
#include <mutex>
#include <optional>
#include <utility>
#include <vector>
 
namespace xrpl {
 
class ServiceRegistry;
class Job;
class TransactionMaster;
 
class SqliteStatement;
 
struct CreateGenesisT
{
    explicit CreateGenesisT() = default;
};
extern CreateGenesisT const kCreateGenesis;

class Ledger final : public std::enable_shared_from_this<Ledger>,
                     public DigestAwareReadView,
                     public TxsRawView,
                     public CountedObject<Ledger>
{
public:
    Ledger(Ledger const&) = delete;
    Ledger&
    operator=(Ledger const&) = delete;
 
    Ledger(Ledger&&) = delete;
    Ledger&
    operator=(Ledger&&) = delete;

    Ledger(
        CreateGenesisT,
        Rules rules,
        Fees const& fees,
        std::vector<uint256> const& amendments,
        Family& family);
 
    Ledger(LedgerHeader const& info, Rules rules, Family& family);

    Ledger(
        LedgerHeader const& info,
        bool& loaded,
        bool acquire,
        Rules rules,
        Fees const& fees,
        Family& family,
        beast::Journal j);

    Ledger(Ledger const& previous, NetClock::time_point closeTime);
 
    // used for database ledgers
    Ledger(
        std::uint32_t ledgerSeq,
        NetClock::time_point closeTime,
        Rules rules,
        Fees const& fees,
        Family& family);
 
    ~Ledger() override = default;
 
    //
    // ReadView
    //
 
    bool
    open() const override
    {
        return false;
    }
 
    LedgerHeader const&
    header() const override
    {
        return header_;
    }
 
    void
    setLedgerInfo(LedgerHeader const& info)
    {
        header_ = info;
    }
 
    Fees const&
    fees() const override
    {
        return fees_;
    }
 
    Rules const&
    rules() const override
    {
        return rules_;
    }
 
    bool
    exists(Keylet const& k) const override;
 
    bool
    exists(uint256 const& key) const;
 
    std::optional<uint256>
    succ(uint256 const& key, std::optional<uint256> const& last = std::nullopt) const override;
 
    SLE::const_pointer
    read(Keylet const& k) const override;
 
    std::unique_ptr<SlesType::iter_base>
    slesBegin() const override;
 
    std::unique_ptr<SlesType::iter_base>
    slesEnd() const override;
 
    std::unique_ptr<SlesType::iter_base>
    slesUpperBound(uint256 const& key) const override;
 
    std::unique_ptr<TxsType::iter_base>
    txsBegin() const override;
 
    std::unique_ptr<TxsType::iter_base>
    txsEnd() const override;
 
    bool
    txExists(uint256 const& key) const override;
 
    tx_type
    txRead(key_type const& key) const override;
 
    //
    // DigestAwareReadView
    //
 
    std::optional<digest_type>
    digest(key_type const& key) const override;
 
    //
    // RawView
    //
 
    void
    rawErase(SLE::ref sle) override;
 
    void
    rawInsert(SLE::ref sle) override;
 
    void
    rawErase(uint256 const& key);
 
    void
    rawReplace(SLE::ref sle) override;
 
    void
    rawDestroyXRP(XRPAmount const& fee) override
    {
        header_.drops -= fee;
    }
 
    //
    // TxsRawView
    //
 
    void
    rawTxInsert(
        uint256 const& key,
        std::shared_ptr<Serializer const> const& txn,
        std::shared_ptr<Serializer const> const& metaData) override;
 
    //--------------------------------------------------------------------------
 
    void
    setValidated() const
    {
        header_.validated = true;
    }
 
    void
    setAccepted(
        NetClock::time_point closeTime,
        NetClock::duration closeResolution,
        bool correctCloseTime);
 
    void
    setImmutable(bool rehash = true);
 
    bool
    isImmutable() const
    {
        return immutable_;
    }
 
    /*  Mark this ledger as "should be full".
 
        "Full" is metadata property of the ledger, it indicates
        that the local server wants all the corresponding nodes
        in durable storage.
 
        This is marked `const` because it reflects metadata
        and not data that is in common with other nodes on the
        network.
    */
    void
    setFull() const
    {
        txMap_.setFull();
        txMap_.setLedgerSeq(header_.seq);
        stateMap_.setFull();
        stateMap_.setLedgerSeq(header_.seq);
    }
 
    void
    setTotalDrops(std::uint64_t totDrops)
    {
        header_.drops = totDrops;
    }
 
    SHAMap const&
    stateMap() const
    {
        return stateMap_;
    }
 
    SHAMap&
    stateMap()
    {
        return stateMap_;
    }
 
    SHAMap const&
    txMap() const
    {
        return txMap_;
    }
 
    SHAMap&
    txMap()
    {
        return txMap_;
    }
 
    // returns false on error
    bool
    addSLE(SLE const& sle);
 
    //--------------------------------------------------------------------------
 
    void
    updateSkipList();
 
    bool
    walkLedger(beast::Journal j, bool parallel = false) const;
 
    bool
    isSensible() const;
 
    void
    invariants() const;
    void
    unshare() const;

    hash_set<PublicKey>
    negativeUNL() const;

    std::optional<PublicKey>
    validatorToDisable() const;

    std::optional<PublicKey>
    validatorToReEnable() const;

    void
    updateNegativeUNL();

    bool
    isFlagLedger() const;

    bool
    isVotingLedger() const;
 
    SLE::pointer
    peek(Keylet const& k) const;
 
private:
    class SlesIterImpl;
    class TxsIterImpl;
 
    bool
    setup();

    static std::shared_ptr<STTx const>
    deserializeTx(SHAMapItem const& item);

    static std::pair<std::shared_ptr<STTx const>, std::shared_ptr<STObject const>>
    deserializeTxPlusMeta(SHAMapItem const& item);
 
    bool immutable_;
 
    // A SHAMap containing the transactions associated with this ledger.
    SHAMap mutable txMap_;
 
    // A SHAMap containing the state objects for this ledger.
    SHAMap mutable stateMap_;
 
    // Protects fee variables
    std::mutex mutable mutex_;
 
    Fees fees_;
    Rules rules_;
    LedgerHeader header_;
    beast::Journal j_;
};

using CachedLedger = CachedView<Ledger>;
 
}  // namespace xrpl