VaultInvariant.h

#pragma once
 
#include <xrpl/basics/Number.h>
#include <xrpl/basics/base_uint.h>
#include <xrpl/beast/utility/Journal.h>
#include <xrpl/beast/utility/Zero.h>
#include <xrpl/ledger/ReadView.h>
#include <xrpl/protocol/AccountID.h>
#include <xrpl/protocol/Asset.h>
#include <xrpl/protocol/MPTIssue.h>
#include <xrpl/protocol/Rules.h>
#include <xrpl/protocol/STLedgerEntry.h>
#include <xrpl/protocol/STTx.h>
#include <xrpl/protocol/TER.h>
#include <xrpl/protocol/XRPAmount.h>
 
#include <cstdint>
#include <optional>
#include <unordered_map>
#include <vector>
 
namespace xrpl {

class ValidVault
{
    static constexpr Number kZero{};
 
    struct Vault final
    {
        UInt256 key = beast::kZero;
        Asset asset;
        AccountID pseudoId;
        AccountID owner;
        UInt192 shareMPTID = beast::kZero;
        Number assetsTotal = 0;
        Number assetsAvailable = 0;
        Number assetsMaximum = 0;
        Number lossUnrealized = 0;
        std::optional<std::uint8_t> vaultKind;
        std::optional<std::uint32_t> subscriptionDate;
        std::optional<std::uint32_t> redemptionDate;
 
        Vault static make(SLE const&);
    };
 
    struct Shares final
    {
        MPTIssue share;
        std::uint64_t sharesTotal = 0;
        std::uint64_t sharesMaximum = 0;
 
        Shares static make(SLE const&);
    };
 
public:
    struct DeltaInfo final
    {
        Number delta = kNumZero;
        std::optional<int> scale;
 
        // Compute the delta between two Numbers, taking the coarsest scale
        [[nodiscard]] static DeltaInfo
        makeDelta(Number const& before, Number const& after, Asset const& asset);
    };
 
private:
    std::vector<Vault> afterVault_;
    std::vector<Shares> afterMPTs_;
    std::vector<Vault> beforeVault_;
    std::vector<Shares> beforeMPTs_;
    std::unordered_map<UInt256, DeltaInfo> deltas_;

    [[nodiscard]] std::int32_t
    computeVaultMinScale(DeltaInfo const& vaultDelta, Rules const& rules) const;

    [[nodiscard]] std::optional<DeltaInfo>
    deltaAssets(AccountID const& id) const;

    [[nodiscard]] static std::optional<AccountID>
    feePayerAccountRoot(ReadView const& view, STTx const& tx);

    [[nodiscard]] std::optional<DeltaInfo>
    deltaAssetsForParty(
        ReadView const& view,
        AccountID const& id,
        STTx const& tx,
        XRPAmount fee,
        bool fix340Enabled) const;

    [[nodiscard]] std::optional<DeltaInfo>
    deltaShares(AccountID const& id) const;

    [[nodiscard]] static bool
    isVaultEmpty(Vault const& vault);

    [[nodiscard]] bool
    finalizeLoanSet(ReadView const& view, beast::Journal const& j) const;
 
public:
    // Compute the coarsest scale required to represent all numbers
    [[nodiscard]] static std::int32_t
    computeCoarsestScale(std::vector<DeltaInfo> const& numbers);
 
    void
    visitEntry(bool, SLE::ConstRef, SLE::ConstRef);
 
    bool
    finalize(STTx const&, TER const, XRPAmount const, ReadView const&, beast::Journal const&);
};
 
}  // namespace xrpl