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::vector<std::shared_ptr<SLE const>> deletedHoldings_;
 
public:
    void
    visitEntry(bool isDelete, SLE::const_ref before, SLE::const_ref 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
    hash_map<uint192, MPTData> data_;
 
public:
    void
    visitEntry(bool isDelete, SLE::const_ref before, SLE::const_ref 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;
        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}
    hash_map<uint192, hash_map<AccountID, Value>> amount_;
    // Deleted MPToken
    // MPToken key: true if MPTAuthorized is set
    hash_map<uint256, bool> deletedAuthorized_;
 
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