Adds functionality to block vault deposits

include/xrpl/ledger/helpers/VaultHelpers.h

@@ -78,4 +78,17 @@ sharesToAssetsWithdraw(
     std::shared_ptr<SLE const> const& issuance,
     STAmount const& shares);
 
+/** Determine if a vault is insolvent. A vault is considered insolvent when
+    the total assets in the vault are zero, and outstanding shares are non-zero.
+
+    @param vault The vault SLE.
+    @param shareIssuance The MPTokenIssuance SLE for the vault's shares.
+
+    @return True if the vault is insolvent, false otherwise.
+*/
+[[nodiscard]] bool
+isVaultInsolvent(
+    std::shared_ptr<SLE const> const& vault,
+    std::shared_ptr<SLE const> const& shareIssuance);
+
 }  // namespace xrpl

include/xrpl/protocol/LedgerFormats.h

@@ -193,7 +193,9 @@ enum LedgerEntryType : std::uint16_t {
         LSF_FLAG(lsfAccepted, 0x00010000))                                                                                         \
                                                                                                                                    \
     LEDGER_OBJECT(Vault,                                                                                                           \
-        LSF_FLAG(lsfVaultPrivate, 0x00010000))                                                                                     \
+        LSF_FLAG(lsfVaultPrivate, 0x00010000)                                                                                      \
+        LSF_FLAG(lsfVaultDepositBlocked, 0x00020000)             /* True, vault deposit is blocked */                               \
+        LSF_FLAG(lsfVaultOwnerCanBlockDeposit, 0x00040000))      /* True, vault owner can block deposit */                                                                                     \
                                                                                                                                    \
     LEDGER_OBJECT(Loan,                                                                                                            \
         LSF_FLAG(lsfLoanDefault, 0x00010000)                                                                                       \

include/xrpl/protocol/TxFlags.h

@@ -183,7 +183,13 @@ inline constexpr FlagValue tfUniversalMask = ~tfUniversal;
                                                                                                                                                                \
     TRANSACTION(VaultCreate,                                                                                                                                   \
         TF_FLAG(tfVaultPrivate, lsfVaultPrivate)                                                                                                               \
-        TF_FLAG(tfVaultShareNonTransferable, 0x00020000),                                                                                                      \
+        TF_FLAG(tfVaultShareNonTransferable, 0x00020000)                                                                                                       \
+        TF_FLAG(tfVaultOwnerCanBlockDeposit, lsfVaultOwnerCanBlockDeposit),                                                                                    \
+        MASK_ADJ(0))                                                                                                                                           \
+                                                                                                                                                               \
+    TRANSACTION(VaultSet,                                                                                                                                      \
+        TF_FLAG(tfVaultDepositBlock, 0x00010000)                                                                                                               \
+        TF_FLAG(tfVaultDepositUnblock, 0x00020000),                                                                                                            \
         MASK_ADJ(0))                                                                                                                                           \
                                                                                                                                                                \
     TRANSACTION(Batch,                                                                                                                                         \
@@ -213,7 +219,6 @@ inline constexpr FlagValue tfUniversalMask = ~tfUniversal;
         TF_FLAG(tfLoanImpair, 0x00020000)                                                                                                                      \
         TF_FLAG(tfLoanUnimpair, 0x00040000),                                                                                                                   \
         MASK_ADJ(0))
-
 // clang-format on
 
 // Create all the flag values.

include/xrpl/tx/transactors/vault/VaultClawback.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <xrpl/ledger/helpers/VaultHelpers.h>
 #include <xrpl/tx/Transactor.h>
 
 namespace xrpl {

include/xrpl/tx/transactors/vault/VaultDeposit.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <xrpl/ledger/helpers/VaultHelpers.h>
 #include <xrpl/tx/Transactor.h>
 
 namespace xrpl {

include/xrpl/tx/transactors/vault/VaultSet.h

@@ -13,6 +13,9 @@ class VaultSet : public Transactor
     {
     }
 
+    static std::uint32_t
+    getFlagsMask(PreflightContext const& ctx);
+
     static bool
     checkExtraFeatures(PreflightContext const& ctx);
 

include/xrpl/tx/transactors/vault/VaultWithdraw.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <xrpl/ledger/helpers/VaultHelpers.h>
 #include <xrpl/tx/Transactor.h>
 
 namespace xrpl {

src/libxrpl/ledger/helpers/VaultHelpers.cpp

@@ -109,4 +109,20 @@ sharesToAssetsWithdraw(
     return assets;
 }
 
+[[nodiscard]] bool
+isVaultInsolvent(
+    std::shared_ptr<SLE const> const& vault,
+    std::shared_ptr<SLE const> const& shareIssuance)
+{
+    XRPL_ASSERT(vault && vault->getType() == ltVAULT, "xrpl::isVaultInsolvent : Vault sle");
+    XRPL_ASSERT(
+        shareIssuance && shareIssuance->getType() == ltMPTOKEN_ISSUANCE,
+        "xrpl::isVaultInsolvent : MPTokenIssuance sle");
+
+    auto const assetsTotal = vault->at(sfAssetsTotal);
+    auto const sharesOutstanding = shareIssuance->at(sfOutstandingAmount);
+
+    return assetsTotal == 0 && sharesOutstanding > 0;
+}
+
 }  // namespace xrpl

src/libxrpl/tx/transactors/vault/VaultClawback.cpp

@@ -1,4 +1,5 @@
-#include <xrpl/beast/utility/instrumentation.h>
+#include <xrpl/tx/transactors/vault/VaultClawback.h>
+//
 #include <xrpl/ledger/View.h>
 #include <xrpl/ledger/helpers/TokenHelpers.h>
 #include <xrpl/ledger/helpers/VaultHelpers.h>
@@ -10,7 +11,6 @@
 #include <xrpl/protocol/STTakesAsset.h>
 #include <xrpl/protocol/TER.h>
 #include <xrpl/protocol/TxFlags.h>
-#include <xrpl/tx/transactors/vault/VaultClawback.h>
 
 #include <optional>
 
@@ -51,9 +51,8 @@ clawbackAmount(
     if (maybeAmount)
         return *maybeAmount;
 
-    Asset const share = MPTIssue{vault->at(sfShareMPTID)};
     if (account == vault->at(sfOwner))
-        return STAmount{share};
+        return STAmount{MPTIssue{vault->at(sfShareMPTID)}};
 
     return STAmount{vault->at(sfAsset)};
 }

src/libxrpl/tx/transactors/vault/VaultCreate.cpp

@@ -1,3 +1,5 @@
+#include <xrpl/tx/transactors/vault/VaultCreate.h>
+//
 #include <xrpl/ledger/View.h>
 #include <xrpl/ledger/helpers/AccountRootHelpers.h>
 #include <xrpl/ledger/helpers/MPTokenHelpers.h>
@@ -15,7 +17,6 @@
 #include <xrpl/protocol/TxFlags.h>
 #include <xrpl/tx/transactors/token/MPTokenAuthorize.h>
 #include <xrpl/tx/transactors/token/MPTokenIssuanceCreate.h>
-#include <xrpl/tx/transactors/vault/VaultCreate.h>
 
 namespace xrpl {
 
@@ -34,7 +35,10 @@ VaultCreate::checkExtraFeatures(PreflightContext const& ctx)
 std::uint32_t
 VaultCreate::getFlagsMask(PreflightContext const& ctx)
 {
-    return tfVaultCreateMask;
+    if (ctx.rules.enabled(featureLendingProtocolV1_1))
+        return tfVaultCreateMask;
+
+    return tfVaultCreateMask | tfVaultOwnerCanBlockDeposit;
 }
 
 NotTEC
@@ -161,11 +165,11 @@ VaultCreate::doApply()
         ? 0
         : ctx_.tx[~sfScale].value_or(vaultDefaultIOUScale);
 
-    auto txFlags = tx.getFlags();
     std::uint32_t mptFlags = 0;
-    if ((txFlags & tfVaultShareNonTransferable) == 0)
+    if (!tx.isFlag(tfVaultShareNonTransferable))
         mptFlags |= (lsfMPTCanEscrow | lsfMPTCanTrade | lsfMPTCanTransfer);
-    if ((txFlags & tfVaultPrivate) != 0u)
+
+    if (tx.isFlag(tfVaultPrivate))
         mptFlags |= lsfMPTRequireAuth;
 
     // Note, here we are **not** creating an MPToken for the assets held in
@@ -189,7 +193,13 @@ VaultCreate::doApply()
     auto const& mptIssuanceID = *maybeShare;
 
     vault->setFieldIssue(sfAsset, STIssue{sfAsset, asset});
-    vault->at(sfFlags) = txFlags & tfVaultPrivate;
+    if (tx.isFlag(tfVaultPrivate))
+        vault->setFlag(lsfVaultPrivate);
+
+    if (view().rules().enabled(featureLendingProtocolV1_1) &&
+        tx.isFlag(tfVaultOwnerCanBlockDeposit))
+        vault->setFlag(lsfVaultOwnerCanBlockDeposit);
+
     vault->at(sfSequence) = sequence;
     vault->at(sfOwner) = account_;
     vault->at(sfAccount) = pseudoId;
@@ -222,7 +232,7 @@ VaultCreate::doApply()
         return err;
 
     // If the vault is private, set the authorized flag for the vault owner
-    if ((txFlags & tfVaultPrivate) != 0u)
+    if (vault->isFlag(lsfVaultPrivate))
     {
         if (auto const err = authorizeMPToken(
                 view(), preFeeBalance_, mptIssuanceID, pseudoId, ctx_.journal, {}, account_);

src/libxrpl/tx/transactors/vault/VaultDelete.cpp

@@ -1,3 +1,5 @@
+#include <xrpl/tx/transactors/vault/VaultDelete.h>
+//
 #include <xrpl/ledger/View.h>
 #include <xrpl/ledger/helpers/AccountRootHelpers.h>
 #include <xrpl/ledger/helpers/MPTokenHelpers.h>
@@ -8,7 +10,6 @@
 #include <xrpl/protocol/STTakesAsset.h>
 #include <xrpl/protocol/TER.h>
 #include <xrpl/protocol/TxFlags.h>
-#include <xrpl/tx/transactors/vault/VaultDelete.h>
 
 namespace xrpl {
 

src/libxrpl/tx/transactors/vault/VaultDeposit.cpp

@@ -1,3 +1,5 @@
+#include <xrpl/tx/transactors/vault/VaultDeposit.h>
+//
 #include <xrpl/ledger/View.h>
 #include <xrpl/ledger/helpers/CredentialHelpers.h>
 #include <xrpl/ledger/helpers/MPTokenHelpers.h>
@@ -13,7 +15,6 @@
 #include <xrpl/protocol/TER.h>
 #include <xrpl/protocol/TxFlags.h>
 #include <xrpl/tx/transactors/token/MPTokenAuthorize.h>
-#include <xrpl/tx/transactors/vault/VaultDeposit.h>
 
 namespace xrpl {
 
@@ -62,23 +63,41 @@ VaultDeposit::preclaim(PreclaimContext const& ctx)
         // LCOV_EXCL_STOP
     }
 
-    auto const sleIssuance = ctx.view.read(keylet::mptIssuance(mptIssuanceID));
-    if (!sleIssuance)
+    auto const sleShareIssuance = ctx.view.read(keylet::mptIssuance(mptIssuanceID));
+    if (!sleShareIssuance)
     {
         // LCOV_EXCL_START
         JLOG(ctx.j.error()) << "VaultDeposit: missing issuance of vault shares.";
         return tefINTERNAL;
         // LCOV_EXCL_STOP
     }
 
-    if (sleIssuance->isFlag(lsfMPTLocked))
+    if (sleShareIssuance->isFlag(lsfMPTLocked))
     {
         // LCOV_EXCL_START
         JLOG(ctx.j.error()) << "VaultDeposit: issuance of vault shares is locked.";
         return tefINTERNAL;
         // LCOV_EXCL_STOP
     }
 
+    if (ctx.view.rules().enabled(featureLendingProtocolV1_1))
+    {
+        // Perform these checks early to avoid unnecessary processing
+
+        // The Vault is insolvent, deposits are not allowed
+        if (isVaultInsolvent(vault, sleShareIssuance))
+        {
+            JLOG(ctx.j.debug()) << "VaultDeposit: Vault is insolvent, deposits are not allowed";
+            return tecLOCKED;
+        }
+
+        if (vault->isFlag(lsfVaultDepositBlocked))
+        {
+            JLOG(ctx.j.debug()) << "VaultDeposit: Vault deposits are blocked";
+            return tecNO_PERMISSION;
+        }
+    }
+
     // Cannot deposit inside Vault an Asset frozen for the depositor
     if (isFrozen(ctx.view, account, vaultAsset))
         return vaultAsset.holds<Issue>() ? tecFROZEN : tecLOCKED;
@@ -89,7 +108,7 @@ VaultDeposit::preclaim(PreclaimContext const& ctx)
 
     if (vault->isFlag(lsfVaultPrivate) && account != vault->at(sfOwner))
     {
-        auto const maybeDomainID = sleIssuance->at(~sfDomainID);
+        auto const maybeDomainID = sleShareIssuance->at(~sfDomainID);
         // Since this is a private vault and the account is not its owner, we
         // perform authorization check based on DomainID read from sleIssuance.
         // Had the vault shares been a regular MPToken, we would allow

src/libxrpl/tx/transactors/vault/VaultSet.cpp

@@ -17,6 +17,29 @@ VaultSet::checkExtraFeatures(PreflightContext const& ctx)
     return !ctx.tx.isFieldPresent(sfDomainID) || ctx.rules.enabled(featurePermissionedDomains);
 }
 
+std::uint32_t
+VaultSet::getFlagsMask(PreflightContext const& ctx)
+{
+    if (ctx.rules.enabled(featureLendingProtocolV1_1))
+        return tfVaultSetMask;
+
+    // Add tfVaultDepositBlock and tfVaultDepositUnblock flags to indicate they are disabled
+    return tfVaultSetMask | tfVaultDepositBlock | tfVaultDepositUnblock;
+}
+
+static bool
+isValidVaultUpdate(PreflightContext const& ctx)
+{
+    auto const atLeastOneFieldPresent = ctx.tx.isFieldPresent(sfDomainID) ||
+        ctx.tx.isFieldPresent(sfAssetsMaximum) || ctx.tx.isFieldPresent(sfData);
+
+    // Mask of valid, non-universal flags: any bit set here means the
+    // transaction is requesting a meaningful flag change.
+    auto const expectedFlags = ~(VaultSet::getFlagsMask(ctx) | tfUniversal);
+
+    return atLeastOneFieldPresent || (ctx.tx.getFlags() & expectedFlags);
+}
+
 NotTEC
 VaultSet::preflight(PreflightContext const& ctx)
 {
@@ -44,13 +67,19 @@ VaultSet::preflight(PreflightContext const& ctx)
         }
     }
 
-    if (!ctx.tx.isFieldPresent(sfDomainID) && !ctx.tx.isFieldPresent(sfAssetsMaximum) &&
-        !ctx.tx.isFieldPresent(sfData))
+    if (!isValidVaultUpdate(ctx))
     {
         JLOG(ctx.j.debug()) << "VaultSet: nothing is being updated.";
         return temMALFORMED;
     }
 
+    if (ctx.tx.isFlag(tfVaultDepositBlock) && ctx.tx.isFlag(tfVaultDepositUnblock))
+    {
+        JLOG(ctx.j.debug())
+            << "VaultSet: cannot set tfVaultDepositBlock and tfVaultDepositUnblock simultaneously.";
+        return temINVALID_FLAG;
+    }
+
     return tesSUCCESS;
 }
 
@@ -104,6 +133,29 @@ VaultSet::preclaim(PreclaimContext const& ctx)
         }
     }
 
+    if (ctx.view.rules().enabled(featureLendingProtocolV1_1))
+    {
+        // The Vault is not configured to support deposit blocking
+        if (!vault->isFlag(lsfVaultOwnerCanBlockDeposit) &&
+            (ctx.tx.isFlag(tfVaultDepositBlock) || ctx.tx.isFlag(tfVaultDepositUnblock)))
+        {
+            JLOG(ctx.j.debug()) << "VaultSet: vault does not support blocking deposits";
+            return tecNO_PERMISSION;
+        }
+
+        if (vault->isFlag(lsfVaultDepositBlocked) && ctx.tx.isFlag(tfVaultDepositBlock))
+        {
+            JLOG(ctx.j.debug()) << "VaultSet: vault deposit is already blocked";
+            return tecNO_PERMISSION;
+        }
+
+        if (!vault->isFlag(lsfVaultDepositBlocked) && ctx.tx.isFlag(tfVaultDepositUnblock))
+        {
+            JLOG(ctx.j.debug()) << "VaultSet: vault deposit is already unblocked";
+            return tecNO_PERMISSION;
+        }
+    }
+
     return tesSUCCESS;
 }
 
@@ -161,6 +213,15 @@ VaultSet::doApply()
         view().update(sleIssuance);
     }
 
+    if (view().rules().enabled(featureLendingProtocolV1_1))
+    {
+        if (tx.isFlag(tfVaultDepositBlock))
+            vault->setFlag(lsfVaultDepositBlocked);
+
+        if (tx.isFlag(tfVaultDepositUnblock))
+            vault->clearFlag(lsfVaultDepositBlocked);
+    }
+
     // Note, we must update Vault object even if only DomainID is being updated
     // in Issuance object. Otherwise it's really difficult for Vault invariants
     // to verify the operation.

src/libxrpl/tx/transactors/vault/VaultWithdraw.cpp

@@ -1,3 +1,5 @@
+#include <xrpl/tx/transactors/vault/VaultWithdraw.h>
+//
 #include <xrpl/ledger/View.h>
 #include <xrpl/ledger/helpers/CredentialHelpers.h>
 #include <xrpl/ledger/helpers/TokenHelpers.h>
@@ -9,7 +11,6 @@
 #include <xrpl/protocol/STTakesAsset.h>
 #include <xrpl/protocol/TER.h>
 #include <xrpl/protocol/TxFlags.h>
-#include <xrpl/tx/transactors/vault/VaultWithdraw.h>
 
 namespace xrpl {