xrpld
Loading...
Searching...
No Matches
LoanCashBasis_test.cpp
1#include <test/app/lending/LoanTestBase.h>
2#include <test/jtx/Account.h>
3#include <test/jtx/Env.h>
4#include <test/jtx/TestHelpers.h>
5#include <test/jtx/amount.h>
6#include <test/jtx/fee.h>
7#include <test/jtx/permissioned_domains.h>
8#include <test/jtx/ter.h>
9#include <test/jtx/vault.h>
10
11#include <xrpl/basics/Number.h>
12#include <xrpl/basics/base_uint.h>
13#include <xrpl/basics/chrono.h>
14#include <xrpl/beast/unit_test/suite.h>
15#include <xrpl/beast/utility/Zero.h>
16#include <xrpl/ledger/helpers/LendingHelpers.h>
17#include <xrpl/ledger/helpers/VaultHelpers.h>
18#include <xrpl/protocol/Feature.h>
19#include <xrpl/protocol/Indexes.h>
20#include <xrpl/protocol/Issue.h>
21#include <xrpl/protocol/Protocol.h>
22#include <xrpl/protocol/SField.h>
23#include <xrpl/protocol/SeqProxy.h>
24#include <xrpl/protocol/TER.h>
25#include <xrpl/protocol/TxFlags.h>
26
27#include <chrono>
28#include <cstdint>
29#include <functional>
30#include <string>
31#include <tuple>
32
33namespace xrpl::test {
34
35// LendingProtocolV1_1 ("cash-basis" accounting) dedicated coverage.
36//
37// Existing tests never enable featureLendingProtocolV1_1 (see `all_`
38// above), so these are the only tests in this file that exercise the
39// amendment. They are called once, directly, from
40// runAmendmentIndependent() -- not looped through
41// runAmendmentSensitive()/amendmentCombinations(), since doing so would
42// require re-deriving instant-recognition-specific expected values for ~15
43// unrelated regression tests.
45{
46private:
47 // 1. LoanSet origination: Vault.AssetsTotal/LoanBroker.DebtTotal deltas,
48 // and the AssetsMaximum/DebtMaximum guards. Instant-recognition AssetsMaximum still
49 // requires headroom for interestDue; cash-basis AssetsMaximum does not,
50 // because origination does not credit interest into AssetsTotal.
51 void
53 {
54 testcase("cash-basis: LoanSet origination");
55
56 using namespace jtx;
57 using namespace loan;
58
59 PrettyAsset const xrpAsset{xrpIssue(), 1'000'000};
60 BrokerParameters const brokerParams{
61 .vaultDeposit = 100'000,
62 .debtMax = 0,
63 .coverRateMin = TenthBips32{0},
64 .coverDeposit = 0,
65 .managementFeeRate = TenthBips16{0},
66 .coverRateLiquidation = TenthBips32{0},
67 };
68
69 Number const principalRequest{10'000};
70 TenthBips32 const interestRate{percentageToTenthBips(10)};
71 std::uint32_t const paymentTotal = 2;
72 std::uint32_t const paymentInterval = 86400;
73
74 // Creates a broker/vault, submits a single LoanSet with a nonzero
75 // interest rate, and returns the observed Vault.AssetsTotal /
76 // LoanBroker.DebtTotal deltas plus the loan's own computed
77 // interestDue and principalOutstanding.
78 auto const runOrigination = [&](FeatureBitset features) {
79 Env env(*this, features);
80
81 Account const lender{"lender"};
82 Account const borrower{"borrower"};
83 env.fund(XRP(1'000'000), lender, borrower);
84 env.close();
85
86 BrokerInfo const broker{createVaultAndBroker(env, xrpAsset, lender, brokerParams)};
87
88 auto const vaultBefore = env.le(broker.vaultKeylet());
89 auto const brokerBefore = env.le(broker.brokerKeylet());
90 BEAST_EXPECT(vaultBefore && brokerBefore);
91 Number const assetsTotalBefore = vaultBefore->at(sfAssetsTotal);
92 Number const debtTotalBefore = brokerBefore->at(sfDebtTotal);
93
94 auto const loanSequence = brokerBefore->at(sfLoanSequence);
95 auto const loanKeylet =
96 keylet::loan(broker.brokerID, SeqProxy::rawSequence(loanSequence));
97
98 env(set(borrower, broker.brokerID, xrpAsset(principalRequest).value()),
99 kCounterparty(lender),
100 kInterestRate(interestRate),
101 kPaymentTotal(paymentTotal),
102 kPaymentInterval(paymentInterval),
103 Sig(sfCounterpartySignature, lender),
104 Fee(env.current()->fees().base * 2),
105 Ter(tesSUCCESS));
106 env.close();
107
108 auto const loanSle = env.le(loanKeylet);
109 BEAST_EXPECT(loanSle);
110 Number const principalOutstanding = loanSle->at(sfPrincipalOutstanding);
111 Number const totalValueOutstanding = loanSle->at(sfTotalValueOutstanding);
112 Number const interestDue = totalValueOutstanding - principalOutstanding;
113 BEAST_EXPECT(interestDue > beast::kZero);
114 BEAST_EXPECT(principalOutstanding == xrpAsset(principalRequest).value());
115
116 auto const vaultAfter = env.le(broker.vaultKeylet());
117 auto const brokerAfter = env.le(broker.brokerKeylet());
118 BEAST_EXPECT(vaultAfter && brokerAfter);
119 Number const assetsTotalDelta =
120 Number(vaultAfter->at(sfAssetsTotal)) - assetsTotalBefore;
121 Number const debtTotalDelta = Number(brokerAfter->at(sfDebtTotal)) - debtTotalBefore;
122
123 return std::make_tuple(
124 assetsTotalDelta, debtTotalDelta, interestDue, principalOutstanding);
125 };
126
127 Number interestDueCash{};
128 Number principalOutstandingCash{};
129 {
130 auto const [assetsTotalDelta, debtTotalDelta, interestDue, principalOutstanding] =
131 runOrigination(all_ | featureLendingProtocolV1_1);
132 interestDueCash = interestDue;
133 principalOutstandingCash = principalOutstanding;
134
135 BEAST_EXPECTS(
136 assetsTotalDelta == beast::kZero,
137 "cash-basis origination must not change AssetsTotal; delta=" +
138 to_string(assetsTotalDelta));
139 BEAST_EXPECTS(
140 debtTotalDelta == principalOutstanding,
141 "cash-basis origination must add principal-only to DebtTotal; delta=" +
142 to_string(debtTotalDelta) + " principal=" + to_string(principalOutstanding));
143 }
144
145 {
146 auto const [assetsTotalDelta, debtTotalDelta, interestDue, principalOutstanding] =
147 runOrigination(all_);
148
149 BEAST_EXPECTS(
150 assetsTotalDelta == interestDue,
151 "instant-recognition origination must add interestDue to AssetsTotal; delta=" +
152 to_string(assetsTotalDelta) + " interestDue=" + to_string(interestDue));
153 BEAST_EXPECTS(
154 debtTotalDelta == principalOutstanding + interestDue,
155 "instant-recognition origination must add principal+interest to DebtTotal; delta=" +
156 to_string(debtTotalDelta));
157 }
158
159 // AssetsMaximum guard checks interestDue headroom only under
160 // instant interest recognition; DebtMaximum guard also varies by model.
161 auto const runVaultGuard = [&](FeatureBitset features, Number const& slack, TER expected) {
162 Env env(*this, features);
163
164 Account const lender{"lender"};
165 Account const borrower{"borrower"};
166 env.fund(XRP(1'000'000), lender, borrower);
167 env.close();
168
169 BrokerInfo const broker{createVaultAndBroker(env, xrpAsset, lender, brokerParams)};
170
171 auto const vaultSle = env.le(broker.vaultKeylet());
172 BEAST_EXPECT(vaultSle);
173 Number const assetsTotalBefore = vaultSle->at(sfAssetsTotal);
174
175 Vault const vault{env};
176 auto tx = vault.set({.owner = lender, .id = broker.vaultID});
177 tx[sfAssetsMaximum] = assetsTotalBefore + slack;
178 env(tx);
179 env.close();
180
181 env(set(borrower, broker.brokerID, xrpAsset(principalRequest).value()),
182 kCounterparty(lender),
183 kInterestRate(interestRate),
184 kPaymentTotal(paymentTotal),
185 kPaymentInterval(paymentInterval),
186 Sig(sfCounterpartySignature, lender),
187 Fee(env.current()->fees().base * 2),
188 Ter(expected));
189 env.close();
190 };
191
192 auto const runBrokerGuard =
193 [&](FeatureBitset features, Number const& debtMaximum, TER expected) {
194 Env env(*this, features);
195
196 Account const lender{"lender"};
197 Account const borrower{"borrower"};
198 env.fund(XRP(1'000'000), lender, borrower);
199 env.close();
200
201 BrokerInfo const broker{createVaultAndBroker(env, xrpAsset, lender, brokerParams)};
202
203 env(loan_broker::set(lender, broker.vaultID),
205 loan_broker::kDebtMaximum(debtMaximum),
206 Fee(env.current()->fees().base * 2));
207 env.close();
208
209 env(set(borrower, broker.brokerID, xrpAsset(principalRequest).value()),
210 kCounterparty(lender),
211 kInterestRate(interestRate),
212 kPaymentTotal(paymentTotal),
213 kPaymentInterval(paymentInterval),
214 Sig(sfCounterpartySignature, lender),
215 Fee(env.current()->fees().base * 2),
216 Ter(expected));
217 env.close();
218 };
219
220 Number const oneDrop = xrpAsset(1).value();
221 {
222 testcase(
223 "instant-recognition: LoanSet AssetsMaximum guard checks interestDue headroom");
224 // Guard rejects when there's not quite enough headroom for the
225 // interest.
226 runVaultGuard(all_, interestDueCash - oneDrop, tecLIMIT_EXCEEDED);
227 // Guard accepts at the exact boundary.
228 runVaultGuard(all_, interestDueCash, tesSUCCESS);
229 }
230
231 {
232 testcase("cash-basis: LoanSet AssetsMaximum guard ignores interestDue headroom");
233 // Even far less headroom than interestDue still succeeds, since
234 // cash-basis origination never adds interest to AssetsTotal.
235 runVaultGuard(all_ | featureLendingProtocolV1_1, oneDrop, tesSUCCESS);
236 // Fully subscribed: AssetsTotal == AssetsMaximum. Instant-recognition preclaim
237 // used to refuse this; origination must still succeed because it
238 // does not change AssetsTotal.
239 runVaultGuard(all_ | featureLendingProtocolV1_1, Number{0}, tesSUCCESS);
240 }
241
242 // DebtMaximum guard: cash-basis projects principal-only DebtTotal;
243 // instant recognition projects principal + interestDue.
244 for (auto const cashBasis : {true, false})
245 {
246 testcase(
247 std::string("LoanSet DebtMaximum guard (") +
248 (cashBasis ? "cash-basis)" : "instant-recognition)"));
249 auto const features = cashBasis ? all_ | featureLendingProtocolV1_1 : all_;
250 Number const newDebtTotal =
251 principalOutstandingCash + (cashBasis ? Number{} : interestDueCash);
252 runBrokerGuard(features, newDebtTotal - oneDrop, tecLIMIT_EXCEEDED);
253 runBrokerGuard(features, newDebtTotal, tesSUCCESS);
254 }
255 }
256
257 // 2. LoanPay: regular, late, overpayment, and full-payment types.
258 // Assert Vault.AssetsTotal/LoanBroker.DebtTotal deltas match
259 // interestPaid/principalPaid under cash-basis, and cross-check the
260 // amendment-disabled run's deltas against the documented instant-recognition
261 // formula (AssetsTotal += valueChange; DebtTotal mirrors the loan's own
262 // TotalValueOutstanding delta exactly, since instant-recognition debt recognition
263 // tracks total loan value).
264 void
266 {
267 using namespace jtx;
268 using namespace loan;
269 using namespace std::chrono_literals;
270 using Tp = NetClock::time_point;
271
272 PrettyAsset const xrpAsset{xrpIssue(), 1'000'000};
273 BrokerParameters const brokerParams{
274 .vaultDeposit = 1'000'000,
275 .debtMax = 0,
276 .coverRateMin = TenthBips32{0},
277 .coverDeposit = 0,
278 .managementFeeRate = TenthBips16{0},
279 .coverRateLiquidation = TenthBips32{0},
280 };
281
282 Number const principalRequest{12'000};
283 TenthBips32 const interestRate{percentageToTenthBips(12)};
284 std::uint32_t const paymentTotal = 4;
285 std::uint32_t const paymentInterval = 600;
286 std::uint32_t const gracePeriod = 300;
287
288 struct PaymentDeltas
289 {
290 Number principalPaid;
291 Number assetsTotalDelta;
292 Number debtTotalDelta;
293 Number totalValueDelta;
294 };
295
296 // Sets up a fresh broker + loan, advances time, submits a single
297 // payment of the given type/amount, and returns the observed deltas.
298 auto const runPayment =
299 [&](FeatureBitset features,
300 std::uint32_t loanSetFlags,
301 std::uint32_t payFlags,
302 std::function<void(Env&, Tp const&)> const& advanceTime,
303 std::function<STAmount(LoanState const&)> const& paymentAmount) {
304 Env env(*this, features);
305
306 Account const lender{"lender"};
307 Account const borrower{"borrower"};
308 env.fund(XRP(10'000'000), lender, borrower);
309 env.close();
310
311 BrokerInfo const broker{createVaultAndBroker(env, xrpAsset, lender, brokerParams)};
312
313 LoanParameters const loanParams{
314 .account = borrower,
315 .counter = lender,
316 .principalRequest = principalRequest,
317 .interest = interestRate,
318 .payTotal = paymentTotal,
319 .payInterval = paymentInterval,
320 .gracePd = gracePeriod,
321 .flags = loanSetFlags,
322 };
323
324 auto const brokerBeforeLoan = env.le(broker.brokerKeylet());
325 BEAST_EXPECT(brokerBeforeLoan);
326 auto const loanSequence = brokerBeforeLoan->at(sfLoanSequence);
327 auto const loanKeylet =
328 keylet::loan(broker.brokerID, SeqProxy::rawSequence(loanSequence));
329
330 env(loanParams(env, broker));
331 env.close();
332
333 LoanState const state = getCurrentState(env, broker, loanKeylet);
334
335 advanceTime(env, state.startDate);
336
337 auto const vaultBefore = env.le(broker.vaultKeylet());
338 auto const brokerBefore = env.le(broker.brokerKeylet());
339 auto const loanBefore = env.le(loanKeylet);
340 BEAST_EXPECT(vaultBefore && brokerBefore && loanBefore);
341
342 Number const principalBefore = loanBefore->at(sfPrincipalOutstanding);
343 Number const totalValueBefore = loanBefore->at(sfTotalValueOutstanding);
344 Number const assetsTotalBefore = vaultBefore->at(sfAssetsTotal);
345 Number const debtTotalBefore = brokerBefore->at(sfDebtTotal);
346
347 STAmount const amount = paymentAmount(state);
348 env(pay(borrower, loanKeylet.key, amount, payFlags), Ter(tesSUCCESS));
349 env.close();
350
351 auto const vaultAfter = env.le(broker.vaultKeylet());
352 auto const brokerAfter = env.le(broker.brokerKeylet());
353 auto const loanAfter = env.le(loanKeylet);
354 BEAST_EXPECT(vaultAfter && brokerAfter && loanAfter);
355
356 Number const principalAfter = loanAfter->at(sfPrincipalOutstanding);
357 Number const totalValueAfter = loanAfter->at(sfTotalValueOutstanding);
358 Number const assetsTotalAfter = vaultAfter->at(sfAssetsTotal);
359 Number const debtTotalAfter = brokerAfter->at(sfDebtTotal);
360
361 return PaymentDeltas{
362 .principalPaid = principalBefore - principalAfter,
363 .assetsTotalDelta = assetsTotalAfter - assetsTotalBefore,
364 .debtTotalDelta = debtTotalAfter - debtTotalBefore,
365 .totalValueDelta = totalValueAfter - totalValueBefore,
366 };
367 };
368
369 // Compares the disabled (instant-recognition) and enabled (cash-basis) runs
370 // of the same payment scenario, and asserts the documented
371 // relationships between them.
372 auto const checkScenario = [&](std::string const& label,
373 PaymentDeltas const& off,
374 PaymentDeltas const& on) {
375 testcase("cash-basis: LoanPay " + label);
376
377 // The loan's own PrincipalOutstanding field is untouched by
378 // the amendment.
379 BEAST_EXPECTS(
380 off.principalPaid == on.principalPaid,
381 "principalPaid must be amendment-independent; off=" + to_string(off.principalPaid) +
382 " on=" + to_string(on.principalPaid));
383
384 // Whole-life structural invariant: DebtTotal (which
385 // recognizes a loan's full remaining value as debt) must
386 // change exactly as the loan's own TotalValueOutstanding
387 // does.
388 BEAST_EXPECTS(
389 off.debtTotalDelta == off.totalValueDelta,
390 "instant-recognition DebtTotal delta must mirror TotalValueOutstanding delta; "
391 "debtTotalDelta=" +
392 to_string(off.debtTotalDelta) +
393 " totalValueDelta=" + to_string(off.totalValueDelta));
394
395 // Derive interestPaid from the instant-recognition run's independent
396 // ledger deltas:
397 // assetsTotalDelta_off == valueChange
398 // debtTotalDelta_off == valueChange - (principalPaid + interestPaid)
399 // => interestPaid == assetsTotalDelta_off - debtTotalDelta_off - principalPaid
400 Number const interestPaid =
401 off.assetsTotalDelta - off.debtTotalDelta - off.principalPaid;
402 BEAST_EXPECTS(
403 interestPaid >= beast::kZero,
404 "derived interestPaid must be non-negative: " + to_string(interestPaid));
405
406 BEAST_EXPECTS(
407 on.assetsTotalDelta == interestPaid,
408 "cash-basis AssetsTotal delta must equal interestPaid; delta=" +
409 to_string(on.assetsTotalDelta) + " interestPaid=" + to_string(interestPaid));
410 BEAST_EXPECTS(
411 on.debtTotalDelta == -on.principalPaid,
412 "cash-basis DebtTotal delta must equal -principalPaid; delta=" +
413 to_string(on.debtTotalDelta) + " principalPaid=" + to_string(on.principalPaid));
414 };
415
416 // ---- Regular, on-time payment ----
417 {
418 auto const noAdvance = [](Env& env, Tp const&) { env.close(); };
419 auto const regularAmount = [&](LoanState const& state) {
420 return STAmount{
421 xrpAsset,
422 roundPeriodicPayment(xrpAsset, state.periodicPayment, state.loanScale) *
423 Number{3, -1} * 5}; // 1.5x, so only a single period is paid
424 };
425
426 auto const off = runPayment(all_, 0, 0, noAdvance, regularAmount);
427 auto const on =
428 runPayment(all_ | featureLendingProtocolV1_1, 0, 0, noAdvance, regularAmount);
429
430 // Regular, on-time payments never change the loan's value beyond
431 // normal amortization (production asserts valueChange == 0), so
432 // AssetsTotal must be unaffected in the instant-recognition run.
433 BEAST_EXPECTS(
434 off.assetsTotalDelta == beast::kZero,
435 "regular on-time payment must not change AssetsTotal under instant recognition; "
436 "delta=" +
437 to_string(off.assetsTotalDelta));
438
439 checkScenario("regular payment", off, on);
440 }
441
442 // ---- Late payment ----
443 {
444 auto const advancePastDue = [&](Env& env, Tp const& startDate) {
445 env.close(startDate + std::chrono::seconds(paymentInterval + 1));
446 };
447 auto const lateAmount = [&](LoanState const& state) {
448 return STAmount{
449 xrpAsset,
450 roundPeriodicPayment(xrpAsset, state.periodicPayment, state.loanScale) *
451 Number{3}}; // generous; excess is not withdrawn
452 };
453
454 auto const off = runPayment(all_, 0, tfLoanLatePayment, advancePastDue, lateAmount);
455 auto const on = runPayment(
456 all_ | featureLendingProtocolV1_1,
457 0,
458 tfLoanLatePayment,
459 advancePastDue,
460 lateAmount);
461
462 checkScenario("late payment", off, on);
463 }
464
465 // ---- Overpayment ----
466 {
467 auto const noAdvance = [](Env& env, Tp const&) { env.close(); };
468 auto const overpayAmount = [&](LoanState const& state) {
469 // One regular period, plus a generous extra principal
470 // paydown.
471 return STAmount{
472 xrpAsset,
473 roundPeriodicPayment(xrpAsset, state.periodicPayment, state.loanScale) +
474 xrpAsset(2'000).value()};
475 };
476
477 auto const off =
478 runPayment(all_, tfLoanOverpayment, tfLoanOverpayment, noAdvance, overpayAmount);
479 auto const on = runPayment(
480 all_ | featureLendingProtocolV1_1,
481 tfLoanOverpayment,
482 tfLoanOverpayment,
483 noAdvance,
484 overpayAmount);
485
486 checkScenario("overpayment", off, on);
487 }
488
489 // ---- Full payment ----
490 {
491 auto const noAdvance = [](Env& env, Tp const&) { env.close(); };
492 auto const fullAmount = [&](LoanState const&) {
493 // Generously large: full payment only ever consumes exactly
494 // what's due (principal + accrued interest; close fee/
495 // prepayment penalty are 0 here), excess is not withdrawn.
496 return STAmount{xrpAsset, xrpAsset(principalRequest).value() * Number{2}};
497 };
498
499 auto const off = runPayment(all_, 0, tfLoanFullPayment, noAdvance, fullAmount);
500 auto const on = runPayment(
501 all_ | featureLendingProtocolV1_1, 0, tfLoanFullPayment, noAdvance, fullAmount);
502
503 checkScenario("full payment", off, on);
504 }
505 }
506
507 // VaultSet must still succeed when cash-basis LoanPay has already pushed
508 // AssetsTotal above a nonzero AssetsMaximum. Before fixCleanup3_4_0,
509 // ValidVault rejects that with tecINVARIANT_FAILED even though
510 // VaultSet::doApply and the product rule allow the over-cap state when
511 // the excess is interest.
512 void
514 {
515 using namespace jtx;
516 using namespace loan;
517
518 PrettyAsset const xrpAsset{xrpIssue(), 1'000'000};
519 BrokerParameters const brokerParams{
520 .vaultDeposit = 1'000'000,
521 .debtMax = 0,
522 .coverRateMin = TenthBips32{0},
523 .coverDeposit = 0,
524 .managementFeeRate = TenthBips16{0},
525 .coverRateLiquidation = TenthBips32{0},
526 };
527
528 auto const run =
529 [&](FeatureBitset features, TER expectedOverCapSet, bool native, bool vaultPrivate) {
530 bool const fix340Enabled = features[fixCleanup3_4_0];
531 testcase(
532 std::string("cash-basis: VaultSet while AssetsTotal exceeds AssetsMaximum") +
533 (native ? " XRP" : " IOU") + (vaultPrivate ? " private" : "") +
534 (fix340Enabled ? " (fixCleanup3_4_0)" : " (pre-fix)"));
535
536 Account const issuer{"issuer"};
537 Account const lender{"lender"};
538 Account const borrower{"borrower"};
539 Env env(*this, features);
540
541 BrokerParameters params = brokerParams;
542 if (vaultPrivate)
543 params.vaultFlags = tfVaultPrivate;
544
545 PrettyAsset vaultAsset = xrpAsset;
546 if (native)
547 {
548 env.fund(XRP(10'000'000), lender, borrower);
549 env.close();
550 }
551 else
552 {
553 vaultAsset = createFundedIouAsset(env, issuer, lender, borrower);
554 }
555
556 BrokerInfo const broker{createVaultAndBroker(env, vaultAsset, lender, params)};
557 auto const vaultBefore = env.le(broker.vaultKeylet());
558 BEAST_EXPECT(vaultBefore);
559 // One unit at the vault's asset scale so the stored cap is
560 // strictly above AssetsTotal (a smaller ULP rounds away).
561 // Cash-basis origination does not credit interest, so LoanSet
562 // still succeeds.
563 Number const slack{1, -static_cast<int>(vaultBefore->at(sfScale))};
564 Number const assetsMaximum = Number(vaultBefore->at(sfAssetsTotal)) + slack;
565
566 Vault const vault{env};
567 {
568 auto tx = vault.set({.owner = lender, .id = broker.vaultID});
569 tx[sfAssetsMaximum] = assetsMaximum;
570 env(tx);
571 env.close();
572 }
573
574 {
575 auto tx = vault.set({.owner = lender, .id = broker.vaultID});
576 tx[sfData] = "AA";
577 env(tx, Ter(tesSUCCESS));
578 env.close();
579 }
580
581 auto const brokerBeforeLoan = env.le(broker.brokerKeylet());
582 BEAST_EXPECT(brokerBeforeLoan);
583 auto const loanKeylet = keylet::loan(
584 broker.brokerID, SeqProxy::rawSequence(brokerBeforeLoan->at(sfLoanSequence)));
585
586 LoanParameters const loanParams{
587 .account = borrower,
588 .counter = lender,
589 .principalRequest = 12'000,
590 .interest = TenthBips32{percentageToTenthBips(12)},
591 .payTotal = 4,
592 .payInterval = 600,
593 .gracePd = 300,
594 };
595 env(loanParams(env, broker));
596 env.close();
597
598 auto const vaultAfterLoan = env.le(broker.vaultKeylet());
599 BEAST_EXPECT(vaultAfterLoan);
600 BEAST_EXPECT(vaultAfterLoan->at(sfAssetsTotal) <= assetsMaximum);
601
602 LoanState const state = getCurrentState(env, broker, loanKeylet);
603 STAmount const payment{
604 vaultAsset,
605 roundPeriodicPayment(vaultAsset, state.periodicPayment, state.loanScale) *
606 Number{3, -1} * 5};
607 env(pay(borrower, loanKeylet.key, payment), Ter(tesSUCCESS));
608 env.close();
609
610 auto const vaultAboveMaximum = env.le(broker.vaultKeylet());
611 BEAST_EXPECT(vaultAboveMaximum);
612 BEAST_EXPECT(vaultAboveMaximum->at(sfAssetsTotal) > assetsMaximum);
613 BEAST_EXPECT(vaultAboveMaximum->at(sfAssetsMaximum) == assetsMaximum);
614
615 {
616 auto tx = vault.set({.owner = lender, .id = broker.vaultID});
617 tx[sfData] = "BB";
618 env(tx, Ter(expectedOverCapSet));
619 env.close();
620 }
621
622 if (vaultPrivate)
623 {
625 {.issuer = lender, .credType = "credential"},
626 };
627 env(pdomain::setTx(lender, credentials));
628 auto const domainId = pdomain::getNewDomain(env.meta());
629 auto tx = vault.set({.owner = lender, .id = broker.vaultID});
630 tx[sfDomainID] = to_string(domainId);
631 env(tx, Ter(expectedOverCapSet));
632 env.close();
633 }
634
635 if (!fix340Enabled)
636 return;
637
638 {
639 auto tx = vault.set({.owner = lender, .id = broker.vaultID});
640 tx[sfAssetsMaximum] = assetsMaximum;
641 env(tx, Ter(tecLIMIT_EXCEEDED));
642 env.close();
643 }
644
645 {
646 auto tx = vault.set({.owner = lender, .id = broker.vaultID});
647 tx[sfAssetsMaximum] = Number{0};
648 env(tx, Ter(tesSUCCESS));
649 env.close();
650 }
651 };
652
653 FeatureBitset const withFix = all_ | featureLendingProtocolV1_1;
654 FeatureBitset const withoutFix = withFix - fixCleanup3_4_0;
655
656 run(withFix, tesSUCCESS, true, true);
657 run(withoutFix, tecINVARIANT_FAILED, true, true);
658 run(withFix, tesSUCCESS, false, false);
659 run(withoutFix, tecINVARIANT_FAILED, false, false);
660 }
661
662 void
664 {
665 testcase("cash-basis: LoanSet after interest pushes AssetsTotal past AssetsMaximum");
666
667 using namespace jtx;
668 using namespace loan;
669
670 PrettyAsset const xrpAsset{xrpIssue(), 1'000'000};
671 BrokerParameters const brokerParams{
672 .vaultDeposit = 1'000'000,
673 .debtMax = 0,
674 .coverRateMin = TenthBips32{0},
675 .coverDeposit = 0,
676 .managementFeeRate = TenthBips16{0},
677 .coverRateLiquidation = TenthBips32{0},
678 };
679
680 Account const lender{"lender"};
681 Account const borrower{"borrower"};
682 Env env(*this, all_ | featureLendingProtocolV1_1);
683 env.fund(XRP(10'000'000), lender, borrower);
684 env.close();
685
686 BrokerInfo const broker{createVaultAndBroker(env, xrpAsset, lender, brokerParams)};
687 auto const vaultBefore = env.le(broker.vaultKeylet());
688 BEAST_EXPECT(vaultBefore);
689 Number const assetsMaximum = Number(vaultBefore->at(sfAssetsTotal));
690
691 Vault const vault{env};
692 {
693 auto tx = vault.set({.owner = lender, .id = broker.vaultID});
694 tx[sfAssetsMaximum] = assetsMaximum;
695 env(tx);
696 env.close();
697 }
698
699 auto const brokerBeforeLoan = env.le(broker.brokerKeylet());
700 BEAST_EXPECT(brokerBeforeLoan);
701 auto const firstLoanKeylet = keylet::loan(
702 broker.brokerID, SeqProxy::rawSequence(brokerBeforeLoan->at(sfLoanSequence)));
703
704 Number const firstPrincipal = xrpAsset(12'000).value();
705 env(set(borrower, broker.brokerID, firstPrincipal),
706 kCounterparty(lender),
707 kInterestRate(TenthBips32{percentageToTenthBips(12)}),
708 kPaymentTotal(4),
709 kPaymentInterval(600),
710 Sig(sfCounterpartySignature, lender),
711 Fee(env.current()->fees().base * 2),
712 Ter(tesSUCCESS));
713 env.close();
714
715 auto const vaultAfterFirst = env.le(broker.vaultKeylet());
716 BEAST_EXPECT(vaultAfterFirst);
717 BEAST_EXPECT(vaultAfterFirst->at(sfAssetsTotal) == assetsMaximum);
718 BEAST_EXPECT(vaultAfterFirst->at(sfAssetsAvailable) == assetsMaximum - firstPrincipal);
719
720 LoanState const state = getCurrentState(env, broker, firstLoanKeylet);
721 STAmount const payment{
722 xrpAsset,
723 roundPeriodicPayment(xrpAsset, state.periodicPayment, state.loanScale) * Number{3, -1} *
724 5};
725 env(pay(borrower, firstLoanKeylet.key, payment), Ter(tesSUCCESS));
726 env.close();
727
728 auto const vaultAfterPay = env.le(broker.vaultKeylet());
729 BEAST_EXPECT(vaultAfterPay);
730 BEAST_EXPECT(vaultAfterPay->at(sfAssetsTotal) > assetsMaximum);
731 BEAST_EXPECT(vaultAfterPay->at(sfAssetsAvailable) > beast::kZero);
732
733 auto const brokerAfterPay = env.le(broker.brokerKeylet());
734 BEAST_EXPECT(brokerAfterPay);
735 auto const secondLoanKeylet = keylet::loan(
736 broker.brokerID, SeqProxy::rawSequence(brokerAfterPay->at(sfLoanSequence)));
737
738 Number const secondPrincipal = xrpAsset(1'000).value();
739 env(set(borrower, broker.brokerID, secondPrincipal),
740 kCounterparty(lender),
741 kInterestRate(TenthBips32{percentageToTenthBips(12)}),
742 kPaymentTotal(4),
743 kPaymentInterval(600),
744 Sig(sfCounterpartySignature, lender),
745 Fee(env.current()->fees().base * 2),
746 Ter(tesSUCCESS));
747 env.close();
748
749 auto const vaultAfterSecond = env.le(broker.vaultKeylet());
750 auto const secondLoan = env.le(secondLoanKeylet);
751 BEAST_EXPECT(vaultAfterSecond && secondLoan);
752 BEAST_EXPECT(vaultAfterSecond->at(sfAssetsTotal) == vaultAfterPay->at(sfAssetsTotal));
753 BEAST_EXPECT(secondLoan->at(sfPrincipalOutstanding) == secondPrincipal);
754 }
755
756 // 3. LoanManage: impair, unimpair, and default.
757 void
759 {
760 using namespace jtx;
761 using namespace loan;
762 using namespace std::chrono_literals;
763
764 PrettyAsset const xrpAsset{xrpIssue(), 1'000'000};
765 BrokerParameters const brokerParams{
766 .vaultDeposit = 1'000'000,
767 .debtMax = 0,
768 .coverRateMin = TenthBips32{percentageToTenthBips(10)},
769 .coverDeposit = 5'000,
770 .managementFeeRate = TenthBips16{0},
771 .coverRateLiquidation = TenthBips32{percentageToTenthBips(25)},
772 };
773
774 Number const principalRequest{10'000};
775 TenthBips32 const interestRate{percentageToTenthBips(12)};
776 std::uint32_t const paymentTotal = 4;
777 std::uint32_t const paymentInterval = 600;
778 std::uint32_t const gracePeriod = 60;
779
780 auto setupLoan = [&](Env& env) {
781 Account const lender{"lender"};
782 Account const borrower{"borrower"};
783 env.fund(XRP(10'000'000), lender, borrower);
784 env.close();
785
786 BrokerInfo const broker{createVaultAndBroker(env, xrpAsset, lender, brokerParams)};
787
788 LoanParameters const loanParams{
789 .account = borrower,
790 .counter = lender,
791 .principalRequest = principalRequest,
792 .interest = interestRate,
793 .payTotal = paymentTotal,
794 .payInterval = paymentInterval,
795 .gracePd = gracePeriod,
796 };
797
798 auto const brokerBeforeLoan = env.le(broker.brokerKeylet());
799 BEAST_EXPECT(brokerBeforeLoan);
800 auto const loanSequence = brokerBeforeLoan->at(sfLoanSequence);
801 auto const loanKeylet =
802 keylet::loan(broker.brokerID, SeqProxy::rawSequence(loanSequence));
803
804 env(loanParams(env, broker));
805 env.close();
806
807 return std::make_tuple(broker, loanKeylet, lender, borrower);
808 };
809
810 // ---- impair / unimpair ----
811 auto const runImpairUnimpair = [&](FeatureBitset features) {
812 Env env(*this, features);
813 auto const [broker, loanKeylet, lender, borrower] = setupLoan(env);
814
815 auto const loanBefore = env.le(loanKeylet);
816 BEAST_EXPECT(loanBefore);
817 Number const principalOutstanding = loanBefore->at(sfPrincipalOutstanding);
818 Number const totalValueOutstanding = loanBefore->at(sfTotalValueOutstanding);
819 Number const managementFeeOutstanding = loanBefore->at(sfManagementFeeOutstanding);
820
821 Number const expectedExposure =
822 env.current()->rules().enabled(featureLendingProtocolV1_1)
823 ? principalOutstanding
824 : totalValueOutstanding - managementFeeOutstanding;
825
826 auto const vaultBeforeImpair = env.le(broker.vaultKeylet());
827 BEAST_EXPECT(vaultBeforeImpair);
828 Number const lossBefore = vaultBeforeImpair->at(sfLossUnrealized);
829
830 advancePastDueDate(env, loanKeylet);
831 env(manage(lender, loanKeylet.key, tfLoanImpair), Ter(tesSUCCESS));
832 env.close();
833
834 auto const vaultAfterImpair = env.le(broker.vaultKeylet());
835 BEAST_EXPECT(vaultAfterImpair);
836 Number const impairDelta = Number(vaultAfterImpair->at(sfLossUnrealized)) - lossBefore;
837
838 env(manage(lender, loanKeylet.key, tfLoanUnimpair), Ter(tesSUCCESS));
839 env.close();
840
841 auto const vaultAfterUnimpair = env.le(broker.vaultKeylet());
842 BEAST_EXPECT(vaultAfterUnimpair);
843 Number const netDelta = Number(vaultAfterUnimpair->at(sfLossUnrealized)) - lossBefore;
844
845 return std::make_tuple(expectedExposure, impairDelta, netDelta);
846 };
847
848 for (auto const features : {all_ | featureLendingProtocolV1_1, all_})
849 {
850 testcase(
851 std::string("cash-basis: LoanManage impair/unimpair (") +
852 (features[featureLendingProtocolV1_1] ? "enabled)" : "disabled)"));
853 auto const [expectedExposure, impairDelta, netDelta] = runImpairUnimpair(features);
854
855 BEAST_EXPECTS(
856 impairDelta == expectedExposure,
857 "impair must add loanVaultExposure to LossUnrealized; delta=" +
858 to_string(impairDelta) + " expected=" + to_string(expectedExposure));
859 BEAST_EXPECTS(
860 netDelta == beast::kZero,
861 "unimpair must be an exact reversal of impair; net=" + to_string(netDelta));
862 }
863
864 // ---- impair, then default ----
865 auto const runDefault = [&](FeatureBitset features) {
866 Env env(*this, features);
867 auto const [broker, loanKeylet, lender, borrower] = setupLoan(env);
868
869 auto const loanBeforeImpair = env.le(loanKeylet);
870 BEAST_EXPECT(loanBeforeImpair);
871 Number const principalOutstanding = loanBeforeImpair->at(sfPrincipalOutstanding);
872 Number const totalValueOutstanding = loanBeforeImpair->at(sfTotalValueOutstanding);
873 Number const managementFeeOutstanding =
874 loanBeforeImpair->at(sfManagementFeeOutstanding);
875
876 Number const expectedExposure =
877 env.current()->rules().enabled(featureLendingProtocolV1_1)
878 ? principalOutstanding
879 : totalValueOutstanding - managementFeeOutstanding;
880
881 advancePastDueDate(env, loanKeylet);
882 env(manage(lender, loanKeylet.key, tfLoanImpair), Ter(tesSUCCESS));
883 env.close();
884
885 LoanState const state = getCurrentState(env, broker, loanKeylet);
886 env.close(
887 state.startDate + std::chrono::seconds(paymentInterval) +
888 std::chrono::seconds(gracePeriod) + 60s);
889
890 auto const vaultBefore = env.le(broker.vaultKeylet());
891 auto const brokerBefore = env.le(broker.brokerKeylet());
892 BEAST_EXPECT(vaultBefore && brokerBefore);
893 Number const assetsTotalBefore = vaultBefore->at(sfAssetsTotal);
894 Number const debtTotalBefore = brokerBefore->at(sfDebtTotal);
895 Number const lossBefore = vaultBefore->at(sfLossUnrealized);
896 Number const coverAvailableBefore = brokerBefore->at(sfCoverAvailable);
897
898 env(manage(lender, loanKeylet.key, tfLoanDefault), Ter(tesSUCCESS));
899 env.close();
900
901 auto const vaultAfter = env.le(broker.vaultKeylet());
902 auto const brokerAfter = env.le(broker.brokerKeylet());
903 BEAST_EXPECT(vaultAfter && brokerAfter);
904 Number const assetsTotalDelta =
905 Number(vaultAfter->at(sfAssetsTotal)) - assetsTotalBefore;
906 Number const debtTotalDelta = Number(brokerAfter->at(sfDebtTotal)) - debtTotalBefore;
907 Number const lossDelta = Number(vaultAfter->at(sfLossUnrealized)) - lossBefore;
908 Number const coverAvailableDelta =
909 Number(brokerAfter->at(sfCoverAvailable)) - coverAvailableBefore;
910
911 Number const defaultCovered = -coverAvailableDelta;
912 Number const vaultDefaultAmount = expectedExposure - defaultCovered;
913
914 return std::make_tuple(
915 expectedExposure, assetsTotalDelta, debtTotalDelta, lossDelta, vaultDefaultAmount);
916 };
917
918 for (auto const features : {all_ | featureLendingProtocolV1_1, all_})
919 {
920 testcase(
921 std::string("cash-basis: LoanManage default (") +
922 (features[featureLendingProtocolV1_1] ? "enabled)" : "disabled)"));
923 auto const
924 [expectedExposure,
925 assetsTotalDelta,
926 debtTotalDelta,
927 lossDelta,
928 vaultDefaultAmount] = runDefault(features);
929
930 BEAST_EXPECTS(
931 debtTotalDelta == -expectedExposure,
932 "default must reduce DebtTotal by the unified default amount; delta=" +
933 to_string(debtTotalDelta) + " expected=" + to_string(expectedExposure));
934 BEAST_EXPECTS(
935 lossDelta == -expectedExposure,
936 "default must reverse the earlier impair's LossUnrealized exactly; delta=" +
937 to_string(lossDelta) + " expected=" + to_string(expectedExposure));
938 BEAST_EXPECTS(
939 assetsTotalDelta == -vaultDefaultAmount,
940 "default must reduce AssetsTotal by (defaultAmount - defaultCovered); delta=" +
941 to_string(assetsTotalDelta) + " expected=" + to_string(-vaultDefaultAmount));
942 }
943 }
944
945 // 3b. LEVersion regression: a Vault created before featureLendingProtocolV1_1
946 // activates (LEVersion absent) must keep instant interest recognition
947 // forever, even after the amendment is later enabled -- the switch is
948 // per-Vault (LEVersion == VaultVersion::CashBasis), not a single global amendment
949 // flag.
950 void
952 {
953 testcase(
954 "LEVersion: legacy vault keeps instant interest recognition after amendment enabled");
955
956 using namespace jtx;
957 using namespace loan;
958 using namespace std::chrono_literals;
959
960 PrettyAsset const xrpAsset{xrpIssue(), 1'000'000};
961 BrokerParameters const brokerParams{
962 .vaultDeposit = 1'000'000,
963 .debtMax = 0,
964 .coverRateMin = TenthBips32{percentageToTenthBips(10)},
965 .coverDeposit = 5'000,
966 .managementFeeRate = TenthBips16{0},
967 .coverRateLiquidation = TenthBips32{percentageToTenthBips(25)},
968 };
969
970 Number const principalRequest{10'000};
971 TenthBips32 const interestRate{percentageToTenthBips(12)};
972 std::uint32_t const paymentTotal = 4;
973 std::uint32_t const paymentInterval = 600;
974 std::uint32_t const gracePeriod = 60;
975
976 // Amendment disabled at Vault creation time: LEVersion stays absent.
977 Env env(*this, all_);
978
979 Account const lender{"lender"};
980 Account const borrower{"borrower"};
981 env.fund(XRP(10'000'000), lender, borrower);
982 env.close();
983
984 BrokerInfo const broker{createVaultAndBroker(env, xrpAsset, lender, brokerParams)};
985
986 {
987 auto const vaultSle = env.le(broker.vaultKeylet());
988 BEAST_EXPECT(vaultSle);
989 BEAST_EXPECT(!vaultSle->isFieldPresent(sfLEVersion));
990 }
991
992 // Now enable the amendment -- production dispatch must still treat
993 // this specific Vault as instant interest recognition, since its LEVersion is
994 // (and remains) absent.
995 env.enableFeature(featureLendingProtocolV1_1);
996 env.close();
997
998 LoanParameters const loanParams{
999 .account = borrower,
1000 .counter = lender,
1001 .principalRequest = principalRequest,
1002 .interest = interestRate,
1003 .payTotal = paymentTotal,
1004 .payInterval = paymentInterval,
1005 .gracePd = gracePeriod,
1006 };
1007
1008 auto const brokerBeforeLoan = env.le(broker.brokerKeylet());
1009 BEAST_EXPECT(brokerBeforeLoan);
1010 auto const loanSequence = brokerBeforeLoan->at(sfLoanSequence);
1011 auto const loanKeylet = keylet::loan(broker.brokerID, SeqProxy::rawSequence(loanSequence));
1012
1013 // ---- LoanSet origination: instant-recognition formulas expected ----
1014 auto const vaultBeforeSet = env.le(broker.vaultKeylet());
1015 auto const brokerBeforeSet = env.le(broker.brokerKeylet());
1016 BEAST_EXPECT(vaultBeforeSet && brokerBeforeSet);
1017 Number const assetsTotalBeforeSet = vaultBeforeSet->at(sfAssetsTotal);
1018 Number const debtTotalBeforeSet = brokerBeforeSet->at(sfDebtTotal);
1019
1020 env(loanParams(env, broker));
1021 env.close();
1022
1023 auto const loanAfterSet = env.le(loanKeylet);
1024 BEAST_EXPECT(loanAfterSet);
1025 Number const principalOutstanding = loanAfterSet->at(sfPrincipalOutstanding);
1026 Number const totalValueOutstanding = loanAfterSet->at(sfTotalValueOutstanding);
1027 Number const interestDue = totalValueOutstanding - principalOutstanding;
1028 BEAST_EXPECT(interestDue > beast::kZero);
1029
1030 auto const vaultAfterSet = env.le(broker.vaultKeylet());
1031 auto const brokerAfterSet = env.le(broker.brokerKeylet());
1032 BEAST_EXPECT(vaultAfterSet && brokerAfterSet);
1033 Number const assetsTotalDeltaSet =
1034 Number(vaultAfterSet->at(sfAssetsTotal)) - assetsTotalBeforeSet;
1035 Number const debtTotalDeltaSet =
1036 Number(brokerAfterSet->at(sfDebtTotal)) - debtTotalBeforeSet;
1037
1038 BEAST_EXPECTS(
1039 assetsTotalDeltaSet == interestDue,
1040 "legacy vault origination must still add interestDue to AssetsTotal; delta=" +
1041 to_string(assetsTotalDeltaSet) + " interestDue=" + to_string(interestDue));
1042 BEAST_EXPECTS(
1043 debtTotalDeltaSet == principalOutstanding + interestDue,
1044 "legacy vault origination must still add principal+interest to DebtTotal; delta=" +
1045 to_string(debtTotalDeltaSet));
1046
1047 LoanState const state = getCurrentState(env, broker, loanKeylet);
1048 env.close();
1049
1050 // ---- LoanPay: instant-recognition formulas expected ----
1051 auto const vaultBeforePay = env.le(broker.vaultKeylet());
1052 auto const brokerBeforePay = env.le(broker.brokerKeylet());
1053 auto const loanBeforePay = env.le(loanKeylet);
1054 BEAST_EXPECT(vaultBeforePay && brokerBeforePay && loanBeforePay);
1055 Number const totalValueBeforePay = loanBeforePay->at(sfTotalValueOutstanding);
1056 Number const assetsTotalBeforePay = vaultBeforePay->at(sfAssetsTotal);
1057 Number const debtTotalBeforePay = brokerBeforePay->at(sfDebtTotal);
1058
1059 STAmount const paymentAmount{
1060 xrpAsset, roundPeriodicPayment(xrpAsset, state.periodicPayment, state.loanScale)};
1061 env(pay(borrower, loanKeylet.key, paymentAmount), Ter(tesSUCCESS));
1062 env.close();
1063
1064 auto const vaultAfterPay = env.le(broker.vaultKeylet());
1065 auto const brokerAfterPay = env.le(broker.brokerKeylet());
1066 auto const loanAfterPay = env.le(loanKeylet);
1067 BEAST_EXPECT(vaultAfterPay && brokerAfterPay && loanAfterPay);
1068 Number const totalValueAfterPay = loanAfterPay->at(sfTotalValueOutstanding);
1069 Number const assetsTotalDeltaPay =
1070 Number(vaultAfterPay->at(sfAssetsTotal)) - assetsTotalBeforePay;
1071 Number const debtTotalDeltaPay =
1072 Number(brokerAfterPay->at(sfDebtTotal)) - debtTotalBeforePay;
1073 Number const totalValueDeltaPay = totalValueAfterPay - totalValueBeforePay;
1074
1075 // A regular, on-time payment has valueChange == 0, so instant-recognition
1076 // AssetsTotal is untouched and DebtTotal mirrors TotalValueOutstanding.
1077 BEAST_EXPECTS(
1078 assetsTotalDeltaPay == beast::kZero,
1079 "legacy vault regular payment must not change AssetsTotal; delta=" +
1080 to_string(assetsTotalDeltaPay));
1081 BEAST_EXPECTS(
1082 debtTotalDeltaPay == totalValueDeltaPay,
1083 "legacy vault DebtTotal delta must mirror TotalValueOutstanding delta; "
1084 "debtTotalDelta=" +
1085 to_string(debtTotalDeltaPay) + " totalValueDelta=" + to_string(totalValueDeltaPay));
1086
1087 // ---- LoanManage: impair, then default -- instant-recognition exposure expected ----
1088 auto const loanBeforeImpair = env.le(loanKeylet);
1089 BEAST_EXPECT(loanBeforeImpair);
1090 Number const totalValueBeforeImpair = loanBeforeImpair->at(sfTotalValueOutstanding);
1091 Number const managementFeeBeforeImpair = loanBeforeImpair->at(sfManagementFeeOutstanding);
1092 Number const expectedExposure = totalValueBeforeImpair - managementFeeBeforeImpair;
1093
1094 // With fixCleanup3_4_0, impairment is only allowed once the
1095 // payment is late. After the earlier LoanPay the due date advanced by
1096 // one interval, so use the current due date rather than startDate.
1097 std::uint32_t const dueDateBeforeImpair = loanBeforeImpair->at(sfNextPaymentDueDate);
1098 env.close(NetClock::time_point{NetClock::duration{dueDateBeforeImpair}} + 1s);
1099
1100 env(manage(lender, loanKeylet.key, tfLoanImpair), Ter(tesSUCCESS));
1101 env.close();
1102
1103 env.close(
1104 NetClock::time_point{NetClock::duration{dueDateBeforeImpair}} +
1105 std::chrono::seconds(gracePeriod) + 60s);
1106
1107 auto const vaultBeforeDefault = env.le(broker.vaultKeylet());
1108 auto const brokerBeforeDefault = env.le(broker.brokerKeylet());
1109 BEAST_EXPECT(vaultBeforeDefault && brokerBeforeDefault);
1110 Number const debtTotalBeforeDefault = brokerBeforeDefault->at(sfDebtTotal);
1111 Number const lossBeforeDefault = vaultBeforeDefault->at(sfLossUnrealized);
1112
1113 env(manage(lender, loanKeylet.key, tfLoanDefault), Ter(tesSUCCESS));
1114 env.close();
1115
1116 auto const vaultAfterDefault = env.le(broker.vaultKeylet());
1117 auto const brokerAfterDefault = env.le(broker.brokerKeylet());
1118 BEAST_EXPECT(vaultAfterDefault && brokerAfterDefault);
1119 Number const debtTotalDeltaDefault =
1120 Number(brokerAfterDefault->at(sfDebtTotal)) - debtTotalBeforeDefault;
1121 Number const lossDeltaDefault =
1122 Number(vaultAfterDefault->at(sfLossUnrealized)) - lossBeforeDefault;
1123
1124 BEAST_EXPECTS(
1125 debtTotalDeltaDefault == -expectedExposure,
1126 "legacy vault default must reduce DebtTotal by instant-recognition exposure; delta=" +
1127 to_string(debtTotalDeltaDefault) + " expected=" + to_string(expectedExposure));
1128 BEAST_EXPECTS(
1129 lossDeltaDefault == -expectedExposure,
1130 "legacy vault default must reverse the earlier impair's LossUnrealized exactly; "
1131 "delta=" +
1132 to_string(lossDeltaDefault) + " expected=" + to_string(expectedExposure));
1133
1134 // Confirm the Vault's LEVersion truly never got set, throughout.
1135 {
1136 auto const vaultSle = env.le(broker.vaultKeylet());
1137 BEAST_EXPECT(vaultSle);
1138 BEAST_EXPECT(!vaultSle->isFieldPresent(sfLEVersion));
1139 BEAST_EXPECT(getVaultVersion(vaultSle) == VaultVersion::Legacy);
1140 }
1141 }
1142
1143 // 4. End-to-end trajectory: LoanSet -> 2 LoanPays -> LoanManage(default),
1144 // entirely under the amendment, with independently hand-computed
1145 // expected AssetsTotal/DebtTotal/LossUnrealized/CoverAvailable values at
1146 // each step. 0% interest keeps the arithmetic exact and tractable; the
1147 // divergence from instant interest recognition is already covered directly by
1148 // testCashBasisLoanSetOrigination/LoanPay/LoanManage above, so this test
1149 // focuses purely on an independent, from-scratch trajectory check.
1150 void
1152 {
1153 testcase("cash-basis: end-to-end trajectory");
1154
1155 using namespace jtx;
1156 using namespace loan;
1157 using namespace std::chrono_literals;
1158
1159 PrettyAsset const xrpAsset{xrpIssue(), 1'000'000};
1160 BrokerParameters const brokerParams{
1161 .vaultDeposit = 100'000,
1162 .managementFeeRate = TenthBips16{0},
1163 };
1164
1165 Env env(*this, all_ | featureLendingProtocolV1_1);
1166
1167 Account const lender{"lender"};
1168 Account const borrower{"borrower"};
1169 env.fund(XRP(10'000'000), lender, borrower);
1170 env.close();
1171
1172 BrokerInfo const broker{createVaultAndBroker(env, xrpAsset, lender, brokerParams)};
1173
1174 // Hand computation (all values in XRP, drops == 1e-6 XRP):
1175 // Vault: AssetsTotal starts at 100'000 (the deposit).
1176 // Broker: DebtTotal starts at 0, CoverAvailable starts at 1'000
1177 // (BrokerParameters::defaults().coverDeposit).
1178 auto const vaultKeylet = broker.vaultKeylet();
1179 auto const brokerKeylet = broker.brokerKeylet();
1180
1181 // All the "human XRP unit" constants below (e.g. `100'000`) are
1182 // converted to raw native (drops) values via xrpAsset(...), since
1183 // that's how the ledger fields are actually denominated.
1184 auto const checkVaultBroker = [&](Number const& assetsTotalUnits,
1185 Number const& debtTotalUnits,
1186 Number const& lossUnrealizedUnits,
1187 Number const& coverAvailableUnits,
1188 char const* step) {
1189 Number const assetsTotal = xrpAsset(assetsTotalUnits).value();
1190 Number const debtTotal = xrpAsset(debtTotalUnits).value();
1191 Number const lossUnrealized = xrpAsset(lossUnrealizedUnits).value();
1192 Number const coverAvailable = xrpAsset(coverAvailableUnits).value();
1193
1194 auto const vaultSle = env.le(vaultKeylet);
1195 auto const brokerSle = env.le(brokerKeylet);
1196 BEAST_EXPECT(vaultSle && brokerSle);
1197 BEAST_EXPECTS(
1198 vaultSle->at(sfAssetsTotal) == assetsTotal,
1199 std::string(step) + ": AssetsTotal expected " + to_string(assetsTotal) + " got " +
1200 to_string(Number(vaultSle->at(sfAssetsTotal))));
1201 BEAST_EXPECTS(
1202 brokerSle->at(sfDebtTotal) == debtTotal,
1203 std::string(step) + ": DebtTotal expected " + to_string(debtTotal) + " got " +
1204 to_string(Number(brokerSle->at(sfDebtTotal))));
1205 BEAST_EXPECTS(
1206 vaultSle->at(sfLossUnrealized) == lossUnrealized,
1207 std::string(step) + ": LossUnrealized expected " + to_string(lossUnrealized) +
1208 " got " + to_string(Number(vaultSle->at(sfLossUnrealized))));
1209 BEAST_EXPECTS(
1210 brokerSle->at(sfCoverAvailable) == coverAvailable,
1211 std::string(step) + ": CoverAvailable expected " + to_string(coverAvailable) +
1212 " got " + to_string(Number(brokerSle->at(sfCoverAvailable))));
1213 };
1214
1215 checkVaultBroker(100'000, 0, 0, 1'000, "before LoanSet");
1216
1217 // Loan: principal=1200, 0% interest, 12 payments of 100 each, no fees.
1218 Number const principalRequest{1'200};
1219 std::uint32_t const paymentTotal = 12;
1220 std::uint32_t const paymentInterval = 600;
1221 std::uint32_t const gracePeriod = 60;
1222
1223 auto const brokerBeforeLoan = env.le(brokerKeylet);
1224 BEAST_EXPECT(brokerBeforeLoan);
1225 auto const loanSequence = brokerBeforeLoan->at(sfLoanSequence);
1226 auto const loanKeylet = keylet::loan(broker.brokerID, SeqProxy::rawSequence(loanSequence));
1227
1228 LoanParameters const loanParams{
1229 .account = borrower,
1230 .counter = lender,
1231 .principalRequest = principalRequest,
1232 .interest = TenthBips32{0},
1233 .payTotal = paymentTotal,
1234 .payInterval = paymentInterval,
1235 .gracePd = gracePeriod,
1236 };
1237 env(loanParams(env, broker));
1238 env.close();
1239
1240 // Origination (cash-basis): AssetsTotal += 0, DebtTotal += principal.
1241 checkVaultBroker(100'000, 1'200, 0, 1'000, "after LoanSet");
1242
1243 LoanState const state = getCurrentState(env, broker, loanKeylet);
1244 BEAST_EXPECT(state.periodicPayment == xrpAsset(100).value());
1245
1246 // Payment 1: principalPaid=100, interestPaid=0.
1247 // AssetsTotal += 0; DebtTotal -= 100.
1248 env(pay(borrower, loanKeylet.key, xrpAsset(100).value()), Ter(tesSUCCESS));
1249 env.close();
1250 checkVaultBroker(100'000, 1'100, 0, 1'000, "after payment 1");
1251
1252 // Payment 2: same as above.
1253 env(pay(borrower, loanKeylet.key, xrpAsset(100).value()), Ter(tesSUCCESS));
1254 env.close();
1255 checkVaultBroker(100'000, 1'000, 0, 1'000, "after payment 2");
1256
1257 // Default (no impair): principalOutstanding remaining is 1'000.
1258 // totalDefaultAmount (cash-basis) = PrincipalOutstanding = 1'000.
1259 // minimumCover = DebtTotal(1'000) * coverRateMin(10%) = 100.
1260 // covered = min(minimumCover * coverRateLiquidation(25%), totalDefaultAmount)
1261 // = min(25, 1'000) = 25.
1262 // defaultCovered = min(covered, CoverAvailable(1'000)) = 25.
1263 // vaultDefaultAmount = 1'000 - 25 = 975.
1264 // DebtTotal -= 1'000 -> 0. CoverAvailable -= 25 -> 975.
1265 // AssetsTotal -= 975 -> 99'025. LossUnrealized unaffected (never impaired).
1266 auto const loanBeforeDefault = env.le(loanKeylet);
1267 BEAST_EXPECT(loanBeforeDefault);
1268 BEAST_EXPECT(
1269 Number(loanBeforeDefault->at(sfPrincipalOutstanding)) == xrpAsset(1'000).value());
1270
1271 env.close(state.startDate + std::chrono::seconds((3 * paymentInterval) + gracePeriod) + 1s);
1272
1273 env(manage(lender, loanKeylet.key, tfLoanDefault), Ter(tesSUCCESS));
1274 env.close();
1275
1276 checkVaultBroker(99'025, 0, 0, 975, "after LoanManage(default)");
1277 }
1278
1279public:
1280 void
1291};
1292
1293BEAST_DEFINE_TESTSUITE(LoanCashBasis, tx, xrpl);
1294
1295} // namespace xrpl::test
TestcaseT testcase
Memberspace for declaring test cases.
Definition suite.h:155
std::chrono::time_point< NetClock > time_point
Definition chrono.h:48
std::chrono::duration< rep, period > duration
Definition chrono.h:47
Number is a floating point type that can represent a wide range of values.
Definition Number.h:351
static constexpr SeqProxy rawSequence(std::uint32_t v)
Factory function to return a sequence-based SeqProxy.
Definition SeqProxy.h:62
void run() override
Runs the suite.
Shared base for the Loan*_test family under src/test/app/lending/.
jtx::PrettyAsset createFundedIouAsset(jtx::Env &env, jtx::Account const &issuer, jtx::Account const &lender, jtx::Account const &borrower, Number const &lenderPay=100 '000 '000, Number const &borrowerPay=1 '000 '000)
FeatureBitset const all_
void advancePastDueDate(jtx::Env &env, Keylet const &loanKeylet)
BrokerInfo createVaultAndBroker(jtx::Env &env, jtx::PrettyAsset const &asset, jtx::Account const &lender, BrokerParameters const &params=BrokerParameters::defaults())
LoanState getCurrentState(jtx::Env const &env, BrokerInfo const &broker, Keylet const &loanKeylet)
Get the state without checking anything.
Immutable cryptographic account descriptor.
Definition jtx/Account.h:21
AccountID id() const
Returns the Account ID.
A transaction testing environment.
Definition Env.h:161
bool close(NetClock::time_point closeTime, std::optional< std::chrono::milliseconds > consensusDelay=std::nullopt)
Close and advance the ledger.
Definition Env.cpp:133
SLE::const_pointer le(Account const &account) const
Return an account root.
Definition Env.cpp:311
void fund(bool setDefaultRipple, STAmount const &amount, Account const &account)
Definition Env.cpp:323
void enableFeature(UInt256 const feature)
Definition Env.cpp:709
std::shared_ptr< STObject const > meta()
Return metadata for the last JTx.
Definition Env.cpp:538
std::shared_ptr< OpenView const > current() const
Returns the current ledger.
Definition Env.h:377
Set the fee on a JTx.
Definition fee.h:20
Set the regular signature on a JTx.
Definition sig.h:19
Set the expected result code for a JTx The test will fail if the code doesn't match.
Definition ter.h:18
T make_tuple(T... args)
constexpr Zero kZero
Definition Zero.h:30
Keylet loan(UInt256 const &loanBrokerID, SeqProxy const &loanSeq) noexcept
Definition Indexes.cpp:577
json::Value set(AccountID const &account, UInt256 const &vaultId, uint32_t flags)
std::vector< Credential > Credentials
UInt256 getNewDomain(std::shared_ptr< STObject const > const &meta)
json::Value setTx(AccountID const &account, Credentials const &credentials, std::optional< UInt256 > domain)
json::Value pay(AccountID const &account, AccountID const &to, AnyAmount amount)
Create a payment.
Definition pay.cpp:14
XrpT const XRP
Converts to XRP Issue or STAmount.
Definition amount.cpp:92
BEAST_DEFINE_TESTSUITE(AMMClawback, app, xrpl)
Use hash_* containers for keys that do not need a cryptographically secure hashing algorithm.
Definition algorithm.h:5
bool set(T &target, std::string const &name, Section const &section)
Set a value from a configuration Section If the named value is not found or doesn't parse as a T,...
Issue const & xrpIssue()
Returns an asset specifier that represents XRP.
Definition Issue.h:108
constexpr TenthBips32 percentageToTenthBips(std::uint32_t percentage)
Definition Protocol.h:127
TenthBips< std::uint32_t > TenthBips32
Definition Units.h:454
TenthBips< std::uint16_t > TenthBips16
Definition Units.h:453
std::string to_string(BaseUInt< Bits, Tag > const &a)
Definition base_uint.h:658
Number roundPeriodicPayment(Asset const &asset, Number const &periodicPayment, std::int32_t scale)
Ensure the periodic payment is always rounded consistently.
TERSubset< CanCvtToTER > TER
Definition TER.h:657
@ tecINVARIANT_FAILED
Definition TER.h:324
@ tecLIMIT_EXCEEDED
Definition TER.h:372
VaultVersion getVaultVersion(SLE::ConstRef vault)
Resolves a Vault's LEVersion.
@ tesSUCCESS
Definition TER.h:253
std::optional< std::uint32_t > vaultFlags