MPTInvariant.h

#pragma once
 
#include <xrpl/basics/UnorderedContainers.h>
#include <xrpl/basics/base_uint.h>
#include <xrpl/beast/utility/Journal.h>
#include <xrpl/ledger/ReadView.h>
#include <xrpl/protocol/AccountID.h>
#include <xrpl/protocol/STLedgerEntry.h>
#include <xrpl/protocol/STTx.h>
#include <xrpl/protocol/TER.h>
#include <xrpl/protocol/UintTypes.h>
#include <xrpl/protocol/XRPAmount.h>
 
#include <array>
#include <cstdint>
#include <map>
#include <memory>
#include <optional>
#include <vector>
 
namespace xrpl {
 
class ValidMPTIssuance
{
    std::uint32_t mptIssuancesCreated_ = 0;
    std::uint32_t mptIssuancesDeleted_ = 0;
 
    std::uint32_t mptokensCreated_ = 0;
    std::uint32_t mptokensDeleted_ = 0;
    // non-MPT transactions may attempt to create
    // MPToken by an issuer
    bool mptCreatedByIssuer_ = false;

    bool referenceHoldingSetOnCreate_ = false;

    bool referenceHoldingMutated_ = false;

    std::uint32_t issuanceFlagsCleared_ = 0;

    std::vector<std::shared_ptr<SLE const>> deletedHoldings_;
 
public:
    void
    visitEntry(bool isDelete, SLE::ConstRef before, SLE::ConstRef after);

    [[nodiscard]] bool
    finalize(
        STTx const& tx,
        TER const result,
        XRPAmount const fee,
        ReadView const& view,
        beast::Journal const& j) const;
};

class ValidMPTBalanceChanges
{
    enum class Order { Before = 0, After = 1 };
    struct MPTData
    {
        std::array<std::int64_t, 2> outstanding{};
        // sum (MPT after - MPT before)
        std::int64_t mptAmount{0};
    };
 
    // true if OutstandingAmount > MaximumAmount in after for any MPT
    bool overflow_{false};
    // mptid:MPTData
    HashMap<UInt192, MPTData> data_;
 
public:
    void
    visitEntry(bool isDelete, SLE::ConstRef before, SLE::ConstRef after);

    bool
    finalize(
        STTx const& tx,
        TER const result,
        XRPAmount const fee,
        ReadView const& view,
        beast::Journal const& j);
};

class ValidConfidentialMPToken
{
    struct Changes
    {
        std::int64_t mptAmountDelta = 0;
        std::int64_t coaDelta = 0;
        std::int64_t outstandingDelta = 0;
        SLE::const_pointer issuance;
        bool deletedWithEncrypted = false;
        // True when an erased MPToken had a non-zero pre-tx public balance.
        bool deletedWithBalanceBefore = false;
        bool badConsistency = false;
        bool badCOA = false;
        bool changesConfidentialFields = false;
        bool badVersion = false;
    };
    std::map<UInt192, Changes> changes_;
 
public:
    void
    visitEntry(
        bool isDelete,
        std::shared_ptr<SLE const> const& before,
        std::shared_ptr<SLE const> const& after);

    bool
    finalize(
        STTx const& tx,
        TER const result,
        XRPAmount const fee,
        ReadView const& view,
        beast::Journal const& j);
};
 
class ValidMPTTransfer
{
    struct Value
    {
        std::optional<std::uint64_t> amtBefore;
        std::optional<std::uint64_t> amtAfter;
    };
    // MPTID: {holder: Value}
    HashMap<UInt192, HashMap<AccountID, Value>> amount_;
    // Deleted MPToken
    // MPToken key: true if MPTAuthorized is set
    HashMap<UInt256, bool> deletedAuthorized_;
    // Every touched AccountRoot (not only pseudos):
    // AccountID -> whether it was a pseudo-account BEFORE this transaction
    // applied. Needed because a transaction may erase a pseudo-account and
    // move MPT out of it in the same transaction; by finalize() time the
    // view no longer shows it as a pseudo-account (or as existing at all).
    // False entries freeze the pre-tx classification for touched non-pseudos.
    HashMap<AccountID, bool> pseudoAccountsBefore_;
 
public:
    void
    visitEntry(
        bool isDelete,
        std::shared_ptr<SLE const> const& before,
        std::shared_ptr<SLE const> const& after);

    bool
    finalize(
        STTx const& tx,
        TER const result,
        XRPAmount const fee,
        ReadView const& view,
        beast::Journal const& j);
 
private:
    [[nodiscard]] bool
    isAuthorized(
        ReadView const& view,
        MPTID const& mptid,
        AccountID const& holder,
        bool requireAuth) const;
};
 
}  // namespace xrpl