xrpld
Loading...
Searching...
No Matches
LoanPay_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/flags.h>
8#include <test/jtx/jtx_json.h>
9#include <test/jtx/noop.h>
10#include <test/jtx/pay.h>
11#include <test/jtx/ter.h>
12#include <test/jtx/trust.h>
13
14#include <xrpl/basics/Number.h>
15#include <xrpl/basics/chrono.h>
16#include <xrpl/beast/unit_test/suite.h>
17#include <xrpl/beast/utility/Journal.h>
18#include <xrpl/beast/utility/Zero.h>
19#include <xrpl/core/ServiceRegistry.h>
20#include <xrpl/json/json_value.h>
21#include <xrpl/ledger/OpenView.h>
22#include <xrpl/ledger/helpers/LendingHelpers.h>
23#include <xrpl/ledger/helpers/VaultHelpers.h>
24#include <xrpl/protocol/AccountID.h>
25#include <xrpl/protocol/Feature.h>
26#include <xrpl/protocol/Indexes.h>
27#include <xrpl/protocol/Issue.h>
28#include <xrpl/protocol/Keylet.h>
29#include <xrpl/protocol/LedgerFormats.h>
30#include <xrpl/protocol/Protocol.h>
31#include <xrpl/protocol/SField.h>
32#include <xrpl/protocol/STAmount.h>
33#include <xrpl/protocol/SeqProxy.h>
34#include <xrpl/protocol/TER.h>
35#include <xrpl/protocol/TxFlags.h>
36#include <xrpl/protocol/Units.h>
37#include <xrpl/tx/transactors/lending/LoanSet.h>
38
39#include <algorithm>
40#include <cstddef>
41#include <cstdint>
42#include <limits>
43#include <memory>
44#include <optional>
45#include <string>
46#include <type_traits>
47#include <vector>
48
49namespace xrpl::test {
50
52{
53private:
54 // An IOU environment with a funded issuer, lender and borrower.
56 {
58 jtx::Account const issuer{"issuer"};
59 jtx::Account const lender{"lender"};
60 jtx::Account const borrower{"borrower"};
62
65 FeatureBitset features,
66 Number const& trustLimit,
67 Number const& lenderAmount,
68 Number const& borrowerAmount)
69 : env{suite, features}, asset{issuer["USD"]}
70 {
71 using namespace jtx;
72 env.fund(XRP(100'000), issuer, lender, borrower);
73 env.close();
74 env(trust(lender, asset(trustLimit)));
75 env(trust(borrower, asset(trustLimit)));
76 env(pay(issuer, lender, asset(lenderAmount)));
77 env(pay(issuer, borrower, asset(borrowerAmount)));
78 env.close();
79 }
80 };
81
84 {
85 return all_ | featureLendingProtocolV1_1 | featureLendingProtocolV1_2;
86 }
87
88 // Scale-6 vault and no management fee; tests override what they need.
89 static BrokerParameters
91 {
92 BrokerParameters params;
93 params.vaultScale = 6;
95 return params;
96 }
97
104
105 // Originates a loan on broker; extra adds LoanSet fields (interest rates,
106 // fees).
107 template <class Principal, class... Extra>
108 Keylet
110 jtx::Env& env,
111 BrokerInfo const& broker,
112 jtx::Account const& borrower,
113 jtx::Account const& lender,
114 Principal&& principal,
115 LoanShape const& shape,
116 Extra&&... extra)
117 {
118 using namespace jtx;
119 using namespace loan;
120
121 auto const loanKeylet = nextLoanKeylet(env, broker);
122 env(set(borrower, broker.brokerID, std::forward<Principal>(principal), shape.flags),
123 Sig(sfCounterpartySignature, lender),
124 kPaymentTotal(shape.paymentTotal),
125 kPaymentInterval(shape.paymentInterval),
126 Fee(env.current()->fees().base * 2),
127 std::forward<Extra>(extra)...);
128 env.close();
129 return loanKeylet;
130 }
131
132 // Advances a year past the growth loan's start and pays it off in full at
133 // the maximum close interest, which grows AssetsTotal.
134 void
136 jtx::Env& env,
137 BrokerInfo const& broker,
138 jtx::Account const& borrower,
139 Keylet const& growthLoan,
140 Number const& maximum)
141 {
142 auto const growthState = getCurrentState(env, broker, growthLoan);
143 using Duration = NetClock::duration;
144 env.close(growthState.startDate + Duration{366 * 24 * 60 * 60});
145 env(jtx::loan::pay(borrower, growthLoan.key, broker.asset(maximum), tfLoanFullPayment));
146 env.close();
147 }
148
149 static Number
151 {
152 return loan->at(sfTotalValueOutstanding) - loan->at(sfPrincipalOutstanding) -
153 loan->at(sfManagementFeeOutstanding);
154 }
155
156 // In FixedPrecision the vault's unpaid balance is exactly the debt owed.
157 void
159 {
160 BEAST_EXPECT(
161 vault->at(sfAssetsTotal) - vault->at(sfAssetsAvailable) ==
162 loan->at(sfPrincipalOutstanding));
163 }
164
165#if LOAN_TODO
166 void
167 testLoanPayLateFullPaymentBypassesPenalties(FeatureBitset features)
168 {
169 testcase("LoanPay full payment skips late penalties");
170 using namespace jtx;
171 using namespace loan;
172 using namespace std::chrono_literals;
173
174 Env env(*this, features);
175
176 Account const issuer{"issuer"};
177 Account const lender{"lender"};
178 Account const borrower{"borrower"};
179
180 env.fund(XRP(1'000'000), issuer, lender, borrower);
181 env.close();
182
183 PrettyAsset const asset = issuer[iouCurrency];
184 env(trust(lender, asset(100'000'000)));
185 env(trust(borrower, asset(100'000'000)));
186 env(pay(issuer, lender, asset(50'000'000)));
187 env(pay(issuer, borrower, asset(5'000'000)));
188 env.close();
189
190 BrokerInfo broker{createVaultAndBroker(env, asset, lender)};
191
192 auto const loanSetFee = Fee(env.current()->fees().base * 2);
193
194 auto const brokerPreLoan = env.le(keylet::loanBroker(broker.brokerID));
195 if (BEAST_EXPECT(brokerPreLoan); !brokerPreLoan.has_value())
196 return;
197
198 auto const loanSequence = brokerPreLoan->at(sfLoanSequence);
199 auto const loanKeylet = keylet::loan(broker.brokerID, SeqProxy::rawSequence(loanSequence));
200
201 Number const principal = asset(1'000).value();
202 Number const serviceFee = asset(2).value();
203 Number const lateFee = asset(5).value();
204 Number const closeFee = asset(4).value();
205
206 env(set(borrower, broker.brokerID, principal),
207 Sig(sfCounterpartySignature, lender),
208 kLoanServiceFee(serviceFee),
209 kLatePaymentFee(lateFee),
210 kClosePaymentFee(closeFee),
214 kPaymentTotal(12),
215 kPaymentInterval(600),
216 kGracePeriod(0),
217 Fee(loanSetFee));
218 env.close();
219
220 auto state1 = getCurrentState(env, broker, loanKeylet);
221 if (!BEAST_EXPECT(state1.paymentRemaining > 1))
222 return;
223
224 using D = NetClock::duration;
225 using Tp = NetClock::time_point;
226 auto const overdueClose = Tp{D{state1.nextPaymentDate + state1.paymentInterval}};
227 env.close(overdueClose);
228
229 auto const brokerSle = env.le(keylet::loanBroker(broker.brokerID));
230 auto const loanSle = env.le(loanKeylet);
231 if (!BEAST_EXPECT(brokerSle && loanSle))
232 return;
233
234 auto state = getCurrentState(env, broker, loanKeylet);
235
236 TenthBips16 const managementFeeRate{brokerSle->at(sfManagementFeeRate)};
237 TenthBips32 const interestRateValue{loanSle->at(sfInterestRate)};
238 TenthBips32 const lateInterestRateValue{loanSle->at(sfLateInterestRate)};
239 TenthBips32 const closeInterestRateValue{loanSle->at(sfCloseInterestRate)};
240
241 Number const closePaymentFeeRounded =
242 roundToAsset(broker.asset, loanSle->at(sfClosePaymentFee), state.loanScale);
243 Number const latePaymentFeeRounded =
244 roundToAsset(broker.asset, loanSle->at(sfLatePaymentFee), state.loanScale);
245
246 auto const roundedLoanState = constructLoanState(
247 state.totalValue, state.principalOutstanding, state.managementFeeOutstanding);
248 Number const totalInterestOutstanding = roundedLoanState.interestDue;
249
250 auto const periodicRate = loanPeriodicRate(interestRateValue, state.paymentInterval);
251 auto const rawLoanState = computeTheoreticalLoanState(
252 env.current()->rules(),
253 state.periodicPayment,
254 periodicRate,
255 state.paymentRemaining,
256 managementFeeRate);
257
258 auto const parentCloseTime = env.current()->parentCloseTime();
259 auto const startDateSeconds =
260 static_cast<std::uint32_t>(state.startDate.time_since_epoch().count());
261
262 Number const fullPaymentInterest = computeFullPaymentInterest(
263 rawLoanState.principalOutstanding,
264 periodicRate,
265 parentCloseTime,
266 state.paymentInterval,
267 state.previousPaymentDate,
268 startDateSeconds,
269 closeInterestRateValue);
270
271 Number const roundedFullInterestAmount =
272 roundToAsset(broker.asset, fullPaymentInterest, state.loanScale);
273 Number const roundedFullManagementFee = computeManagementFee(
274 broker.asset, roundedFullInterestAmount, managementFeeRate, state.loanScale);
275 Number const roundedFullInterest = roundedFullInterestAmount - roundedFullManagementFee;
276
277 Number const trackedValueDelta =
278 state.principalOutstanding + totalInterestOutstanding + state.managementFeeOutstanding;
279 Number const untrackedManagementFee =
280 closePaymentFeeRounded + roundedFullManagementFee - state.managementFeeOutstanding;
281 Number const untrackedInterest = roundedFullInterest - totalInterestOutstanding;
282
283 Number const baseFullDue = trackedValueDelta + untrackedInterest + untrackedManagementFee;
284 BEAST_EXPECT(baseFullDue == roundToAsset(broker.asset, baseFullDue, state.loanScale));
285
286 auto const overdueSeconds =
287 parentCloseTime.time_since_epoch().count() - state.nextPaymentDate;
288 if (!BEAST_EXPECT(overdueSeconds > 0))
289 return;
290
291 Number const overdueRate = loanPeriodicRate(lateInterestRateValue, overdueSeconds);
292 Number const lateInterestRaw = state.principalOutstanding * overdueRate;
293 Number const lateInterestRounded =
294 roundToAsset(broker.asset, lateInterestRaw, state.loanScale);
295 Number const lateManagementFeeRounded = computeManagementFee(
296 broker.asset, lateInterestRounded, managementFeeRate, state.loanScale);
297 Number const penaltyDue =
298 lateInterestRounded + lateManagementFeeRounded + latePaymentFeeRounded;
299 BEAST_EXPECT(penaltyDue > Number{});
300
301 auto const balanceBefore = env.balance(borrower, broker.asset).number();
302
303 STAmount const paymentAmount{broker.asset.raw(), baseFullDue};
304 env(pay(borrower, loanKeylet.key, paymentAmount, tfLoanFullPayment));
305 env.close();
306
307 if (auto const meta = env.meta(); BEAST_EXPECT(meta))
308 BEAST_EXPECT(meta->at(sfTransactionResult) == tesSUCCESS);
309
310 auto const balanceAfter = env.balance(borrower, broker.asset).number();
311 Number const actualPaid = balanceBefore - balanceAfter;
312 BEAST_EXPECT(actualPaid == baseFullDue);
313
314 Number const expectedWithPenalty = baseFullDue + penaltyDue;
315 BEAST_EXPECT(expectedWithPenalty > actualPaid);
316 BEAST_EXPECT(expectedWithPenalty - actualPaid == penaltyDue);
317 }
318#endif
319
320 void
322 {
323 testcase("testOverpaymentManagementFee");
324
325 using namespace jtx;
326 using namespace loan;
327
328 Env env{*this, features};
329
330 Account const lender{"lender"}, borrower{"borrower"};
331
332 env.fund(XRP(10'000'000), lender, borrower);
333 env.close();
334
335 PrettyAsset const asset{xrpIssue(), 1000};
336
337 auto const result = createVaultAndBroker(
338 env,
339 asset,
340 lender,
341 {
342 .vaultDeposit = asset(100'000).value(),
343 .managementFeeRate = TenthBips16(10'000),
344 });
345
346 auto const loanSetFee = Fee(env.current()->fees().base * 2);
347
348 auto const brokerSle = env.le(result.brokerKeylet());
349 if (!BEAST_EXPECT(brokerSle))
350 return;
351 auto const loanKeylet = keylet::loan(
352 result.brokerKeylet().key, SeqProxy::rawSequence(brokerSle->at(sfLoanSequence)));
353 env(loan::set(
354 borrower, result.brokerKeylet().key, asset(10'000).value(), tfLoanOverpayment),
355 Sig(sfCounterpartySignature, lender),
356 loan::kPaymentInterval(86400 * 30),
359 loanSetFee);
360
361 // From calculator
362 auto const expectedOverpaymentManagementFee = Number{33333, 0};
363 auto const loanBrokerBalanceBefore = env.balance(lender);
364
365 auto const loanPayFee = Fee(env.current()->fees().base * 2);
366 env(pay(borrower, loanKeylet.key, asset(5'000).value(), tfLoanOverpayment), loanPayFee);
367 env.close();
368
369 BEAST_EXPECTS(
370 env.balance(lender) - loanBrokerBalanceBefore == expectedOverpaymentManagementFee,
371 "overpayment management fee mismatch; expected:" +
372 to_string(expectedOverpaymentManagementFee) +
373 " got: " + to_string(env.balance(lender) - loanBrokerBalanceBefore));
374 }
375
376 void
378 {
379 bool const feeCapped = features[fixCleanup3_1_3];
380
381 // From FIND-005
382 testcase << "DoS LoanPay: fee calculation " << (feeCapped ? "capped" : "uncapped");
383
384 using namespace jtx;
385 using namespace std::chrono_literals;
386 using namespace lending;
387 Env env(*this, features);
388
389 Account const issuer{"issuer"};
390 Account const lender{"lender"};
391 Account const borrower{"borrower"};
392
393 env.fund(XRP(1'000'000), issuer, lender, borrower);
394 env.close();
395
396 BEAST_EXPECT(feeCapped == env.current()->rules().enabled(fixCleanup3_1_3));
397
398 PrettyAsset const iouAsset = issuer[iouCurrency_];
399 env(trust(lender, iouAsset(100'000'000)));
400 env(trust(borrower, iouAsset(100'000'000)));
401 env(pay(issuer, lender, iouAsset(10'000'000)));
402 env(pay(issuer, borrower, iouAsset(1'000)));
403 env.close();
404
405 BrokerInfo const broker{createVaultAndBroker(env, iouAsset, lender)};
406
407 using namespace loan;
408
409 auto const loanSetFee = Fee(env.current()->fees().base * 2);
410 Number const principalRequest{3959'37, -2};
411 auto const baseFee = env.current()->fees().base;
412
413 auto const createJson = env.json(
414 set(borrower, broker.brokerID, principalRequest),
415 Fee(loanSetFee),
416 Json(sfCounterpartySignature, json::ValueType::Object),
417 kClosePaymentFee(0),
418 kGracePeriod(60),
419 kInterestRate(TenthBips32(20930)),
420 kLateInterestRate(TenthBips32(77049)),
421 kLatePaymentFee(0),
422 kLoanServiceFee(0),
423 kOverpaymentFee(TenthBips32(7)),
424 kOverpaymentInterestRate(TenthBips32(66653)),
425 kPaymentInterval(60),
426 kPaymentTotal(3239184));
427
428 // There are enough payments due on this loan that it only needs to be
429 // created once, and can be paid on multiple times. Just don't create a
430 // gazillion test cases.
431 auto const keylet = nextLoanKeylet(env, broker);
432
433 env(createJson, Sig(sfCounterpartySignature, lender));
434 env.close();
435
436 auto const roundedPayment = [&] {
437 auto const stateBefore = getCurrentState(env, broker, keylet);
438 BEAST_EXPECT(stateBefore.paymentRemaining == 3239184);
439 BEAST_EXPECT(stateBefore.paymentRemaining > kLoanMaximumPaymentsPerTransaction);
440
441 return roundToAsset(
442 iouAsset,
443 stateBefore.periodicPayment,
444 stateBefore.loanScale,
446 }();
447
448 auto const test =
449 [&](int const payFactor, int const feeFactor, TER const expectedTer = tesSUCCESS) {
450 auto const stateBefore = getCurrentState(env, broker, keylet);
451 BEAST_EXPECT(stateBefore.paymentRemaining <= 3239184);
452 BEAST_EXPECT(stateBefore.paymentRemaining > kLoanMaximumPaymentsPerTransaction);
453
454 Number const amount = roundedPayment * payFactor;
455 auto const loanPayTx =
456 env.json(pay(borrower, keylet.key, STAmount{broker.asset, amount}));
457 XRPAmount const payFee{baseFee * feeFactor};
458 env(loanPayTx, Ter(expectedTer), Fee(payFee));
459 env.close();
460 auto const expectedChange = isTesSuccess(expectedTer)
461 ? std::min(kLoanMaximumPaymentsPerTransaction, payFactor)
462 : 0;
463
464 auto const stateAfter = getCurrentState(env, broker, keylet);
465 BEAST_EXPECT(
466 stateAfter.paymentRemaining == stateBefore.paymentRemaining - expectedChange);
467 };
468
469 static constexpr std::int64_t kMaxFeeIncrements =
470 kLoanMaximumPaymentsPerTransaction / kLoanPaymentsPerFeeIncrement;
471
472 TER const failWithoutFix = feeCapped ? (TER)tesSUCCESS : (TER)telINSUF_FEE_P;
473
474 // * Amount well above threshold -> capped fee
475 // The original test case - way over the limit - more fee is always ok
476 test(1819878, 363976);
477 // The capped fee is only sufficient if the amendment is enabled.
478 test(1819878, kMaxFeeIncrements, failWithoutFix);
479
480 // * Amount exactly at threshold -> capped fee
481 test(kLoanMaximumPaymentsPerTransaction, kMaxFeeIncrements);
482 // More fee is always ok
483 test(kLoanMaximumPaymentsPerTransaction, kMaxFeeIncrements + 10);
484
485 // * Amount below threshold -> normal calculation
486 test(1, 1);
487 test(kLoanPaymentsPerFeeIncrement * 2, 2);
488 test(0, 0, temBAD_AMOUNT);
489 test(0, 1, temBAD_AMOUNT);
490 // Fee difference rounds evenly
491 test(
492 kLoanMaximumPaymentsPerTransaction - 10,
493 ((kLoanMaximumPaymentsPerTransaction - 10) / kLoanPaymentsPerFeeIncrement) - 1,
495 test(
496 kLoanMaximumPaymentsPerTransaction - 10,
497 ((kLoanMaximumPaymentsPerTransaction - 10) / kLoanPaymentsPerFeeIncrement));
498 // More fee is always ok
499 test(
500 kLoanMaximumPaymentsPerTransaction - 10,
501 ((kLoanMaximumPaymentsPerTransaction - 10) / kLoanPaymentsPerFeeIncrement) + 3);
502 // Fee rounds up
503 for (int under = 1; under < kLoanPaymentsPerFeeIncrement; ++under)
504 {
505 test(kLoanMaximumPaymentsPerTransaction - under, kMaxFeeIncrements - 1, telINSUF_FEE_P);
506 test(kLoanMaximumPaymentsPerTransaction - under, kMaxFeeIncrements);
507 }
508 // Only when you get one less fee increment can you pay less
509 test(
510 kLoanMaximumPaymentsPerTransaction - kLoanPaymentsPerFeeIncrement,
511 kMaxFeeIncrements - 1);
512 // And again, more fee is always ok.
513 test(kLoanMaximumPaymentsPerTransaction - kLoanPaymentsPerFeeIncrement, kMaxFeeIncrements);
514 }
515
516 // A LoanSet with InterestRate = 1 (0.001% annualized, the minimum non-zero
517 // rate). At such a near-zero rate the closed-form payment factor
518 // (1 + r)^n - 1 cancels catastrophically.
519 //
520 // Without fixCleanup3_2_0 the resulting amortization is degenerate and the
521 // LoanSet is rejected with tecPRECISION_LOSS (no loan created). With the
522 // amendment, computePowerMinusOneHybrid uses a numerically-stable series
523 // expansion, so the loan is created and the scheduled payments
524 // (2 * periodicPayment) cover the principal — no economic underpayment
525 // (yield theft).
526 //
527 // The test runs the same LoanSet under both amendment settings and pins the
528 // exact outcome for each.
529 void
531 {
532 testcase("LoanSet near-zero interest rate covers principal");
533
534 using namespace jtx;
535 using namespace loan;
536
537 Number const principalRequested{1000};
538
539 struct Result
540 {
541 TER ter = tesSUCCESS;
542 bool created = false;
543 std::int32_t loanScale = 0;
544 Number principal;
545 Number totalValue;
546 Number managementFee;
547 Number periodicPayment;
548 };
549
550 auto const runScenario = [&](FeatureBitset features, TER expectedTer) -> Result {
551 Env env(*this, features);
552
553 Account const issuer{"issuer"};
554 Account const lender{"vaultOwner"};
555 Account const borrower{"borrower"};
556
557 PrettyAsset const iouAsset = createFundedRippleIouAsset(env, issuer, lender, borrower);
558
559 auto const broker = createVaultAndBroker(
560 env,
561 iouAsset,
562 lender,
563 {.vaultDeposit = 100'000, .debtMax = 0, .managementFeeRate = TenthBips16{0}});
564
565 auto const brokerSle = env.le(broker.brokerKeylet());
566 BEAST_EXPECT(brokerSle);
567 auto const loanSequence = brokerSle ? brokerSle->at(sfLoanSequence) : 0;
568 auto const loanKeylet =
569 keylet::loan(broker.brokerID, SeqProxy::rawSequence(loanSequence));
570
571 env(set(borrower, broker.brokerID, principalRequested),
572 Sig(sfCounterpartySignature, lender),
573 kInterestRate(TenthBips32{1}),
574 kPaymentTotal(2),
575 kPaymentInterval(400),
576 Fee(env.current()->fees().base * 2),
577 Ter(expectedTer));
578 env.close();
579
580 Result r;
581 r.ter = env.ter();
582 if (auto const loanSle = env.le(loanKeylet))
583 {
584 r.created = true;
585 r.loanScale = loanSle->at(sfLoanScale);
586 r.principal = loanSle->at(sfPrincipalOutstanding);
587 r.totalValue = loanSle->at(sfTotalValueOutstanding);
588 r.managementFee = loanSle->at(sfManagementFeeOutstanding);
589 r.periodicPayment = loanSle->at(sfPeriodicPayment);
590 }
591 return r;
592 };
593
594 Result const fixed = runScenario(all_, tesSUCCESS);
595 Result const legacy = runScenario(all_ - fixCleanup3_2_0, tecPRECISION_LOSS);
596
597 // Without the amendment, the catastrophically-cancelling closed-form
598 // payment factor produces a degenerate amortization that fails
599 // checkLoanGuards: the LoanSet is rejected with tecPRECISION_LOSS and no
600 // loan is created.
601 BEAST_EXPECT(legacy.ter == tecPRECISION_LOSS);
602 BEAST_EXPECT(!legacy.created);
603
604 // With the amendment the stable series expansion produces a valid loan
605 // at loanScale -10.
606 BEAST_EXPECT(fixed.ter == tesSUCCESS);
607 BEAST_EXPECT(fixed.created);
608 BEAST_EXPECT(fixed.loanScale == -10);
609 BEAST_EXPECT(fixed.principal == principalRequested);
610 BEAST_EXPECT((fixed.totalValue == Number{10000000001903, -10}));
611 BEAST_EXPECT(fixed.managementFee == beast::kZero);
612
613 // Periodic payment from the numerically-stable series expansion, and the
614 // scheduled total (2 * periodicPayment) which exceeds the 1000 principal
615 // — no economic underpayment / yield theft.
616 BEAST_EXPECT((fixed.periodicPayment == Number{5000000000951293762, -16}));
617 BEAST_EXPECT((fixed.periodicPayment * 2 == Number{1000000000190258752, -15}));
618 BEAST_EXPECT(fixed.periodicPayment * 2 > principalRequested);
619 }
620
621 void
623 {
624 // For FIND-013
625 testcase << "Prevent nextPaymentDueDate overflow";
626
627 using namespace jtx;
628 using namespace std::chrono_literals;
629 using namespace lending;
630 Env env{*this, features};
631
632 Account const issuer{"issuer"};
633 Account const lender{"lender"};
634 Account const borrower{"borrower"};
635
636 PrettyAsset const iouAsset =
637 createFundedIouAsset(env, issuer, lender, borrower, 100'000'000, 10'000'000);
638
639 BrokerParameters const brokerParams{.debtMax = Number{0}, .coverRateMin = TenthBips32{1}};
640 BrokerInfo broker{createVaultAndBroker(env, iouAsset, lender, brokerParams)};
641
642 using namespace loan;
643
644 auto const loanSetFee = Fee(env.current()->fees().base * 2);
645
646 using TimeType = decltype(sfNextPaymentDueDate)::type::value_type;
648 constexpr TimeType kMaxTime = std::numeric_limits<TimeType>::max();
649 static_assert(kMaxTime == 4'294'967'295);
650
651 auto const baseJson = [&] {
652 auto createJson = env.json(
653 set(borrower, broker.brokerID, Number{55524'81, -2}),
654 Fee(loanSetFee),
655 kClosePaymentFee(0),
656 kGracePeriod(LoanSet::kDefaultGracePeriod),
657 kInterestRate(TenthBips32(12833)),
658 kLateInterestRate(TenthBips32(77048)),
659 kLatePaymentFee(0),
660 kLoanOriginationFee(218),
661 Json(sfCounterpartySignature, json::ValueType::Object));
662
663 createJson.removeMember(sfSequence.getJsonName());
664
665 return createJson;
666 }();
667
668 auto const baseFee = env.current()->fees().base;
669
670 auto parentCloseTime = [&] {
671 return env.current()->parentCloseTime().time_since_epoch().count();
672 };
673 auto const maxLoanTime = [&] {
674 auto const startDate = parentCloseTime();
675
676 BEAST_EXPECT(startDate >= 50);
677
678 return kMaxTime - startDate;
679 };
680
681 {
682 // straight-up overflow: interval
683 auto const interval = maxLoanTime() + 1;
684 auto const total = 1;
685 auto const createJson =
686 env.json(baseJson, kPaymentInterval(interval), kPaymentTotal(total));
687
688 env(createJson, Sig(sfCounterpartySignature, lender), Ter(tecKILLED));
689 env.close();
690 }
691 {
692 // straight-up overflow: total
693 // min interval is 60
694 auto const interval = 60;
695 auto const total = maxLoanTime() + 1;
696 auto const createJson =
697 env.json(baseJson, kPaymentInterval(interval), kPaymentTotal(total));
698
699 env(createJson, Sig(sfCounterpartySignature, lender), Ter(tecKILLED));
700 env.close();
701 }
702 {
703 // straight-up overflow: grace period
704 // min interval is 60
705 auto const interval = maxLoanTime() + 1;
706 auto const total = 1;
707 auto const grace = interval;
708 auto const createJson = env.json(
709 baseJson, kPaymentInterval(interval), kPaymentTotal(total), kGracePeriod(grace));
710
711 // The grace period can't be larger than the interval.
712 env(createJson, Sig(sfCounterpartySignature, lender), Ter(tecKILLED));
713 env.close();
714 }
715 {
716 // Overflow with multiplication of a few large intervals
717 auto const interval = 1'000'000'000;
718 auto const total = 10;
719 auto const createJson =
720 env.json(baseJson, kPaymentInterval(interval), kPaymentTotal(total));
721
722 env(createJson, Sig(sfCounterpartySignature, lender), Ter(tecKILLED));
723 env.close();
724 }
725 {
726 // Overflow with multiplication of many small payments
727 // min interval is 60
728 auto const interval = 60;
729 auto const total = 1'000'000'000;
730 auto const createJson =
731 env.json(baseJson, kPaymentInterval(interval), kPaymentTotal(total));
732
733 env(createJson, Sig(sfCounterpartySignature, lender), Ter(tecKILLED));
734 env.close();
735 }
736 {
737 // Overflow with an absurdly large grace period
738 // min interval is 60
739 auto const total = 60;
740 auto const interval = (maxLoanTime() - total) / total;
741 auto const grace = interval;
742 auto const createJson = env.json(
743 baseJson, kPaymentInterval(interval), kPaymentTotal(total), kGracePeriod(grace));
744
745 env(createJson, Sig(sfCounterpartySignature, lender), Ter(tecKILLED));
746 env.close();
747 }
748 {
749 // Start date when the ledger is closed will be larger
750 auto const keylet = nextLoanKeylet(env, broker);
751
752 auto const grace = 100;
753 auto const interval = maxLoanTime() - grace;
754 auto const total = 1;
755 auto const createJson = env.json(
756 baseJson, kPaymentInterval(interval), kPaymentTotal(total), kGracePeriod(grace));
757
758 env(createJson, Sig(sfCounterpartySignature, lender), Ter(tesSUCCESS));
759 env.close();
760
761 // The transaction is killed in the closed ledger
762 auto const meta = env.meta();
763 if (BEAST_EXPECT(meta))
764 {
765 BEAST_EXPECT(meta->at(sfTransactionResult) == tecKILLED);
766 }
767
768 // If the transaction had succeeded, the loan would exist
769 auto const loanSle = env.le(keylet);
770 // but it doesn't
771 BEAST_EXPECT(!loanSle);
772 }
773 {
774 // Start date when the ledger is closed will be larger
775 auto const keylet = nextLoanKeylet(env, broker);
776
777 auto const closeStartDate = ((parentCloseTime() / 10) + 1) * 10;
778 auto const grace = 5'000;
779 auto const interval = kMaxTime - closeStartDate - grace;
780 auto const total = 1;
781 auto const createJson = env.json(
782 baseJson, kPaymentInterval(interval), kPaymentTotal(total), kGracePeriod(grace));
783
784 env(createJson, Sig(sfCounterpartySignature, lender), Ter(tesSUCCESS));
785 env.close();
786
787 // The transaction succeeds in the closed ledger
788 auto const meta = env.meta();
789 if (BEAST_EXPECT(meta))
790 {
791 BEAST_EXPECT(meta->at(sfTransactionResult) == tesSUCCESS);
792 }
793
794 // This loan exists
795 auto const afterState = getCurrentState(env, broker, keylet);
796 BEAST_EXPECT(afterState.nextPaymentDate == kMaxTime - grace);
797 BEAST_EXPECT(afterState.previousPaymentDate == 0);
798 BEAST_EXPECT(afterState.paymentRemaining == 1);
799 }
800
801 {
802 // Ensure the borrower has funds to pay back the loan
803 env(pay(issuer, borrower, iouAsset(Number{1'055'524'81, -2})));
804
805 // Start date when the ledger is closed will be larger
806 auto const closeStartDate = ((parentCloseTime() / 10) + 1) * 10;
807 auto const grace = 5'000;
808 auto const maxLoanTime = kMaxTime - closeStartDate - grace;
809 auto const total = [&] {
810 if (maxLoanTime % 5 == 0)
811 return 5;
812 if (maxLoanTime % 3 == 0)
813 return 3;
814 if (maxLoanTime % 2 == 0)
815 return 2;
816 return 0;
817 }();
818 if (!BEAST_EXPECT(total != 0))
819 return;
820
821 auto const brokerState = env.le(keylet::loanBroker(broker.brokerID));
822 if (!BEAST_EXPECT(brokerState))
823 return;
824 // Intentionally shadow the outer values
825 auto const loanSequence = brokerState->at(sfLoanSequence);
826 auto const keylet = keylet::loan(broker.brokerID, SeqProxy::rawSequence(loanSequence));
827
828 auto const interval = maxLoanTime / total;
829 auto const createJson = env.json(
830 baseJson, kPaymentInterval(interval), kPaymentTotal(total), kGracePeriod(grace));
831
832 env(createJson, Sig(sfCounterpartySignature, lender), Ter(tesSUCCESS));
833 env.close();
834
835 // This loan exists
836 auto const beforeState = getCurrentState(env, broker, keylet);
837 BEAST_EXPECT(beforeState.nextPaymentDate == closeStartDate + interval);
838 BEAST_EXPECT(beforeState.previousPaymentDate == 0);
839 BEAST_EXPECT(beforeState.paymentRemaining == total);
840 BEAST_EXPECT(beforeState.periodicPayment > 0);
841
842 // pay all but the last payment
843 {
845 Number const payment = beforeState.periodicPayment * (total - 1);
846 XRPAmount const payFee{baseFee * ((total - 1) / kLoanPaymentsPerFeeIncrement + 1)};
847 STAmount const paymentAmount =
848 roundToScale(STAmount{broker.asset, payment}, beforeState.loanScale);
849 auto const loanPayTx =
850 env.json(pay(borrower, keylet.key, paymentAmount), Fee(payFee));
851 env(loanPayTx, Ter(tesSUCCESS));
852 env.close();
853 }
854
855 // The loan is on the last payment
856 auto const afterState = getCurrentState(env, broker, keylet);
857 BEAST_EXPECT(afterState.paymentRemaining == 1);
858 BEAST_EXPECT(afterState.nextPaymentDate == kMaxTime - grace);
859 BEAST_EXPECT(afterState.previousPaymentDate == kMaxTime - grace - interval);
860 }
861 }
862
863 // Which pseudo-account is left holding an unauthorized trust line when the
864 // repayment lands.
865 enum class UnauthorizedPayee {
866 // The vault's own line, as VaultCreate leaves it.
868 // Same vault, but the issuer authorized the line by hand first.
870 // Vault line authorized, broker owner unable to take the fee, so the
871 // fee goes to the loan broker's pseudo-account instead.
873 };
874
875 // A vault holding an IOU whose issuer requires authorization ends up with
876 // its own trust line unauthorized: VaultCreate opens the line without the
877 // auth flag, and the pseudo-account has no key to sign a TrustSet for
878 // itself. Neither deposits nor loan origination look at that line, so the
879 // vault appears to work right up to the first repayment, which is the only
880 // step that has to credit the vault back.
881 //
882 // The loan broker's pseudo-account has the same defect for the same reason,
883 // and LoanPay reaches it whenever the broker owner cannot take the fee.
884 //
885 // The issuer can still repair either line by hand, because TrustSet accepts
886 // a line that already exists even when its owner is a pseudo-account.
887 void
889 {
890 using namespace jtx;
891
892 Account const issuer{"issuer"};
893 Account const lender{"lender"};
894 Account const borrower{"borrower"};
895
896 auto const runTestCases = [&](FeatureBitset features, UnauthorizedPayee payee) {
897 bool const pseudoExempt = features[fixCleanup3_4_0];
898 // With the vault's line repaired by the issuer, the only remaining
899 // unauthorized payee is the broker's pseudo-account.
900 bool const expectSuccess = pseudoExempt || payee == UnauthorizedPayee::VaultAuthorized;
901
902 auto const payeeLabel = [payee] -> char const* {
903 switch (payee)
904 {
906 return "vault";
908 return "vault authorized by the issuer";
910 return "loan broker";
911 }
912 return ""; // LCOV_EXCL_LINE
913 }();
914
915 testcase << "LoanPay crediting an unauthorized " << payeeLabel << ": pseudo-account "
916 << (pseudoExempt ? "exempt" : "not exempt");
917
918 Env env{*this, features};
919
920 env.fund(XRP(1'000'000), issuer, lender, borrower);
921 env.close();
922
923 env(fset(issuer, asfRequireAuth));
924 env.close();
925
926 PrettyAsset const asset = issuer[iouCurrency_];
927 env(trust(lender, asset(100'000'000)));
928 env(trust(borrower, asset(100'000'000)));
929 env.close();
930
931 // Authorize the two participants. Nothing asks the issuer to also
932 // authorize the vault, which is the whole point of this test.
933 env(trust(issuer, asset(0), lender, tfSetfAuth));
934 env(trust(issuer, asset(0), borrower, tfSetfAuth));
935 env.close();
936
937 env(pay(issuer, lender, asset(10'000'000)));
938 env(pay(issuer, borrower, asset(10'000)));
939 env.close();
940
941 // Creating the vault and funding it with deposits succeeds even
942 // though the vault cannot be authorized to hold the asset.
943 BrokerInfo const broker{createVaultAndBroker(env, asset, lender)};
944
945 auto const vaultSle = env.le(broker.vaultKeylet());
946 auto const brokerSle = env.le(broker.brokerKeylet());
947 if (!BEAST_EXPECT(vaultSle && brokerSle))
948 return;
949
950 Account const vaultPseudo{"vault pseudo-account", vaultSle->at(sfAccount)};
951 Account const brokerPseudo{"broker pseudo-account", brokerSle->at(sfAccount)};
952
953 auto const lineIsAuthorized = [&](Account const& holder) -> bool {
954 auto const line = env.le(keylet::trustLine(holder, asset.raw().get<Issue>()));
955 if (!BEAST_EXPECT(line))
956 return false;
957 return line->isFlag(holder.id() > issuer.id() ? lsfLowAuth : lsfHighAuth);
958 };
959
960 BEAST_EXPECT(!lineIsAuthorized(vaultPseudo));
961 BEAST_EXPECT(!lineIsAuthorized(brokerPseudo));
962
963 if (payee != UnauthorizedPayee::Vault)
964 {
965 env(trust(issuer, asset(0), vaultPseudo, tfSetfAuth));
966 env.close();
967 BEAST_EXPECT(lineIsAuthorized(vaultPseudo));
968 }
969
970 using namespace loan;
971
972 // The service fee guarantees the broker is owed something on the
973 // first payment, so the broker leg of the transfer is exercised.
974 Number const serviceFee = asset(2).value();
975 auto const loanKeylet = nextLoanKeylet(env, broker);
976 env(set(borrower, broker.brokerID, asset(1'000).value()),
977 Sig(sfCounterpartySignature, lender),
978 kLoanServiceFee(serviceFee),
979 kInterestRate(percentageToTenthBips(12)),
980 kPaymentTotal(12),
981 kPaymentInterval(600),
982 Fee(env.current()->fees().base * 2));
983 env.close();
984
985 // Paying the principal out of the vault never needed authorization.
986 BEAST_EXPECT(env.le(loanKeylet));
987
988 if (payee == UnauthorizedPayee::Broker)
989 {
990 // A deep-frozen owner cannot take the fee, so LoanPay pays it
991 // into the broker's pseudo-account instead.
992 env(trust(issuer, asset(0), lender, tfSetFreeze | tfSetDeepFreeze));
993 env.close();
994 }
995
996 auto const state = getCurrentState(env, broker, loanKeylet);
997 STAmount const payment{
998 broker.asset,
1000 broker.asset, state.periodicPayment + serviceFee, state.loanScale)};
1001
1002 // Repayment turns an outstanding loan back into cash the vault can
1003 // lend again, so AssetsAvailable is what moves. AssetsTotal already
1004 // counted the loan.
1005 auto const assetsAvailable = [&] -> Number {
1006 auto const sle = env.le(broker.vaultKeylet());
1007 if (!BEAST_EXPECT(sle))
1008 return Number{};
1009 return sle->at(sfAssetsAvailable);
1010 };
1011
1012 auto const borrowerBefore = env.balance(borrower, asset).number();
1013 auto const vaultBefore = env.balance(vaultPseudo, asset).number();
1014 auto const brokerBefore = env.balance(brokerPseudo, asset).number();
1015 auto const assetsAvailableBefore = assetsAvailable();
1016
1017 env(pay(borrower, loanKeylet.key, payment),
1018 Ter(expectSuccess ? TER{tesSUCCESS} : TER{tecNO_AUTH}));
1019 env.close();
1020
1021 if (expectSuccess)
1022 {
1023 BEAST_EXPECT(env.balance(borrower, asset).number() < borrowerBefore);
1024 BEAST_EXPECT(env.balance(vaultPseudo, asset).number() > vaultBefore);
1025 BEAST_EXPECT(assetsAvailable() > assetsAvailableBefore);
1026 // Confirms the broker variant really did route the fee to the
1027 // pseudo-account rather than to the owner.
1028 BEAST_EXPECT(
1029 (env.balance(brokerPseudo, asset).number() > brokerBefore) ==
1030 (payee == UnauthorizedPayee::Broker));
1031
1032 // The payee is skipped by the check, not authorized by it: the line that just
1033 // took the credit is still missing its auth flag.
1034 if (payee == UnauthorizedPayee::Vault)
1035 BEAST_EXPECT(!lineIsAuthorized(vaultPseudo));
1036 if (payee == UnauthorizedPayee::Broker)
1037 BEAST_EXPECT(!lineIsAuthorized(brokerPseudo));
1038 }
1039 else
1040 {
1041 // A rejected repayment must leave every balance untouched.
1042 BEAST_EXPECT(env.balance(borrower, asset).number() == borrowerBefore);
1043 BEAST_EXPECT(env.balance(vaultPseudo, asset).number() == vaultBefore);
1044 BEAST_EXPECT(env.balance(brokerPseudo, asset).number() == brokerBefore);
1045 BEAST_EXPECT(assetsAvailable() == assetsAvailableBefore);
1046 }
1047 };
1048
1049 for (auto const& features : {all_, all_ - fixCleanup3_4_0})
1050 {
1051 runTestCases(features, UnauthorizedPayee::Vault);
1052 runTestCases(features, UnauthorizedPayee::VaultAuthorized);
1053 runTestCases(features, UnauthorizedPayee::Broker);
1054 }
1055 }
1056
1057 void
1059 {
1060 // Regression test: LoanPay::doApply's fund-conservation check used to
1061 // read XRP balances via accountHolds(..., SpendableHandling::
1062 // FullBalance), which for XRP always defers to xrpLiquid (balance
1063 // minus reserve, clamped at zero). When the broker fee landed on a
1064 // payee sitting below its own reserve, that payee's clamped balance
1065 // stayed zero and the fee vanished from the conservation sum,
1066 // tripping "funds are conserved (with rounding)".
1067 testcase("LoanPay funds conserved: broker fee payee below reserve");
1068
1069 using namespace jtx;
1070
1071 Env env(*this, features);
1072
1073 Account const issuer{"issuer"};
1074 Account const lender{"lender"};
1075 Account const borrower{"borrower"};
1076
1077 // Broker defaults match the fuzz workload: ManagementFeeRate = 100
1078 // tenth-bips. The service fee guarantees feePaid > 0 on the first
1079 // regular payment.
1080 BrokerParameters const brokerParams;
1081 Number const serviceFeeValue{2};
1082 LoanParameters const loanParams{
1083 .account = borrower,
1084 .counter = lender,
1085 .principalRequest = 1000,
1086 .serviceFee = serviceFeeValue,
1087 .interest = TenthBips32{percentageToTenthBips(12)},
1088 .payTotal = 12,
1089 .payInterval = 3600,
1090 };
1091
1092 auto const loanOpt =
1093 createLoan(env, AssetType::XRP, brokerParams, loanParams, issuer, lender, borrower);
1094 if (BEAST_EXPECT(loanOpt); !loanOpt.has_value())
1095 return;
1096 auto const& [broker, loanKeylet, brokerPseudo] = *loanOpt;
1097
1098 auto const vaultPseudo = [&] {
1099 auto const vaultSle = env.le(keylet::vault(broker.vaultID));
1100 if (!BEAST_EXPECT(vaultSle))
1101 return AccountID{};
1102 return vaultSle->at(sfAccount);
1103 }();
1104
1105 // Raw AccountRoot balance, matching LoanPay::doApply's conservation
1106 // check (not the reserve-clamped accountHolds()/xrpLiquid() value).
1107 auto const rawBalance = [&](AccountID const& id) -> STAmount {
1108 auto const sle = env.le(keylet::account(id));
1109 if (!BEAST_EXPECT(sle))
1110 return STAmount{};
1111 return sle->getFieldAmount(sfBalance);
1112 };
1113 auto const lenderReserve = [&] {
1114 return env.current()->fees().accountReserve(ownerCount(env, lender), 1);
1115 };
1116
1117 STAmount const baseFee{env.current()->fees().base};
1118
1119 // Park the lender (broker owner, fee payee) exactly at its reserve,
1120 // then burn part of the reserve with an oversized transaction fee.
1121 // Fees are exempt from the reserve check, so the balance ends up
1122 // below the reserve.
1123 env(pay(lender, issuer, rawBalance(lender.id()) - lenderReserve() - baseFee));
1124 env(noop(lender), Fee(XRP(100)));
1125 env.close();
1126 BEAST_EXPECT(env.balance(lender) < lenderReserve());
1127
1128 // First regular payment, exactly the amount due.
1129 auto const state = getCurrentState(env, broker, loanKeylet);
1130 STAmount const serviceFee = broker.asset(serviceFeeValue);
1131 STAmount const roundedPeriodicPayment{
1132 broker.asset,
1133 roundPeriodicPayment(broker.asset, state.periodicPayment, state.loanScale)};
1134 STAmount const totalDue = roundToScale(
1135 roundedPeriodicPayment + serviceFee, state.loanScale, Number::RoundingMode::Upward);
1136
1137 auto const borrowerBefore = rawBalance(borrower.id());
1138 auto const vaultBefore = rawBalance(vaultPseudo);
1139 auto const lenderBefore = rawBalance(lender.id());
1140
1141 // Before the fix, this aborted inside LoanPay::doApply on
1142 // XRPL_ASSERT_PARTS(goodRounding, "xrpl::LoanPay::doApply", "funds
1143 // are conserved (with rounding)").
1144 env(loan::pay(borrower, loanKeylet.key, totalDue));
1145 env.close();
1146
1147 auto const borrowerAfter = rawBalance(borrower.id());
1148 auto const vaultAfter = rawBalance(vaultPseudo);
1149 auto const lenderAfter = rawBalance(lender.id());
1150
1151 // The broker fee reached the lender's AccountRoot, even though the
1152 // lender's balance remains below its reserve.
1153 BEAST_EXPECT(lenderAfter > lenderBefore);
1154 BEAST_EXPECT(lenderAfter < lenderReserve());
1155
1156 // Total funds conserved across the payer, vault, and fee payee.
1157 BEAST_EXPECT(
1158 borrowerBefore - baseFee + vaultBefore + lenderBefore ==
1159 borrowerAfter + vaultAfter + lenderAfter);
1160 }
1161
1162 // Env::close() cannot land the ledger's parentCloseTime on an arbitrary
1163 // instant: it always rounds the requested time forward to the next
1164 // close-time-resolution boundary (see Env::close() and
1165 // roundCloseTime()/effCloseTime() in LedgerTiming.h), so it can only be
1166 // used to reach times strictly *after* a given due date, never exactly
1167 // on it. To pin the exact-boundary behavior of isPaymentLate(), directly
1168 // overwrite the loan's NextPaymentDueDate so that it matches the
1169 // *current* (already fixed) parentCloseTime of the open ledger, without
1170 // closing again. This exercises the same comparison
1171 // (parentCloseTime vs. NextPaymentDueDate) at the exact boundary that
1172 // env.close() cannot reliably reach.
1173 void
1174 setLoanNextPaymentDueDate(jtx::Env& env, Keylet const& loanKeylet, std::uint32_t dueDate)
1175 {
1176 using namespace jtx;
1177 bool const ok = env.app().getOpenLedger().modify([&](OpenView& view, beast::Journal) {
1178 auto const sle = view.read(loanKeylet);
1179 if (!sle)
1180 return false;
1181 auto const replacement = std::make_shared<SLE>(*sle);
1182 (*replacement)[sfNextPaymentDueDate] = dueDate;
1183 view.rawReplace(replacement);
1184 return true;
1185 });
1186 BEAST_EXPECT(ok);
1187 }
1188
1189 // With fixCleanup3_4_0, isPaymentLate() uses a strict (Exclusive)
1190 // comparison: a payment due exactly "now" is not yet late. A plain
1191 // (non-late) LoanPay submitted at the exact NextPaymentDueDate instant
1192 // must therefore succeed, advance the due date by exactly one
1193 // PaymentInterval, and charge only the regular periodic payment amount
1194 // (no late interest / late fee).
1195 void
1197 {
1198 testcase("LoanPay at exact due date succeeds with fixCleanup3_4_0");
1199
1200 using namespace jtx;
1201 using namespace loan;
1202
1203 Env env(*this, all_);
1204 BEAST_EXPECT(env.enabled(fixCleanup3_4_0));
1205
1206 Account const lender{"lender"};
1207 Account const borrower{"borrower"};
1208
1209 env.fund(XRP(10'000'000), lender, borrower);
1210 env.close();
1211
1212 PrettyAsset const asset{xrpIssue(), 1000};
1213 auto const broker = createVaultAndBroker(env, asset, lender);
1214
1215 auto const brokerSle = env.le(keylet::loanBroker(broker.brokerID));
1216 if (!BEAST_EXPECT(brokerSle))
1217 return;
1218 auto const loanKeylet =
1219 keylet::loan(broker.brokerID, SeqProxy::rawSequence(brokerSle->at(sfLoanSequence)));
1220
1221 // Set a large, non-zero late interest rate and late fee so that if
1222 // the late-payment path were incorrectly taken, the extra charge
1223 // would be large and easy to detect (far more than any rounding
1224 // slack in the regular periodic payment amount).
1225 env(set(borrower, broker.brokerID, asset(1'000).value()),
1226 Sig(sfCounterpartySignature, lender),
1227 kPaymentTotal(12),
1228 kPaymentInterval(600),
1229 kLateInterestRate(TenthBips32(percentageToTenthBips(24))),
1230 kLatePaymentFee(asset(50).value()),
1231 Fee(env.current()->fees().base * 2));
1232 env.close();
1233
1234 auto const stateBefore = getCurrentState(env, broker, loanKeylet);
1235 BEAST_EXPECT(stateBefore.paymentRemaining == 12);
1236
1237 STAmount const roundedPeriodicPayment{
1238 asset, roundPeriodicPayment(asset, stateBefore.periodicPayment, stateBefore.loanScale)};
1239
1240 // Set NextPaymentDueDate to exactly the current parentCloseTime,
1241 // without closing the ledger again.
1242 std::uint32_t const exactDueDate =
1243 env.current()->parentCloseTime().time_since_epoch().count();
1244 setLoanNextPaymentDueDate(env, loanKeylet, exactDueDate);
1245
1246 STAmount const payFee{env.current()->fees().base};
1247 auto const borrowerBefore = env.balance(borrower, asset).number();
1248
1249 // A plain payment (no tfLoanLatePayment) for exactly the regular
1250 // periodic amount must succeed: at this instant the payment is not
1251 // yet late.
1252 //
1253 // Note: deliberately not calling env.close() after this: closing
1254 // the ledger re-derives the resulting state from the last validated
1255 // ledger plus the recorded transaction set, which would discard the
1256 // direct NextPaymentDueDate override made above via rawReplace().
1257 // Reading state from the still-open ledger (as env.le()/env.balance()
1258 // do) reflects the transaction as it was actually applied.
1259 env(pay(borrower, loanKeylet.key, roundedPeriodicPayment), Fee(payFee), Ter(tesSUCCESS));
1260
1261 auto const borrowerAfter = env.balance(borrower, asset).number();
1262
1263 // No more than the regular periodic amount (plus the transaction
1264 // fee) was charged: if the late-payment path had wrongly been
1265 // taken, the (large, non-zero) late interest and late fee set above
1266 // would have pushed the charge well past this bound.
1267 Number const charged = borrowerBefore - borrowerAfter - Number{payFee};
1268 BEAST_EXPECT(charged > Number{});
1269 BEAST_EXPECT(charged <= Number{roundedPeriodicPayment});
1270
1271 auto const stateAfter = getCurrentState(env, broker, loanKeylet);
1272 BEAST_EXPECT(stateAfter.paymentRemaining == stateBefore.paymentRemaining - 1);
1273 BEAST_EXPECT(stateAfter.nextPaymentDate == exactDueDate + stateBefore.paymentInterval);
1274 }
1275
1276 // Pins the amendment gate itself (as opposed to
1277 // testLoanPayAtExactDueDateSucceedsPostAmendment, which pins the
1278 // comparison operator): without fixCleanup3_4_0, isPaymentLate() keeps
1279 // using the pre-amendment Inclusive comparison, so a payment due exactly
1280 // "now" is already considered late, and a plain (non-late) LoanPay is
1281 // rejected.
1282 void
1284 {
1285 testcase("LoanPay at exact due date fails without fixCleanup3_4_0");
1286
1287 using namespace jtx;
1288 using namespace loan;
1289
1290 Env env(*this, all_ - fixCleanup3_4_0);
1291 BEAST_EXPECT(!env.enabled(fixCleanup3_4_0));
1292
1293 Account const lender{"lender"};
1294 Account const borrower{"borrower"};
1295
1296 env.fund(XRP(10'000'000), lender, borrower);
1297 env.close();
1298
1299 PrettyAsset const asset{xrpIssue(), 1000};
1300 auto const broker = createVaultAndBroker(env, asset, lender);
1301
1302 auto const brokerSle = env.le(keylet::loanBroker(broker.brokerID));
1303 if (!BEAST_EXPECT(brokerSle))
1304 return;
1305 auto const loanKeylet =
1306 keylet::loan(broker.brokerID, SeqProxy::rawSequence(brokerSle->at(sfLoanSequence)));
1307
1308 env(set(borrower, broker.brokerID, asset(1'000).value()),
1309 Sig(sfCounterpartySignature, lender),
1310 kPaymentTotal(12),
1311 kPaymentInterval(600),
1312 Fee(env.current()->fees().base * 2));
1313 env.close();
1314
1315 auto const stateBefore = getCurrentState(env, broker, loanKeylet);
1316 BEAST_EXPECT(stateBefore.paymentRemaining == 12);
1317
1318 STAmount const roundedPeriodicPayment{
1319 asset, roundPeriodicPayment(asset, stateBefore.periodicPayment, stateBefore.loanScale)};
1320
1321 // Set NextPaymentDueDate to exactly the current parentCloseTime,
1322 // without closing the ledger again.
1323 std::uint32_t const exactDueDate =
1324 env.current()->parentCloseTime().time_since_epoch().count();
1325 setLoanNextPaymentDueDate(env, loanKeylet, exactDueDate);
1326
1327 // Without the amendment, the due date is already considered late at
1328 // this exact instant, so a plain payment must be rejected.
1329 //
1330 // Note: deliberately not calling env.close() after this: closing
1331 // the ledger re-derives the resulting state from the last validated
1332 // ledger plus the recorded transaction set, which would discard the
1333 // direct NextPaymentDueDate override made above via rawReplace().
1334 // Reading state from the still-open ledger (as env.le() does)
1335 // reflects the transaction as it was actually applied.
1336 env(pay(borrower, loanKeylet.key, roundedPeriodicPayment), Ter(tecEXPIRED));
1337
1338 auto const stateAfter = getCurrentState(env, broker, loanKeylet);
1339 BEAST_EXPECT(stateAfter.paymentRemaining == stateBefore.paymentRemaining);
1340 BEAST_EXPECT(stateAfter.nextPaymentDate == exactDueDate);
1341 }
1342
1343 // computeLatePayment() must agree with isPaymentLate() at the exact
1344 // due-date boundary: once fixCleanup3_4_0 is enabled, a payment due
1345 // exactly "now" is not yet late, so a tfLoanLatePayment submitted at
1346 // that same instant must be rejected with tecTOO_SOON rather than being
1347 // admitted and charged the late interest/fee.
1348 void
1350 {
1351 testcase("LoanPay(tfLoanLatePayment) at exact due date rejected with fixCleanup3_4_0");
1352
1353 using namespace jtx;
1354 using namespace loan;
1355
1356 Env env(*this, all_);
1357 BEAST_EXPECT(env.enabled(fixCleanup3_4_0));
1358
1359 Account const lender{"lender"};
1360 Account const borrower{"borrower"};
1361
1362 env.fund(XRP(10'000'000), lender, borrower);
1363 env.close();
1364
1365 PrettyAsset const asset{xrpIssue(), 1000};
1366 auto const broker = createVaultAndBroker(env, asset, lender);
1367
1368 auto const brokerSle = env.le(keylet::loanBroker(broker.brokerID));
1369 if (!BEAST_EXPECT(brokerSle))
1370 return;
1371 auto const loanKeylet =
1372 keylet::loan(broker.brokerID, SeqProxy::rawSequence(brokerSle->at(sfLoanSequence)));
1373
1374 env(set(borrower, broker.brokerID, asset(1'000).value()),
1375 Sig(sfCounterpartySignature, lender),
1376 kPaymentTotal(12),
1377 kPaymentInterval(600),
1378 kLateInterestRate(TenthBips32(percentageToTenthBips(24))),
1379 kLatePaymentFee(asset(50).value()),
1380 Fee(env.current()->fees().base * 2));
1381 env.close();
1382
1383 auto const stateBefore = getCurrentState(env, broker, loanKeylet);
1384 BEAST_EXPECT(stateBefore.paymentRemaining == 12);
1385
1386 // Overpay generously so that, if the late-payment path were
1387 // incorrectly admitted, funds would not be the limiting factor;
1388 // we want to isolate the timing check itself.
1389 STAmount const generousAmount{
1390 asset,
1391 roundPeriodicPayment(asset, stateBefore.periodicPayment, stateBefore.loanScale) * 2};
1392
1393 // Set NextPaymentDueDate to exactly the current parentCloseTime,
1394 // without closing the ledger again.
1395 std::uint32_t const exactDueDate =
1396 env.current()->parentCloseTime().time_since_epoch().count();
1397 setLoanNextPaymentDueDate(env, loanKeylet, exactDueDate);
1398
1399 // At this exact instant the loan is not yet late (Exclusive
1400 // comparison), so even an explicit late payment must be rejected
1401 // as premature, matching the plain-payment path.
1402 //
1403 // Note: deliberately not calling env.close() after this, for the
1404 // same reason given in testLoanPayAtExactDueDateSucceedsPostAmendment
1405 // above: closing would discard the direct NextPaymentDueDate
1406 // override made via rawReplace().
1407 env(pay(borrower, loanKeylet.key, generousAmount, tfLoanLatePayment), Ter(tecTOO_SOON));
1408
1409 auto const stateAfter = getCurrentState(env, broker, loanKeylet);
1410 BEAST_EXPECT(stateAfter.paymentRemaining == stateBefore.paymentRemaining);
1411 BEAST_EXPECT(stateAfter.nextPaymentDate == exactDueDate);
1412 }
1413
1414 // calculateBaseFee must use isPaymentLate(), not a raw inclusive
1415 // hasExpired(): once fixCleanup3_4_0 is enabled, a plain catch-up at
1416 // exactly NextPaymentDueDate succeeds and can process many payments, so
1417 // the fee has to scale with that work. Charging a single base fee here
1418 // would disagree with apply (and with the fixCleanup3_1_3 cap).
1419 void
1421 {
1422 testcase("LoanPay catch-up fee at exact due date with fixCleanup3_4_0");
1423
1424 using namespace jtx;
1425 using namespace loan;
1426 using namespace lending;
1427
1428 Env env(*this, all_);
1429 BEAST_EXPECT(env.enabled(fixCleanup3_4_0));
1430
1431 Account const lender{"lender"};
1432 Account const borrower{"borrower"};
1433
1434 env.fund(XRP(10'000'000), lender, borrower);
1435 env.close();
1436
1437 PrettyAsset const asset{xrpIssue(), 1000};
1438 auto const broker = createVaultAndBroker(env, asset, lender);
1439
1440 auto const brokerSle = env.le(keylet::loanBroker(broker.brokerID));
1441 if (!BEAST_EXPECT(brokerSle))
1442 return;
1443 auto const loanKeylet =
1444 keylet::loan(broker.brokerID, SeqProxy::rawSequence(brokerSle->at(sfLoanSequence)));
1445
1446 env(set(borrower, broker.brokerID, asset(10'000).value()),
1447 Sig(sfCounterpartySignature, lender),
1448 kPaymentTotal(50),
1449 kPaymentInterval(600),
1450 Fee(env.current()->fees().base * 2));
1451 env.close();
1452
1453 auto const stateBefore = getCurrentState(env, broker, loanKeylet);
1454 BEAST_EXPECT(stateBefore.paymentRemaining == 50);
1455 BEAST_EXPECT(stateBefore.paymentRemaining > kLoanPaymentsPerFeeIncrement);
1456
1457 auto const loanSle = env.le(loanKeylet);
1458 if (!BEAST_EXPECT(loanSle))
1459 return;
1460 Number const regularPayment =
1461 roundPeriodicPayment(asset, stateBefore.periodicPayment, stateBefore.loanScale) +
1462 loanSle->at(sfLoanServiceFee);
1463 int const payCount = kLoanPaymentsPerFeeIncrement * 4;
1464 STAmount const catchUp{asset, regularPayment * payCount};
1465 XRPAmount const baseFee = env.current()->fees().base;
1466 XRPAmount const escalatedFee{baseFee * (payCount / kLoanPaymentsPerFeeIncrement)};
1467
1468 std::uint32_t const exactDueDate =
1469 env.current()->parentCloseTime().time_since_epoch().count();
1470 setLoanNextPaymentDueDate(env, loanKeylet, exactDueDate);
1471
1472 // Under-fee: apply would process `payCount` payments, so a single
1473 // base fee is not enough.
1474 env(pay(borrower, loanKeylet.key, catchUp), Fee(baseFee), Ter(telINSUF_FEE_P));
1475
1476 // Same catch-up with the scaled fee must succeed at this instant.
1477 // Do not env.close() after the SLE override (see
1478 // testLoanPayAtExactDueDateSucceedsPostAmendment).
1479 env(pay(borrower, loanKeylet.key, catchUp), Fee(escalatedFee), Ter(tesSUCCESS));
1480
1481 auto const stateAfter = getCurrentState(env, broker, loanKeylet);
1482 BEAST_EXPECT(stateAfter.paymentRemaining == stateBefore.paymentRemaining - payCount);
1483 }
1484
1485 // Without the amendment, inclusive hasExpired still treats the exact
1486 // due-date instant as late, so calculateBaseFee correctly charges a
1487 // single base fee and apply rejects a plain LoanPay with tecEXPIRED.
1488 void
1490 {
1491 testcase("LoanPay catch-up fee at exact due date without fixCleanup3_4_0");
1492
1493 using namespace jtx;
1494 using namespace loan;
1495 using namespace lending;
1496
1497 Env env(*this, all_ - fixCleanup3_4_0);
1498 BEAST_EXPECT(!env.enabled(fixCleanup3_4_0));
1499
1500 Account const lender{"lender"};
1501 Account const borrower{"borrower"};
1502
1503 env.fund(XRP(10'000'000), lender, borrower);
1504 env.close();
1505
1506 PrettyAsset const asset{xrpIssue(), 1000};
1507 auto const broker = createVaultAndBroker(env, asset, lender);
1508
1509 auto const brokerSle = env.le(keylet::loanBroker(broker.brokerID));
1510 if (!BEAST_EXPECT(brokerSle))
1511 return;
1512 auto const loanKeylet =
1513 keylet::loan(broker.brokerID, SeqProxy::rawSequence(brokerSle->at(sfLoanSequence)));
1514
1515 env(set(borrower, broker.brokerID, asset(10'000).value()),
1516 Sig(sfCounterpartySignature, lender),
1517 kPaymentTotal(50),
1518 kPaymentInterval(600),
1519 Fee(env.current()->fees().base * 2));
1520 env.close();
1521
1522 auto const stateBefore = getCurrentState(env, broker, loanKeylet);
1523 BEAST_EXPECT(stateBefore.paymentRemaining == 50);
1524
1525 auto const loanSle = env.le(loanKeylet);
1526 if (!BEAST_EXPECT(loanSle))
1527 return;
1528 Number const regularPayment =
1529 roundPeriodicPayment(asset, stateBefore.periodicPayment, stateBefore.loanScale) +
1530 loanSle->at(sfLoanServiceFee);
1531 int const payCount = kLoanPaymentsPerFeeIncrement * 4;
1532 STAmount const catchUp{asset, regularPayment * payCount};
1533 XRPAmount const baseFee = env.current()->fees().base;
1534
1535 std::uint32_t const exactDueDate =
1536 env.current()->parentCloseTime().time_since_epoch().count();
1537 setLoanNextPaymentDueDate(env, loanKeylet, exactDueDate);
1538
1539 env(pay(borrower, loanKeylet.key, catchUp), Fee(baseFee), Ter(tecEXPIRED));
1540
1541 auto const stateAfter = getCurrentState(env, broker, loanKeylet);
1542 BEAST_EXPECT(stateAfter.paymentRemaining == stateBefore.paymentRemaining);
1543 BEAST_EXPECT(stateAfter.nextPaymentDate == exactDueDate);
1544 }
1545
1546 // LoanPay does not call canAddHolding. addEmptyHolding recreates the
1547 // broker-owner holding when the borrower is also the broker owner. After
1548 // fixCleanup3_4_0 an existing line is a no-op even if DefaultRipple is
1549 // off; pre-fix that path dies with tecINTERNAL.
1550 void
1552 {
1553 using namespace jtx;
1554 using namespace loan;
1555
1556 auto const run = [this](FeatureBitset features, TER expected) {
1557 testcase(
1559 "LoanPay broker-owner borrower existing line after "
1560 "issuer clears asfDefaultRipple (") +
1561 (features[fixCleanup3_4_0] ? "post" : "pre") + "-fixCleanup3_4_0)");
1562
1563 Env env(*this, features);
1564 Account const issuer{"issuer"};
1565 Account const alice{"alice"};
1566
1567 env.fund(XRP(10'000), issuer, alice);
1568 env.close();
1569 env(fset(issuer, asfDefaultRipple));
1570 env.close();
1571
1572 PrettyAsset const usd{issuer["USD"]};
1573 env(trust(alice, usd(10'000'000)));
1574 env.close();
1575 env(pay(issuer, alice, usd(2'000'000)));
1576 env.close();
1577
1578 auto const broker = createVaultAndBroker(env, usd, alice);
1579 auto const brokerSle = env.le(keylet::loanBroker(broker.brokerID));
1580 if (!BEAST_EXPECT(brokerSle))
1581 return;
1582 auto const loanKeylet =
1583 keylet::loan(broker.brokerID, SeqProxy::rawSequence(brokerSle->at(sfLoanSequence)));
1584
1585 Number const serviceFee = usd(2).value();
1586 env(set(alice, broker.brokerID, usd(1'000).value()),
1587 Sig(sfCounterpartySignature, alice),
1588 kLoanServiceFee(serviceFee),
1589 Fee(env.current()->fees().base * 2));
1590 env.close();
1591
1592 env(fclear(issuer, asfDefaultRipple));
1593 env.close();
1594 BEAST_EXPECT(env.le(keylet::trustLine(alice.id(), usd.raw().get<Issue>())));
1595
1596 auto const state = getCurrentState(env, broker, loanKeylet);
1597 STAmount const payment{
1598 usd,
1599 roundPeriodicPayment(usd, state.periodicPayment + serviceFee, state.loanScale)};
1600
1601 env(pay(alice, loanKeylet.key, payment), Ter(expected));
1602 env.close();
1603 };
1604
1605 run(all_ - fixCleanup3_4_0, tecINTERNAL);
1607 }
1608
1609 void
1611 {
1612 testcase("FixedPrecision scheduled LoanPay accounting");
1613
1614 using namespace jtx;
1615 using namespace loan;
1616
1617 Number const trustLimit{10'000'000};
1618 Number const lenderAmount{2'000'000};
1619 Number const borrowerAmount{100};
1621 *this, fixedPrecisionFeatures(), trustLimit, lenderAmount, borrowerAmount};
1622 auto& [env, issuer, lender, borrower, asset] = f;
1623
1624 auto brokerParams = fixedPrecisionBrokerParams();
1625 TenthBips16 const managementFeeRate{100};
1626 brokerParams.managementFeeRate = managementFeeRate;
1627 auto const broker = createVaultAndBroker(env, asset, lender, brokerParams);
1628 Number const principal{1'000};
1629 std::uint32_t const interestRatePercent = 12;
1630 auto const loanKeylet = originateLoan(
1631 env,
1632 broker,
1633 borrower,
1634 lender,
1635 asset(principal).value(),
1636 {.paymentTotal = 3, .paymentInterval = 24 * 60 * 60},
1637 kInterestRate(percentageToTenthBips(interestRatePercent)));
1638
1639 auto const state = getCurrentState(env, broker, loanKeylet);
1640 STAmount const payment{
1641 asset, roundPeriodicPayment(asset, state.periodicPayment, state.loanScale)};
1642
1643 auto const vaultBefore = env.le(broker.vaultKeylet());
1644 auto const brokerBefore = env.le(broker.brokerKeylet());
1645 auto const loanBefore = env.le(loanKeylet);
1646 if (!BEAST_EXPECT(vaultBefore && brokerBefore && loanBefore))
1647 return;
1648
1649 Number const assetsAvailableBefore = vaultBefore->at(sfAssetsAvailable);
1650 Number const assetsTotalBefore = vaultBefore->at(sfAssetsTotal);
1651 Number const yieldBefore = vaultBefore->at(sfYieldUnrealized);
1652 Number const debtBefore = brokerBefore->at(sfDebtTotal);
1653 Number const principalBefore = loanBefore->at(sfPrincipalOutstanding);
1654 Number const managementFeeBefore = loanBefore->at(sfManagementFeeOutstanding);
1655 Number const scheduledInterestBefore = scheduledInterest(loanBefore);
1656 Number const lenderBalanceBefore = env.balance(lender, asset).number();
1657 BEAST_EXPECT(managementFeeBefore > beast::kZero);
1658
1659 env(pay(borrower, loanKeylet.key, payment));
1660 env.close();
1661
1662 auto const vaultAfter = env.le(broker.vaultKeylet());
1663 auto const brokerAfter = env.le(broker.brokerKeylet());
1664 auto const loanAfter = env.le(loanKeylet);
1665 if (!BEAST_EXPECT(vaultAfter && brokerAfter && loanAfter))
1666 return;
1668 *this, env, broker.vaultKeylet(), {}, {loanKeylet}, "after scheduled payment");
1669
1670 Number const principalPaid = principalBefore - loanAfter->at(sfPrincipalOutstanding);
1671 Number const credit = vaultAfter->at(sfAssetsAvailable) - assetsAvailableBefore;
1672 Number const managementFeeAfter = loanAfter->at(sfManagementFeeOutstanding);
1673 Number const scheduledInterestAfter = scheduledInterest(loanAfter);
1674 Number const interestPaid = scheduledInterestBefore - scheduledInterestAfter;
1675 Number const expectedAssetsTotal = [&] {
1677 return Number{STAmount{asset, assetsTotalBefore + interestPaid}};
1678 }();
1679 Number const interestActual = expectedAssetsTotal - assetsTotalBefore;
1680
1681 BEAST_EXPECT(brokerAfter->at(sfDebtTotal) == debtBefore - principalPaid);
1682 BEAST_EXPECTS(
1683 vaultAfter->at(sfAssetsTotal) == expectedAssetsTotal,
1684 "AssetsTotal expected " + to_string(expectedAssetsTotal) + ", got " +
1685 to_string(vaultAfter->at(sfAssetsTotal)));
1686 BEAST_EXPECT(expectedAssetsTotal == assetsTotalBefore + interestPaid);
1687 BEAST_EXPECT(credit == principalPaid + interestActual);
1688 BEAST_EXPECT(
1689 env.balance(lender, asset).number() - lenderBalanceBefore ==
1690 managementFeeBefore - managementFeeAfter);
1691 BEAST_EXPECT(
1692 vaultAfter->at(sfYieldUnrealized) ==
1693 yieldBefore + scheduledInterestAfter - scheduledInterestBefore);
1694 BEAST_EXPECTS(
1695 vaultAfter->at(sfAssetsTotal) + vaultAfter->at(sfYieldUnrealized) ==
1696 assetsTotalBefore + yieldBefore,
1697 "capacity before " + to_string(assetsTotalBefore + yieldBefore) + ", after " +
1698 to_string(vaultAfter->at(sfAssetsTotal) + vaultAfter->at(sfYieldUnrealized)));
1699
1700 BEAST_EXPECT(scheduledInterestAfter > beast::kZero);
1701 BEAST_EXPECT(vaultAfter->at(sfYieldUnrealized) > beast::kZero);
1702
1703 Number const fullPaymentMaximum = env.balance(borrower, asset).number();
1704 env(pay(borrower, loanKeylet.key, asset(fullPaymentMaximum), tfLoanFullPayment));
1705 env.close();
1706
1707 auto const vaultAfterFull = env.le(broker.vaultKeylet());
1708 auto const loanAfterFull = env.le(loanKeylet);
1709 if (!BEAST_EXPECT(vaultAfterFull && loanAfterFull))
1710 return;
1712 *this, env, broker.vaultKeylet(), {}, {loanKeylet}, "after full payment");
1713 BEAST_EXPECT(loanAfterFull->at(sfPaymentRemaining) == 0);
1714 BEAST_EXPECT(loanAfterFull->at(sfTotalValueOutstanding) == beast::kZero);
1715 BEAST_EXPECT(loanAfterFull->at(sfPrincipalOutstanding) == beast::kZero);
1716 BEAST_EXPECT(loanAfterFull->at(sfManagementFeeOutstanding) == beast::kZero);
1717 BEAST_EXPECT(vaultAfterFull->at(sfYieldUnrealized) == beast::kZero);
1718 }
1719
1720 void
1722 {
1723 testcase("FixedPrecision redirected fee rounds at posterior cover scale");
1724
1725 using namespace jtx;
1726 using namespace loan;
1727
1728 Number const trustLimit{2, 10};
1729 Number const lenderAmount{1, 10};
1730 Number const borrowerAmount{2, 9};
1732 *this, fixedPrecisionFeatures(), trustLimit, lenderAmount, borrowerAmount};
1733 auto& [env, issuer, lender, borrower, asset] = f;
1734
1735 auto brokerParams = fixedPrecisionBrokerParams();
1736 brokerParams.coverDeposit = 0;
1737 auto const broker = createVaultAndBroker(env, asset, lender, brokerParams);
1738
1739 // Optional cover can fill the Open zone at P=6. The first redirected
1740 // fee below is mandatory growth and takes CoverAvailable into the
1741 // coarsened state.
1742 Number const coverDepositAmount{9, 9};
1743 env(loan_broker::coverDeposit(lender, broker.brokerID, asset(coverDepositAmount)));
1744 env.close();
1745
1746 Number const loanPrincipal{1'000};
1747 auto const makeLoan = [&](Number const& serviceFee) {
1748 return originateLoan(
1749 env,
1750 broker,
1751 borrower,
1752 lender,
1753 asset(loanPrincipal).value(),
1754 {.paymentTotal = 2, .paymentInterval = 24 * 60 * 60},
1755 kLoanServiceFee(serviceFee));
1756 };
1757 auto const payOnce = [&](Keylet const& loanKeylet, Number const& serviceFee) {
1758 auto const state = getCurrentState(env, broker, loanKeylet);
1759 STAmount const payment{
1760 asset,
1761 roundPeriodicPayment(asset, state.periodicPayment + serviceFee, state.loanScale)};
1762 env(pay(borrower, loanKeylet.key, payment));
1763 env.close();
1764 };
1765
1766 Number const coarseningFee{1, 9};
1767 auto const firstLoan = makeLoan(coarseningFee);
1768 Number const roundedFeeRaw{17, -6};
1769 auto const roundedFeeLoan = makeLoan(roundedFeeRaw);
1770 Number const dustFee{1, -6};
1771 auto const secondLoan = makeLoan(dustFee);
1772 auto const checkSums = [&](char const* label) {
1774 *this,
1775 env,
1776 broker.vaultKeylet(),
1777 {},
1778 {firstLoan, roundedFeeLoan, secondLoan},
1779 label);
1780 };
1781
1782 // A deep-frozen owner cannot receive broker fees, so LoanPay redirects
1783 // them to the broker pseudo-account and CoverAvailable. Originate all
1784 // loans first because the freeze also blocks LoanSet.
1785 env(trust(issuer, asset(0), lender, tfSetFreeze | tfSetDeepFreeze));
1786 env.close();
1787
1788 payOnce(firstLoan, coarseningFee);
1789 checkSums("after firstLoan payment");
1790 auto const brokerCoarsened = env.le(broker.brokerKeylet());
1791 if (!BEAST_EXPECT(brokerCoarsened))
1792 return;
1793 Number const coverBeforeDust = brokerCoarsened->at(sfCoverAvailable);
1794 Number const expectedCoverAfterFirstPayment{1, 10};
1795 BEAST_EXPECT(coverBeforeDust == expectedCoverAfterFirstPayment);
1796
1797 payOnce(roundedFeeLoan, roundedFeeRaw);
1798 checkSums("after roundedFeeLoan payment");
1799 auto const brokerAfterRoundedFee = env.le(broker.brokerKeylet());
1800 if (!BEAST_EXPECT(brokerAfterRoundedFee))
1801 return;
1802 Number const roundedFee = brokerAfterRoundedFee->at(sfCoverAvailable) - coverBeforeDust;
1803 BEAST_EXPECT(roundedFee > beast::kZero);
1804 BEAST_EXPECT(roundedFee < roundedFeeRaw);
1805
1806 auto const vaultBeforeDust = env.le(broker.vaultKeylet());
1807 if (!BEAST_EXPECT(vaultBeforeDust))
1808 return;
1809 Number const availableBeforeDust = vaultBeforeDust->at(sfAssetsAvailable);
1810 Number const borrowerBeforeDust = env.balance(borrower, asset).number();
1811
1812 payOnce(secondLoan, dustFee);
1813
1814 auto const brokerAfterDust = env.le(broker.brokerKeylet());
1815 auto const vaultAfterDust = env.le(broker.vaultKeylet());
1816 if (!BEAST_EXPECT(brokerAfterDust && vaultAfterDust))
1817 return;
1818 checkSums("after secondLoan (dust) payment");
1819 BEAST_EXPECT(
1820 brokerAfterDust->at(sfCoverAvailable) == brokerAfterRoundedFee->at(sfCoverAvailable));
1821 Number const vaultCredit = vaultAfterDust->at(sfAssetsAvailable) - availableBeforeDust;
1822 BEAST_EXPECT(borrowerBeforeDust - env.balance(borrower, asset).number() == vaultCredit);
1823 }
1824
1825 void
1827 {
1828 using namespace jtx;
1829 using namespace loan;
1830
1831 // A fee redirected into cover is added to CoverAvailable before the
1832 // broker's fields are rounded to the asset. A sum past 16 digits must
1833 // be stored rounded.
1834 struct Row
1835 {
1836 char const* name = nullptr;
1837 FeatureBitset features;
1838 };
1839 Row const rows[] = {
1840 {
1841 .name = "Legacy redirected fee is rounded into CoverAvailable",
1842 .features = all_ - featureLendingProtocolV1_1 - featureLendingProtocolV1_2,
1843 },
1844 {
1845 .name = "CashBasis redirected fee is rounded into CoverAvailable",
1846 .features = (all_ | featureLendingProtocolV1_1) - featureLendingProtocolV1_2,
1847 },
1848 };
1849 for (auto const& row : rows)
1850 {
1851 testcase(row.name);
1852
1853 Number const trustLimit{1, 11};
1854 Number const lenderAmount{5, 10};
1855 Number const borrowerAmount{2, 9};
1856 FixedPrecisionIOU f{*this, row.features, trustLimit, lenderAmount, borrowerAmount};
1857 auto& [env, issuer, lender, borrower, asset] = f;
1858
1859 BrokerParameters brokerParams;
1860 brokerParams.coverDeposit = 0;
1861 auto const broker = createVaultAndBroker(env, asset, lender, brokerParams);
1862
1863 // 16 significant digits, so any smaller fee overflows the mantissa.
1864 Number const coverDepositAmount{1'234'567'890'123'456, -5};
1865 env(loan_broker::coverDeposit(lender, broker.brokerID, asset(coverDepositAmount)));
1866 env.close();
1867
1868 Number const serviceFee{1, -6};
1869 auto const loanKeylet = originateLoan(
1870 env,
1871 broker,
1872 borrower,
1873 lender,
1874 asset(Number{1'000}).value(),
1875 {.paymentTotal = 2, .paymentInterval = 24 * 60 * 60},
1876 kLoanServiceFee(serviceFee));
1877
1878 // A deep-frozen owner cannot receive broker fees, so LoanPay
1879 // redirects them into cover.
1880 env(trust(issuer, asset(0), lender, tfSetFreeze | tfSetDeepFreeze));
1881 env.close();
1882
1883 auto const brokerBefore = env.le(broker.brokerKeylet());
1884 if (!BEAST_EXPECT(brokerBefore))
1885 return;
1886 Number const coverBefore = brokerBefore->at(sfCoverAvailable);
1887 BEAST_EXPECT(coverBefore == coverDepositAmount);
1888
1889 auto const state = getCurrentState(env, broker, loanKeylet);
1890 STAmount const payment{
1891 asset,
1892 roundPeriodicPayment(asset, state.periodicPayment + serviceFee, state.loanScale)};
1893 env(pay(borrower, loanKeylet.key, payment));
1894 env.close();
1895
1896 auto const brokerAfter = env.le(broker.brokerKeylet());
1897 if (!BEAST_EXPECT(brokerAfter))
1898 return;
1899 Number const coverAfter = brokerAfter->at(sfCoverAvailable);
1900 // The 17th digit rounds away.
1901 BEAST_EXPECT(coverAfter == coverBefore);
1902 }
1903 }
1904
1905 void
1907 {
1908 testcase("FixedPrecision coarsened LoanPay transfers principal in full");
1909
1910 using namespace jtx;
1911 using namespace loan;
1912
1913 Number const trustLimit{3, 10};
1914 Number const lenderAmount{11, 9};
1915 Number const borrowerAmount{15, 9};
1917 *this, fixedPrecisionFeatures(), trustLimit, lenderAmount, borrowerAmount};
1918 auto& [env, issuer, lender, borrower, asset] = f;
1919
1920 auto brokerParams = fixedPrecisionBrokerParams();
1921 Number const vaultDeposit{9, 9};
1922 Number const debtMax{9, 9};
1923 brokerParams.vaultDeposit = vaultDeposit;
1924 brokerParams.debtMax = debtMax;
1925 brokerParams.coverDeposit = 1'000'000'000;
1926 auto const broker = createVaultAndBroker(env, asset, lender, brokerParams);
1927
1928 LoanShape const shape{.paymentTotal = 2, .paymentInterval = 2 * 365 * 24 * 60 * 60};
1929 Number const firstLoanPrincipal{7, 9};
1930 auto const firstLoan =
1931 originateLoan(env, broker, borrower, lender, firstLoanPrincipal, shape);
1932 Number const growthLoanPrincipal{1, 9};
1933 auto const growthLoan = originateLoan(
1934 env,
1935 broker,
1936 borrower,
1937 lender,
1938 growthLoanPrincipal,
1939 shape,
1940 kCloseInterestRate(lending::kMaxCloseInterestRate));
1941
1942 auto const vaultBeforeGrowth = env.le(broker.vaultKeylet());
1943 if (!BEAST_EXPECT(vaultBeforeGrowth))
1944 return;
1945 Number const assetsAvailableBeforeGrowth = vaultBeforeGrowth->at(sfAssetsAvailable);
1946 Number const assetsTotalBeforeGrowth = vaultBeforeGrowth->at(sfAssetsTotal);
1947 Number const yieldBeforeGrowth = vaultBeforeGrowth->at(sfYieldUnrealized);
1948
1949 Number const payoffMaximum{1, 10};
1950 payOffGrowthLoan(env, broker, borrower, growthLoan, payoffMaximum);
1951
1952 auto const coarsenedVault = env.le(broker.vaultKeylet());
1953 if (!BEAST_EXPECT(coarsenedVault))
1954 return;
1956 *this,
1957 env,
1958 broker.vaultKeylet(),
1959 {},
1960 {firstLoan, growthLoan},
1961 "after growth payment coarsens vault");
1962 int const coarsenedScale = getVaultScale(coarsenedVault);
1963 BEAST_EXPECTS(
1964 coarsenedScale > getVaultBaseScale(coarsenedVault),
1965 "expected coarsened scale; base " + std::to_string(getVaultBaseScale(coarsenedVault)) +
1966 ", live " + std::to_string(coarsenedScale) + ", total " +
1967 to_string(coarsenedVault->at(sfAssetsTotal)));
1968 BEAST_EXPECTS(
1969 coarsenedVault->at(sfAssetsTotal) > assetsTotalBeforeGrowth,
1970 "AssetsTotal before " + to_string(assetsTotalBeforeGrowth) + ", after " +
1971 to_string(coarsenedVault->at(sfAssetsTotal)));
1972 BEAST_EXPECT(coarsenedVault->at(sfYieldUnrealized) == yieldBeforeGrowth);
1973 Number const vaultCredit =
1974 coarsenedVault->at(sfAssetsAvailable) - assetsAvailableBeforeGrowth;
1975 BEAST_EXPECT(isRounded(asset, vaultCredit, coarsenedScale));
1976 BEAST_EXPECT(isRounded(asset, coarsenedVault->at(sfAssetsTotal), coarsenedScale));
1977 }
1978
1979 void
1981 {
1982 testcase("FixedPrecision coarsened LoanPay single-loan terminal remainder");
1983
1984 using namespace jtx;
1985 using namespace loan;
1986
1987 Number const trustLimit{3, 10};
1988 Number const lenderAmount{11, 9};
1989 Number const borrowerAmount{5, 9};
1991 *this, fixedPrecisionFeatures(), trustLimit, lenderAmount, borrowerAmount};
1992 auto& [env, issuer, lender, borrower, asset] = f;
1993
1994 auto brokerParams = fixedPrecisionBrokerParams();
1995 Number const vaultDeposit{9, 9};
1996 Number const debtMax{2, 9};
1997 brokerParams.vaultDeposit = vaultDeposit;
1998 brokerParams.debtMax = debtMax;
1999 brokerParams.coverDeposit = 200'000'000;
2000 auto const broker = createVaultAndBroker(env, asset, lender, brokerParams);
2001
2002 LoanShape const shape{.paymentTotal = 2, .paymentInterval = 2 * 365 * 24 * 60 * 60};
2003 Number const terminalLoanPrincipal{1'000'000};
2004 auto const terminalLoan =
2005 originateLoan(env, broker, borrower, lender, terminalLoanPrincipal, shape);
2006 Number const growthLoanPrincipal{1, 9};
2007 auto const growthLoan = originateLoan(
2008 env,
2009 broker,
2010 borrower,
2011 lender,
2012 growthLoanPrincipal,
2013 shape,
2014 kCloseInterestRate(lending::kMaxCloseInterestRate));
2015
2016 Number const payoffMaximum{4, 9};
2017 payOffGrowthLoan(env, broker, borrower, growthLoan, payoffMaximum);
2018
2019 auto const vaultBefore = env.le(broker.vaultKeylet());
2020 auto const brokerBefore = env.le(broker.brokerKeylet());
2021 auto const loanBefore = env.le(terminalLoan);
2022 if (!BEAST_EXPECT(vaultBefore && brokerBefore && loanBefore))
2023 return;
2024 BEAST_EXPECT(getVaultScale(vaultBefore) > getVaultBaseScale(vaultBefore));
2025 Number const remaining = loanBefore->at(sfPrincipalOutstanding);
2026 Number const minFirstPrincipal{1, getVaultBaseScale(vaultBefore) + 2};
2027 BEAST_EXPECT(remaining >= minFirstPrincipal);
2028 BEAST_EXPECT(
2029 vaultBefore->at(sfAssetsTotal) - vaultBefore->at(sfAssetsAvailable) == remaining);
2030
2031 Number const assetsAvailableBefore = vaultBefore->at(sfAssetsAvailable);
2032 Number const borrowerBefore = env.balance(borrower, asset).number();
2033 env(pay(borrower, terminalLoan.key, asset(remaining), tfLoanFullPayment));
2034 env.close();
2035
2036 auto const loanAfter = env.le(terminalLoan);
2037 auto const vaultAfter = env.le(broker.vaultKeylet());
2038 if (!BEAST_EXPECT(loanAfter && vaultAfter))
2039 return;
2041 *this,
2042 env,
2043 broker.vaultKeylet(),
2044 {},
2045 {terminalLoan, growthLoan},
2046 "after terminal payment");
2047 BEAST_EXPECT(loanAfter->at(sfPaymentRemaining) == 0);
2048 BEAST_EXPECT(loanAfter->at(sfPrincipalOutstanding) == beast::kZero);
2049
2050 Number const credit = vaultAfter->at(sfAssetsAvailable) - assetsAvailableBefore;
2051 BEAST_EXPECT(borrowerBefore - env.balance(borrower, asset).number() == credit);
2052 BEAST_EXPECT(credit > beast::kZero);
2053 Number const residual = vaultAfter->at(sfAssetsTotal) - vaultAfter->at(sfAssetsAvailable);
2054 BEAST_EXPECT(residual == remaining - credit);
2055 Number const availableCandidate = [&] {
2057 return assetsAvailableBefore + remaining;
2058 }();
2059 int const availableScale =
2060 std::max(getVaultBaseScale(vaultAfter), scale(availableCandidate, asset));
2061 Number const availableUnit{1, availableScale};
2062 BEAST_EXPECT((residual < availableUnit));
2063 }
2064
2065 void
2067 {
2068 testcase("FixedPrecision coarsened LoanPay records interest before credit");
2069
2070 using namespace jtx;
2071 using namespace loan;
2072
2073 Number const trustLimit{3, 10};
2074 Number const lenderAmount{1, 10};
2075 Number const borrowerAmount{5, 9};
2077 *this, fixedPrecisionFeatures(), trustLimit, lenderAmount, borrowerAmount};
2078 auto& [env, issuer, lender, borrower, asset] = f;
2079
2080 auto brokerParams = fixedPrecisionBrokerParams();
2081 Number const vaultDeposit{85, 8};
2082 Number const debtMax{2, 9};
2083 brokerParams.vaultDeposit = vaultDeposit;
2084 brokerParams.debtMax = debtMax;
2085 brokerParams.coverDeposit = 200'000'000;
2086 auto const broker = createVaultAndBroker(env, asset, lender, brokerParams);
2087
2088 LoanShape const shape{.paymentTotal = 2, .paymentInterval = 2 * 365 * 24 * 60 * 60};
2089 Number const targetLoanPrincipal{1'000'000};
2090 std::uint32_t const interestRatePercent = 12;
2091 auto const targetLoan = originateLoan(
2092 env,
2093 broker,
2094 borrower,
2095 lender,
2096 asset(targetLoanPrincipal).value(),
2097 shape,
2098 kInterestRate(percentageToTenthBips(interestRatePercent)));
2099 Number const growthLoanPrincipal{15, 8};
2100 auto const growthLoan = originateLoan(
2101 env,
2102 broker,
2103 borrower,
2104 lender,
2105 asset(growthLoanPrincipal).value(),
2106 shape,
2107 kCloseInterestRate(lending::kMaxCloseInterestRate));
2108
2109 Number const payoffMaximum{4, 9};
2110 payOffGrowthLoan(env, broker, borrower, growthLoan, payoffMaximum);
2111
2112 auto const targetBefore = env.le(targetLoan);
2113 auto const vaultBefore = env.le(broker.vaultKeylet());
2114 if (!BEAST_EXPECT(targetBefore && vaultBefore))
2115 return;
2117 *this, env, broker.vaultKeylet(), {}, {targetLoan, growthLoan}, "after growth payment");
2118 BEAST_EXPECT(getVaultScale(vaultBefore) > getVaultBaseScale(vaultBefore));
2119
2120 Number const principalBefore = targetBefore->at(sfPrincipalOutstanding);
2121 Number const scheduledBefore = scheduledInterest(targetBefore);
2122 Number const yieldBefore = vaultBefore->at(sfYieldUnrealized);
2123 Number const assetsTotalBefore = vaultBefore->at(sfAssetsTotal);
2124 Number const assetsAvailableBefore = vaultBefore->at(sfAssetsAvailable);
2125 Number const borrowerBefore = env.balance(borrower, asset).number();
2126
2127 auto const targetState = getCurrentState(env, broker, targetLoan);
2128 Number const payment =
2129 roundPeriodicPayment(asset, targetState.periodicPayment, targetState.loanScale);
2130 env(pay(borrower, targetLoan.key, asset(payment)));
2131 env.close();
2132
2133 auto const targetAfter = env.le(targetLoan);
2134 auto const vaultAfter = env.le(broker.vaultKeylet());
2135 if (!BEAST_EXPECT(targetAfter && vaultAfter))
2136 return;
2138 *this, env, broker.vaultKeylet(), {}, {targetLoan, growthLoan}, "after target payment");
2139 Number const principalAfter = targetAfter->at(sfPrincipalOutstanding);
2140 Number const scheduledAfter = scheduledInterest(targetAfter);
2141 Number const interestActual = vaultAfter->at(sfAssetsTotal) - assetsTotalBefore;
2142 Number const interestPaid = scheduledBefore - scheduledAfter;
2143 Number const credit = vaultAfter->at(sfAssetsAvailable) - assetsAvailableBefore;
2144
2145 BEAST_EXPECT(interestActual < interestPaid);
2146 BEAST_EXPECT(isRounded(asset, interestActual, getVaultScale(vaultAfter)));
2147 // The vault credit floors the sum principalPaid + interestPaid at
2148 // AssetsAvailable's own posterior grid; interest is not floored into
2149 // AssetsTotal, which is only a derived cache.
2150 Number const principalPaid = principalBefore - principalAfter;
2151 Number const expectedCredit = Number(creditToPosteriorAvailableScale(
2152 vaultBefore,
2153 STAmount{asset, principalPaid + interestPaid},
2155 BEAST_EXPECT(credit == expectedCredit);
2156 BEAST_EXPECT(borrowerBefore - env.balance(borrower, asset).number() == credit);
2157 BEAST_EXPECT(scheduledAfter < scheduledBefore);
2158 BEAST_EXPECT(
2159 vaultAfter->at(sfYieldUnrealized) == yieldBefore + scheduledAfter - scheduledBefore);
2160 // Compare against the derived total; the stored AssetsTotal is a
2161 // floored cache once coarsened.
2162 BEAST_EXPECT(
2163 getAssetsTotal(vaultAfter) - Number(vaultAfter->at(sfAssetsAvailable)) ==
2164 principalAfter);
2165 }
2166
2167 void
2169 {
2170 using namespace jtx;
2171 using namespace loan;
2172
2173 struct Row
2174 {
2175 char const* name = nullptr;
2176 bool late = false;
2177 };
2178 Row const rows[] = {
2179 {.name = "FixedPrecision base-scale overpayment", .late = false},
2180 {.name = "FixedPrecision base-scale late payment", .late = true},
2181 };
2182 for (auto const& row : rows)
2183 {
2184 testcase(row.name);
2185
2186 Number const trustLimit{5'000'000};
2187 Number const lenderAmount{2'000'000};
2188 Number const borrowerAmount{500'000};
2190 *this, fixedPrecisionFeatures(), trustLimit, lenderAmount, borrowerAmount};
2191 auto& [env, issuer, lender, borrower, asset] = f;
2192
2193 auto brokerParams = fixedPrecisionBrokerParams();
2194 Number const debtMax{500'000};
2195 brokerParams.debtMax = debtMax;
2196 brokerParams.coverDeposit = 50'000;
2197 auto const broker = createVaultAndBroker(env, asset, lender, brokerParams);
2198
2199 Number const loanPrincipal{100'000};
2200 std::uint32_t const lateInterestRatePercent = 24;
2201 Number const latePaymentFee{1};
2202 std::uint32_t const interestRatePercent = 12;
2203 std::uint32_t const overpaymentInterestRatePercent = 20;
2204 auto const loanKeylet = row.late
2205 ? originateLoan(
2206 env,
2207 broker,
2208 borrower,
2209 lender,
2210 asset(loanPrincipal).value(),
2211 {.paymentTotal = 12, .paymentInterval = 600},
2212 kLateInterestRate(percentageToTenthBips(lateInterestRatePercent)),
2213 kLatePaymentFee(asset(latePaymentFee).value()))
2214 : originateLoan(
2215 env,
2216 broker,
2217 borrower,
2218 lender,
2219 asset(loanPrincipal).value(),
2220 {
2221 .paymentTotal = 3,
2222 .paymentInterval = 24 * 60 * 60,
2223 .flags = tfLoanOverpayment,
2224 },
2225 kInterestRate(percentageToTenthBips(interestRatePercent)),
2226 kOverpaymentInterestRate(
2227 percentageToTenthBips(overpaymentInterestRatePercent)));
2228
2229 if (row.late)
2230 {
2231 auto const state = getCurrentState(env, broker, loanKeylet);
2232 using Duration = NetClock::duration;
2233 env.close(NetClock::time_point{Duration{state.nextPaymentDate + 1}});
2234 // Covers 3 periods plus a small margin.
2235 std::uint32_t const catchUpPeriods = 3;
2236 Number const catchUpMargin{100};
2237 Number const generousAmount =
2238 roundPeriodicPayment(asset, state.periodicPayment, state.loanScale) *
2239 catchUpPeriods +
2240 asset(catchUpMargin).value();
2241 env(pay(borrower, loanKeylet.key, asset(generousAmount), tfLoanLatePayment));
2242 env.close();
2243 }
2244 else
2245 {
2246 Number const overpayAmount{50'000};
2247 env(pay(borrower, loanKeylet.key, asset(overpayAmount), tfLoanOverpayment));
2248 env.close();
2249 }
2250
2251 auto const loanAfter = env.le(loanKeylet);
2252 auto const vaultAfter = env.le(broker.vaultKeylet());
2253 if (!BEAST_EXPECT(loanAfter && vaultAfter))
2254 return;
2256 *this, env, broker.vaultKeylet(), {}, {loanKeylet}, row.name);
2257 BEAST_EXPECT(getVaultVersion(vaultAfter) == VaultVersion::FixedPrecision);
2258 BEAST_EXPECT(vaultAfter->at(sfYieldUnrealized) == scheduledInterest(loanAfter));
2259 expectPrincipalIsVaultDebt(vaultAfter, loanAfter);
2260 }
2261 }
2262
2263 void
2265 {
2266 using namespace jtx;
2267
2268 for (auto const assetType : {AssetType::XRP, AssetType::MPT})
2269 {
2270 testcase << "FixedPrecision regular LoanPay "
2271 << (assetType == AssetType::XRP ? "XRP" : "MPT");
2272
2273 Env env{*this, fixedPrecisionFeatures()};
2274 Account const issuer{"issuer"};
2275 Account const lender{"lender"};
2276 Account const borrower{"borrower"};
2277
2278 BrokerParameters brokerParams;
2279 brokerParams.vaultDeposit = 100'000;
2280 brokerParams.debtMax = 25'000;
2281 brokerParams.coverDeposit = 1'000;
2282 brokerParams.managementFeeRate = TenthBips16{0};
2283 LoanParameters const loanParams{
2284 .account = borrower,
2285 .counter = lender,
2286 .principalRequest = 1'000,
2287 .payTotal = 2,
2288 .payInterval = 24 * 60 * 60,
2289 };
2290
2291 auto const loanOpt =
2292 createLoan(env, assetType, brokerParams, loanParams, issuer, lender, borrower);
2293 if (BEAST_EXPECT(loanOpt); !loanOpt)
2294 continue;
2295 auto const& [broker, loanKeylet, unusedBrokerPseudo] = *loanOpt;
2296
2297 auto const state = getCurrentState(env, broker, loanKeylet);
2298 topUpBorrower(env, broker, issuer, borrower, state, std::nullopt);
2299 Number const payment =
2300 roundPeriodicPayment(broker.asset, state.periodicPayment, state.loanScale);
2301 env(loan::pay(borrower, loanKeylet.key, STAmount{broker.asset, payment}));
2302 env.close();
2303
2304 auto const loanAfter = env.le(loanKeylet);
2305 auto const vaultAfter = env.le(broker.vaultKeylet());
2306 if (!BEAST_EXPECT(loanAfter && vaultAfter))
2307 continue;
2309 *this, env, broker.vaultKeylet(), {}, {loanKeylet}, "after integral payment");
2310 BEAST_EXPECT(getVaultVersion(vaultAfter) == VaultVersion::FixedPrecision);
2311 BEAST_EXPECT(loanAfter->at(sfPaymentRemaining) == state.paymentRemaining - 1);
2312 expectPrincipalIsVaultDebt(vaultAfter, loanAfter);
2313 }
2314 }
2315
2316 void
2318 {
2319 testcase("FixedPrecision YieldUnrealized equals three-loan sum");
2320
2321 using namespace jtx;
2322 using namespace loan;
2323
2324 Number const trustLimit{10'000'000};
2325 Number const lenderAmount{3'000'000};
2326 Number const borrowerAmount{1'000'000};
2328 *this, fixedPrecisionFeatures(), trustLimit, lenderAmount, borrowerAmount};
2329 auto& [env, issuer, lender, borrower, asset] = f;
2330
2331 auto brokerParams = fixedPrecisionBrokerParams();
2332 Number const vaultDeposit{2'000'000};
2333 Number const debtMax{1'000'000};
2334 brokerParams.vaultDeposit = vaultDeposit;
2335 brokerParams.debtMax = debtMax;
2336 brokerParams.coverDeposit = 100'000;
2337 auto const broker = createVaultAndBroker(env, asset, lender, brokerParams);
2338
2339 std::size_t const loanCount = 3;
2340 Number const loanPrincipal{100'000};
2341 std::uint32_t const interestRatePercent = 12;
2342 std::vector<Keylet> loans;
2343 loans.reserve(loanCount);
2344 for (std::size_t i = 0; i < loanCount; ++i)
2345 {
2347 env,
2348 broker,
2349 borrower,
2350 lender,
2351 asset(loanPrincipal).value(),
2352 {.paymentTotal = 2, .paymentInterval = 24 * 60 * 60},
2353 kInterestRate(percentageToTenthBips(interestRatePercent))));
2354 }
2355
2356 auto const expectedYield = [&] {
2357 Number result;
2358 for (auto const& loanKeylet : loans)
2359 {
2360 auto const loan = env.le(loanKeylet);
2361 if (BEAST_EXPECT(loan))
2362 result += scheduledInterest(loan);
2363 }
2364 return result;
2365 };
2366
2367 auto vault = env.le(broker.vaultKeylet());
2368 if (!BEAST_EXPECT(vault))
2369 return;
2370 BEAST_EXPECT(vault->at(sfYieldUnrealized) == expectedYield());
2371
2372 // Pay two of the three loans.
2373 std::size_t const paidLoanCount = 2;
2374 for (std::size_t i = 0; i < paidLoanCount; ++i)
2375 {
2376 auto const state = getCurrentState(env, broker, loans[i]);
2377 Number const payment =
2378 roundPeriodicPayment(asset, state.periodicPayment, state.loanScale);
2379 env(pay(borrower, loans[i].key, asset(payment)));
2380 env.close();
2381 }
2382
2383 vault = env.le(broker.vaultKeylet());
2384 if (!BEAST_EXPECT(vault))
2385 return;
2387 *this, env, broker.vaultKeylet(), {}, loans, "after two of three loans paid");
2388 BEAST_EXPECT(vault->at(sfYieldUnrealized) == expectedYield());
2389 }
2390
2391 void
2393 {
2394 testcase(
2395 "FixedPrecision YieldUnrealized equals the open-loan sum after overpayment and "
2396 "late payment");
2397
2398 using namespace jtx;
2399 using namespace loan;
2400
2401 Number const trustLimit{10'000'000};
2402 Number const lenderAmount{3'000'000};
2403 Number const borrowerAmount{1'000'000};
2405 *this, fixedPrecisionFeatures(), trustLimit, lenderAmount, borrowerAmount};
2406 auto& [env, issuer, lender, borrower, asset] = f;
2407
2408 auto brokerParams = fixedPrecisionBrokerParams();
2409 Number const vaultDeposit{2'000'000};
2410 Number const debtMax{1'000'000};
2411 brokerParams.vaultDeposit = vaultDeposit;
2412 brokerParams.debtMax = debtMax;
2413 brokerParams.coverDeposit = 100'000;
2414 auto const broker = createVaultAndBroker(env, asset, lender, brokerParams);
2415
2416 Number const loanPrincipal{100'000};
2417 std::uint32_t const interestRatePercent = 12;
2418 std::uint32_t const overpaymentInterestRatePercent = 20;
2419 std::uint32_t const lateInterestRatePercent = 24;
2420 Number const latePaymentFee{1};
2421
2422 // One loan each for overpayment, late payment, and an untouched
2423 // loan still accruing scheduled interest.
2424 auto const overpaidLoan = originateLoan(
2425 env,
2426 broker,
2427 borrower,
2428 lender,
2429 asset(loanPrincipal).value(),
2430 {.paymentTotal = 3, .paymentInterval = 24 * 60 * 60, .flags = tfLoanOverpayment},
2431 kInterestRate(percentageToTenthBips(interestRatePercent)),
2432 kOverpaymentInterestRate(percentageToTenthBips(overpaymentInterestRatePercent)));
2433 auto const lateLoan = originateLoan(
2434 env,
2435 broker,
2436 borrower,
2437 lender,
2438 asset(loanPrincipal).value(),
2439 {.paymentTotal = 12, .paymentInterval = 600},
2440 kInterestRate(percentageToTenthBips(interestRatePercent)),
2441 kLateInterestRate(percentageToTenthBips(lateInterestRatePercent)),
2442 kLatePaymentFee(asset(latePaymentFee).value()));
2443 auto const untouchedLoan = originateLoan(
2444 env,
2445 broker,
2446 borrower,
2447 lender,
2448 asset(loanPrincipal).value(),
2449 {.paymentTotal = 3, .paymentInterval = 24 * 60 * 60},
2450 kInterestRate(percentageToTenthBips(interestRatePercent)));
2451
2452 std::vector<Keylet> const loans{overpaidLoan, lateLoan, untouchedLoan};
2453 auto const expectedYield = [&] {
2454 Number result;
2455 for (auto const& loanKeylet : loans)
2456 {
2457 auto const loan = env.le(loanKeylet);
2458 if (BEAST_EXPECT(loan))
2459 result += scheduledInterest(loan);
2460 }
2461 return result;
2462 };
2463
2464 auto vault = env.le(broker.vaultKeylet());
2465 if (!BEAST_EXPECT(vault))
2466 return;
2467 BEAST_EXPECT(vault->at(sfYieldUnrealized) == expectedYield());
2468
2469 // Overpay the first loan.
2470 Number const overpayAmount{50'000};
2471 env(pay(borrower, overpaidLoan.key, asset(overpayAmount), tfLoanOverpayment));
2472 env.close();
2473
2474 // Pay the second loan late.
2475 auto const lateState = getCurrentState(env, broker, lateLoan);
2476 using Duration = NetClock::duration;
2477 env.close(NetClock::time_point{Duration{lateState.nextPaymentDate + 1}});
2478 // Covers 3 periods plus a small margin.
2479 std::uint32_t const catchUpPeriods = 3;
2480 Number const catchUpMargin{100};
2481 Number const generousAmount =
2482 roundPeriodicPayment(asset, lateState.periodicPayment, lateState.loanScale) *
2483 catchUpPeriods +
2484 asset(catchUpMargin).value();
2485 env(pay(borrower, lateLoan.key, asset(generousAmount), tfLoanLatePayment));
2486 env.close();
2487
2488 // The third loan is left untouched, still contributing its own
2489 // scheduled interest to the sum.
2490 vault = env.le(broker.vaultKeylet());
2491 if (!BEAST_EXPECT(vault))
2492 return;
2494 *this, env, broker.vaultKeylet(), {}, loans, "after overpayment and late payment");
2495 BEAST_EXPECT(vault->at(sfYieldUnrealized) == expectedYield());
2496 }
2497
2498 void
2522
2523 // Tests run under each entry in amendmentCombinations().
2524 void
2526 {
2527#if LOAN_TODO
2528 testLoanPayLateFullPaymentBypassesPenalties(features);
2529#endif
2532 testDosLoanPay(features);
2534 }
2535
2536public:
2537 void
2538 run() override
2539 {
2541 for (auto const& features : jtx::amendmentCombinations(
2542 {fixCleanup3_1_3, fixCleanup3_2_0, featureMPTokensV2}, all_))
2543 runAmendmentSensitive(features);
2544 }
2545};
2546
2548
2549} // namespace xrpl::test
A generic endpoint for log messages.
Definition Journal.h:44
A testsuite class.
Definition suite.h:52
TestcaseT testcase
Memberspace for declaring test cases.
Definition suite.h:155
Value removeMember(char const *key)
Remove and return the named member.
constexpr TIss const & get() const
A currency issued by an account.
Definition Issue.h:18
static constexpr std::uint32_t kDefaultGracePeriod
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
bool modify(ModifyType const &f)
Modify the open ledger.
Writable ledger view that accumulates state and tx changes.
Definition OpenView.h:59
void rawReplace(SLE::Ref sle) override
Unconditionally replace a state item.
Definition OpenView.cpp:246
SLE::const_pointer read(Keylet const &k) const override
Return the state item associated with a key.
Definition OpenView.cpp:170
Asset const & asset() const
Definition STAmount.h:496
std::shared_ptr< STLedgerEntry const > const_pointer
static constexpr SeqProxy rawSequence(std::uint32_t v)
Factory function to return a sequence-based SeqProxy.
Definition SeqProxy.h:62
virtual OpenLedger & getOpenLedger()=0
static BrokerParameters fixedPrecisionBrokerParams()
void run() override
Runs the suite.
FeatureBitset fixedPrecisionFeatures() const
void testLoanPayAtExactDueDateSucceedsPostAmendment()
void testFixedPrecisionCoarsenedInterestPayment()
void testDosLoanPay(FeatureBitset features)
void testLoanPayFundsConservedPayeeBelowReserve(FeatureBitset features)
void setLoanNextPaymentDueDate(jtx::Env &env, Keylet const &loanKeylet, std::uint32_t dueDate)
void testFixedPrecisionCoarsenedSingleLoanTerminal()
void payOffGrowthLoan(jtx::Env &env, BrokerInfo const &broker, jtx::Account const &borrower, Keylet const &growthLoan, Number const &maximum)
void testLoanLatePaymentAtExactDueDateRejectedPostAmendment()
void testLoanSetNearZeroInterestRateSucceeds()
void testLoanPayAtExactDueDateFailsPreAmendment()
void testLoanPaySelfBrokerExistingLineDefaultRipple()
void runAmendmentSensitive(FeatureBitset features)
void testLoanNextPaymentDueDateOverflow(FeatureBitset features)
void testOverpaymentManagementFee(FeatureBitset features)
void testLoanPayCatchUpFeeAtExactDueDatePostAmendment()
void expectPrincipalIsVaultDebt(SLE::const_pointer const &vault, SLE::const_pointer const &loan)
void testFixedPrecisionYieldAfterOverpaymentAndLatePayment()
static Number scheduledInterest(SLE::const_pointer const &loan)
void testLoanPayCatchUpFeeAtExactDueDatePreAmendment()
Keylet originateLoan(jtx::Env &env, BrokerInfo const &broker, jtx::Account const &borrower, jtx::Account const &lender, Principal &&principal, LoanShape const &shape, Extra &&... extra)
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_
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.
Keylet nextLoanKeylet(jtx::Env const &env, BrokerInfo const &broker)
std::optional< std::tuple< BrokerInfo, Keylet, jtx::Account > > createLoan(jtx::Env &env, AssetType assetType, BrokerParameters const &brokerParams, LoanParameters const &loanParams, jtx::Account const &issuer, jtx::Account const &lender, jtx::Account const &borrower)
static jtx::PrettyAsset createFundedRippleIouAsset(jtx::Env &env, jtx::Account const &issuer, jtx::Account const &lender, jtx::Account const &borrower, Number const &lenderPay=1 '000 '000, Number const &borrowerPay=1 '000 '000)
std::string const iouCurrency_
static void topUpBorrower(jtx::Env &env, BrokerInfo const &broker, jtx::Account const &issuer, jtx::Account const &borrower, LoanState const &state, std::optional< Number > const &servFee)
Immutable cryptographic account descriptor.
Definition jtx/Account.h:21
AccountID id() const
Returns the Account ID.
A transaction testing environment.
Definition Env.h:161
Application & app()
Definition Env.h:300
bool close(NetClock::time_point closeTime, std::optional< std::chrono::milliseconds > consensusDelay=std::nullopt)
Close and advance the ledger.
Definition Env.cpp:133
TER ter() const
Return the TER for the last JTx.
Definition Env.h:844
json::Value json(JsonValue &&jv, FN const &... fN)
Create JSON from parameters.
Definition Env.h:752
SLE::const_pointer le(Account const &account) const
Return an account root.
Definition Env.cpp:311
bool enabled(UInt256 feature) const
Definition Env.h:886
void fund(bool setDefaultRipple, STAmount const &amount, Account const &account)
Definition Env.cpp:323
PrettyAmount balance(Account const &account) const
Returns the XRP balance on an account.
Definition Env.cpp:201
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
Inject raw JSON.
Definition jtx_json.h:16
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 count(T... args)
T forward(T... args)
T is_same_v
T make_shared(T... args)
T max(T... args)
T min(T... args)
constexpr Zero kZero
Definition Zero.h:30
@ Object
object value (collection of name/value pairs).
Definition json_value.h:33
Keylet computation functions.
Definition Indexes.h:39
Keylet vault(AccountID const &owner, SeqProxy const &seq) noexcept
Definition Indexes.cpp:565
Keylet loanBroker(AccountID const &owner, SeqProxy const &seq) noexcept
Definition Indexes.cpp:571
Keylet account(AccountID const &id) noexcept
AccountID root.
Definition Indexes.cpp:233
Keylet loan(UInt256 const &loanBrokerID, SeqProxy const &loanSeq) noexcept
Definition Indexes.cpp:577
Keylet trustLine(AccountID const &id0, AccountID const &id1, Currency const &currency) noexcept
The index of a trust line for a given currency.
Definition Indexes.cpp:287
constexpr TenthBips32 kMaxCloseInterestRate
The maximum close interest rate charged for repaying a loan early in 1/10 bips.
Definition Protocol.h:193
json::Value coverDeposit(AccountID const &account, UInt256 const &brokerID, STAmount const &amount, uint32_t flags)
json::Value set(AccountID const &account, UInt256 const &loanBrokerID, Number principalRequested, std::uint32_t flags)
auto const kOverpaymentInterestRate
json::Value pay(AccountID const &account, UInt256 const &loanID, STAmount const &amount, std::uint32_t flags)
json::Value pay(AccountID const &account, AccountID const &to, AnyAmount amount)
Create a payment.
Definition pay.cpp:14
std::vector< FeatureBitset > amendmentCombinations(std::initializer_list< UInt256 > features, FeatureBitset seed)
Returns all 2^N permutations of a seed FeatureBitset with each subset of the given features excluded.
Definition Env.h:123
XrpT const XRP
Converts to XRP Issue or STAmount.
Definition amount.cpp:92
json::Value noop(Account const &account)
The null transaction.
Definition noop.h:14
std::uint32_t ownerCount(Env const &env, Account const &account)
json::Value fclear(Account const &account, std::uint32_t off)
Remove account flag.
Definition flags.h:110
json::Value trust(Account const &account, STAmount const &amount, std::uint32_t flags)
Modify a trust line.
Definition trust.cpp:18
json::Value fset(Account const &account, std::uint32_t on, std::uint32_t off=0)
Add and/or remove flag.
Definition flags.cpp:15
BEAST_DEFINE_TESTSUITE(AMMClawback, app, xrpl)
void checkFixedPrecisionVaultAssetsDeployed(beast::unit_test::Suite &suite, jtx::Env &env, Keylet const &vaultKeylet, std::vector< Keylet > const &brokerKeylets, std::vector< Keylet > const &loanKeylets, std::string const &label={})
constexpr XRPAmount
Convert XRP to drops (integral types).
Definition TxTest.h:53
Use hash_* containers for keys that do not need a cryptographically secure hashing algorithm.
Definition algorithm.h:5
@ telINSUF_FEE_P
Definition TER.h:43
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
Number loanPeriodicRate(TenthBips32 interestRate, std::uint32_t paymentInterval)
constexpr TenthBips32 percentageToTenthBips(std::uint32_t percentage)
Definition Protocol.h:127
int scale(Number const &number, Asset const &asset)
Get the scale of a Number for a given asset.
Definition STAmount.h:819
int getVaultScale(SLE::ConstRef vault)
Return the Vault's current live exponent.
TenthBips< std::uint32_t > TenthBips32
Definition Units.h:454
static FunctionType fixed(Keylet const &keylet)
TenthBips< std::uint16_t > TenthBips16
Definition Units.h:453
boost::outcome_v2::result< T, std::error_code > Result
Definition b58_utils.h:19
std::string to_string(BaseUInt< Bits, Tag > const &a)
Definition base_uint.h:658
STAmount roundToScale(STAmount const &value, std::int32_t scale, Number::RoundingMode rounding=Number::getround())
Round an arbitrary precision Amount to the precision of an STAmount that has a given exponent.
int getVaultBaseScale(SLE::ConstRef vault)
Return the Vault's base exponent.
LoanState computeTheoreticalLoanState(Rules const &rules, Number const &periodicPayment, Number const &periodicRate, std::uint32_t const paymentRemaining, TenthBips32 const managementFeeRate)
void roundToAsset(A const &asset, Number &value)
Round an arbitrary precision Number IN PLACE to the precision of a given Asset.
Definition STAmount.h:745
BaseUInt< 160, detail::AccountIDTag > AccountID
A 160-bit unsigned that uniquely identifies an account.
Definition AccountID.h:34
Number roundPeriodicPayment(Asset const &asset, Number const &periodicPayment, std::int32_t scale)
Ensure the periodic payment is always rounded consistently.
@ temBAD_AMOUNT
Definition TER.h:77
bool isTesSuccess(TER x) noexcept
Definition TER.h:686
Number computeManagementFee(Asset const &asset, Number const &interest, TenthBips32 managementFeeRate, std::int32_t scale)
TERSubset< CanCvtToTER > TER
Definition TER.h:657
@ tecNO_AUTH
Definition TER.h:311
@ tecINTERNAL
Definition TER.h:321
@ tecTOO_SOON
Definition TER.h:329
@ tecEXPIRED
Definition TER.h:325
@ tecPRECISION_LOSS
Definition TER.h:374
@ tecKILLED
Definition TER.h:327
Number getAssetsTotal(SLE::ConstRef vault)
Return the Vault's current assets total.
VaultVersion getVaultVersion(SLE::ConstRef vault)
Resolves a Vault's LEVersion.
LoanState constructLoanState(Number const &totalValueOutstanding, Number const &principalOutstanding, Number const &managementFeeOutstanding)
STAmount creditToPosteriorAvailableScale(SLE::ConstRef vault, Number const &raw, Number::RoundingMode roundingMode)
Round a FixedPrecision cash inflow (LoanPay's credit, LoanManage's default cover credit) into AssetsA...
@ tesSUCCESS
Definition TER.h:253
Number computeFullPaymentInterest(Number const &theoreticalPrincipalOutstanding, Number const &periodicRate, NetClock::time_point parentCloseTime, std::uint32_t paymentInterval, std::uint32_t prevPaymentDate, std::uint32_t startDate, TenthBips32 closeInterestRate)
bool isRounded(Asset const &asset, Number const &value, std::int32_t scale)
T push_back(T... args)
T reserve(T... args)
A pair of SHAMap key and LedgerEntryType.
Definition Keylet.h:20
UInt256 key
Definition Keylet.h:21
FixedPrecisionIOU(beast::unit_test::Suite &suite, FeatureBitset features, Number const &trustLimit, Number const &lenderAmount, Number const &borrowerAmount)
std::optional< std::uint8_t > vaultScale
T to_string(T... args)