Fix bugs: frozen pseudo-account, and FLC cutoff (#6170)

- Fixes LoanManage tfBAD_LEDGER case by capping the amount of FLC to use to cover a loss at the amount of cover available.
- Check if the Vault pseudo-account is frozen in LoanBrokerSet

Author: Tapanito

src/test/app/LoanBroker_test.cpp

@@ -1595,6 +1595,32 @@ class LoanBroker_test : public beast::unit_test::suite
         }
     }
 
+    void
+    testAMB06_VaultFreezeCheckMissing()
+    {
+        testcase << "RIPD-4466 - LoanBrokerSet disallows frozen vaults";
+        using namespace jtx;
+        Env env(*this);
+
+        Account const issuer{"issuer"}, lender{"lender"}, borrower{"borrower"};
+        env.fund(XRP(20'000), issuer, lender, borrower);
+        auto const IOU = issuer["IOU"];
+
+        Vault vault{env};
+        auto [tx, vaultKeylet] =
+            vault.create({.owner = lender, .asset = IOU.asset()});
+        env(tx);
+        env.close();
+
+        // Get vault pseudo-account and FREEZE it
+        auto const vaultSle = env.le(vaultKeylet);
+        auto const vaultPseudo = vaultSle->at(sfAccount);
+        auto const vaultPseudoAcct = Account("VaultPseudo", vaultPseudo);
+        env(trust(issuer, vaultPseudoAcct["IOU"](0), tfSetFreeze));
+
+        env(loanBroker::set(lender, vaultKeylet.key), ter(tecFROZEN));
+    }
+
 public:
     void
     run() override
@@ -1612,6 +1638,7 @@ class LoanBroker_test : public beast::unit_test::suite
         testRequireAuth();
 
         testRIPD4323();
+        testAMB06_VaultFreezeCheckMissing();
 
         // TODO: Write clawback failure tests with an issuer / MPT that doesn't
         // have the right flags set.

src/test/app/Loan_test.cpp

@@ -11,6 +11,8 @@
 #include <xrpl/beast/xor_shift_engine.h>
 #include <xrpl/protocol/SField.h>
 
+#include <chrono>
+
 namespace ripple {
 namespace test {
 
@@ -7486,6 +7488,125 @@ class Loan_test : public beast::unit_test::suite
         env.close();
     }
 
+    void
+    testSequentialFLCDepletion()
+    {
+        testcase << "First-Loss Capital Depletion on Sequential Defaults";
+
+        using namespace jtx;
+        using namespace loan;
+        using namespace loanBroker;
+
+        Env env(*this, all);
+
+        Account const issuer{"issuer"};
+        Account const lender{"lender"};
+        Account const borrowerA{"borrowerA"};
+        Account const borrowerB{"borrowerB"};
+
+        env.fund(XRP(1'000'000), issuer, lender, borrowerA, borrowerB);
+        env.close();
+
+        PrettyAsset const asset = xrpIssue();
+        auto const vaultDepositAmount =
+            asset(200'000);  // Enough for 2 x 50k loans plus interest/fees
+
+        auto const brokerInfo = createVaultAndBroker(
+            env,
+            asset,
+            lender,
+            {
+                .vaultDeposit = vaultDepositAmount.value(),
+                .debtMax = 0,
+                .coverRateMin = TenthBips32(20000),  // 20%
+                .coverDeposit = 21'000,
+                .managementFeeRate = TenthBips16(100),  // 0.1%
+                .coverRateLiquidation = TenthBips32(100000),
+            });
+        auto const brokerKeylet = brokerInfo.brokerKeylet();
+
+        // Create two identical loans: each 50,000 XRP principal (scaled down to
+        // avoid funding issues) Total DebtTotal will be ~100,000 XRP (principal
+        // + interest) Formula will calculate cover as: 100% × (20% × 100,000) =
+        // 20,000 XRP So we need FLC = 20,000 XRP to be fully consumed by first
+        // default
+        auto const principalAmount = Number(50'000);
+        auto const loanPaymentInterval = 2592000;  // 30 days
+        auto const loanGracePeriod = 604800;       // 7 days
+
+        // Create Loan A
+        auto loanATx = env.jt(
+            set(borrowerA, brokerKeylet.key, principalAmount),
+            sig(sfCounterpartySignature, lender),
+            interestRate(TenthBips32(500)),  // 5%
+            paymentTotal(12),
+            loan::paymentInterval(loanPaymentInterval),
+            loan::gracePeriod(loanGracePeriod),
+            fee(XRP(10)));  // Sufficient fee for multi-sig transaction
+        env(loanATx);
+        env.close();
+
+        auto const loanAKeylet = keylet::loan(brokerKeylet.key, 1);
+
+        // Create Loan B
+        auto loanBTx = env.jt(
+            set(borrowerB, brokerKeylet.key, principalAmount),
+            sig(sfCounterpartySignature, lender),
+            interestRate(TenthBips32(500)),  // 5%
+            paymentTotal(12),
+            loan::paymentInterval(loanPaymentInterval),
+            loan::gracePeriod(loanGracePeriod),
+            fee(XRP(10)));  // Sufficient fee for multi-sig transaction
+        env(loanBTx);
+        env.close();
+
+        auto const loanBKeylet = keylet::loan(brokerKeylet.key, 2);
+
+        auto loanASle = env.le(loanAKeylet);
+        if (!BEAST_EXPECT(loanASle))
+            return;
+
+        // Advance time past grace period for both loans to be defaultable
+        auto const loanANextDue = loanASle->at(sfNextPaymentDueDate);
+        auto const loanAGrace = loanASle->at(sfGracePeriod);
+        env.close(std::chrono::seconds{loanANextDue + loanAGrace + 60});
+
+        env(manage(lender, loanAKeylet.key, tfLoanDefault), ter(tesSUCCESS));
+        env.close();
+
+        // Verify Loan A is defaulted
+        loanASle = env.le(loanAKeylet);
+        if (!BEAST_EXPECT(loanASle))
+            return;
+        BEAST_EXPECT(loanASle->isFlag(lsfLoanDefault));
+        BEAST_EXPECT(loanASle->at(sfPaymentRemaining) == 0);
+
+        // Check broker state after first default (from committed ledger)
+        auto brokerSle = env.le(brokerKeylet);
+        if (!BEAST_EXPECT(brokerSle))
+            return;
+        auto const afterFirstDebtTotal = brokerSle->at(sfDebtTotal);
+        auto const afterFirstCoverAvailable = brokerSle->at(sfCoverAvailable);
+
+        // DebtTotal should have decreased by Loan A's debt
+        BEAST_EXPECT(afterFirstDebtTotal == 50'134);
+
+        // CoverAvailable should have decreased significantly
+        BEAST_EXPECT(afterFirstCoverAvailable == 946);
+
+        env(manage(lender, loanBKeylet.key, tfLoanDefault), ter(tesSUCCESS));
+
+        brokerSle = env.le(brokerKeylet);
+        if (!BEAST_EXPECT(brokerSle))
+            return;
+        auto const afterSecondDebtTotal = brokerSle->at(sfDebtTotal);
+        auto const afterSecondCoverAvailable = brokerSle->at(sfCoverAvailable);
+
+        BEAST_EXPECT(afterSecondDebtTotal == 0);
+
+        BEAST_EXPECT(afterSecondCoverAvailable == 0);
+    }
+
 public:
     void
     run() override
@@ -7538,6 +7659,7 @@ class Loan_test : public beast::unit_test::suite
         testLoanPayBrokerOwnerUnauthorizedMPT();
         testLoanPayBrokerOwnerNoPermissionedDomainMPT();
         testLoanSetBrokerOwnerNoPermissionedDomainMPT();
+        testSequentialFLCDepletion();
     }
 };
 

src/xrpld/app/tx/detail/LoanBrokerSet.cpp

@@ -117,6 +117,13 @@ LoanBrokerSet::preclaim(PreclaimContext const& ctx)
         }
         if (auto const ter = canAddHolding(ctx.view, sleVault->at(sfAsset)))
             return ter;
+
+        if (auto const ter = checkFrozen(
+                ctx.view, sleVault->at(sfAccount), sleVault->at(sfAsset)))
+        {
+            JLOG(ctx.j.warn()) << "Vault pseudo-account is frozen.";
+            return ter;
+        }
     }
     return tesSUCCESS;
 }

src/xrpld/app/tx/detail/LoanManage.cpp

@@ -158,7 +158,7 @@ LoanManage::defaultLoan(
         auto const minimumCover =
             tenthBipsOfValue(brokerDebtTotalProxy.value(), coverRateMinimum);
         // Round the liquidation amount up, too
-        return roundToAsset(
+        auto const covered = roundToAsset(
             vaultAsset,
             /*
              * This formula is from the XLS-66 spec, section 3.2.3.2 (State
@@ -169,6 +169,9 @@ LoanManage::defaultLoan(
                 tenthBipsOfValue(minimumCover, coverRateLiquidation),
                 totalDefaultAmount),
             loanScale);
+        auto const coverAvailable = *brokerSle->at(sfCoverAvailable);
+
+        return std::min(covered, coverAvailable);
     }();
 
     auto const vaultDefaultAmount = totalDefaultAmount - defaultCovered;