xrpld
Loading...
Searching...
No Matches
LoanSecurity_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/noop.h>
8#include <test/jtx/sponsor.h>
9#include <test/jtx/ter.h>
10#include <test/jtx/txflags.h>
11#include <test/jtx/vault.h>
12
13#include <xrpl/basics/Number.h>
14#include <xrpl/basics/chrono.h>
15#include <xrpl/beast/unit_test/suite.h>
16#include <xrpl/beast/utility/Journal.h>
17#include <xrpl/beast/utility/Zero.h>
18#include <xrpl/core/ServiceRegistry.h>
19#include <xrpl/json/to_string.h>
20#include <xrpl/ledger/OpenView.h>
21#include <xrpl/ledger/helpers/LendingHelpers.h>
22#include <xrpl/protocol/Feature.h>
23#include <xrpl/protocol/Indexes.h>
24#include <xrpl/protocol/Issue.h>
25#include <xrpl/protocol/Keylet.h>
26#include <xrpl/protocol/LedgerFormats.h>
27#include <xrpl/protocol/Protocol.h>
28#include <xrpl/protocol/SField.h>
29#include <xrpl/protocol/STAmount.h>
30#include <xrpl/protocol/SeqProxy.h>
31#include <xrpl/protocol/TER.h>
32#include <xrpl/protocol/TxFlags.h>
33#include <xrpl/protocol/Units.h>
34#include <xrpl/protocol/jss.h>
35
36#include <algorithm>
37#include <cstdint>
38#include <memory>
39#include <ostream>
40
41namespace xrpl::test {
42
44{
45private:
46 // Env::close() cannot land the ledger's parentCloseTime on an arbitrary
47 // instant: it always rounds the requested time forward to the next
48 // close-time-resolution boundary (see Env::close() and
49 // roundCloseTime()/effCloseTime() in LedgerTiming.h), so it can only be
50 // used to reach times strictly *after* a given due date, never exactly
51 // on it. To pin the exact-boundary behavior of isPaymentLate(), directly
52 // overwrite the loan's NextPaymentDueDate instead, without closing the
53 // ledger again.
54 void
55 setLoanNextPaymentDueDate(jtx::Env& env, Keylet const& loanKeylet, std::uint32_t dueDate)
56 {
57 using namespace jtx;
58 bool const ok = env.app().getOpenLedger().modify([&](OpenView& view, beast::Journal) {
59 auto const sle = view.read(loanKeylet);
60 if (!sle)
61 return false;
62 auto const replacement = std::make_shared<SLE>(*sle);
63 (*replacement)[sfNextPaymentDueDate] = dueDate;
64 view.rawReplace(replacement);
65 return true;
66 });
67 BEAST_EXPECT(ok);
68 }
69
70 void
72 {
73 // --- PoC Summary ----------------------------------------------------
74 // Scenario: Borrower makes one periodic payment early (before next due)
75 // so doPayment sets sfPreviousPaymentDueDate to the (future)
76 // sfNextPaymentDueDate and advances sfNextPaymentDueDate by one
77 // interval. Borrower then immediately performs a full-payment
78 // (tfLoanFullPayment). Why it matters: Full-payment interest accrual
79 // uses
80 // delta = now - max(prevPaymentDate, startDate)
81 // with an unsigned clock representation (uint32). If prevPaymentDate is
82 // in the future, the subtraction underflows to a very large positive
83 // number. This inflates roundedFullInterest and total full-close due,
84 // and LoanPay applies the inflated valueChange to the vault
85 // (sfAssetsTotal), increasing NAV.
86 // --------------------------------------------------------------------
87 testcase("PoC: Unsigned-underflow full-pay accrual after early periodic");
88
89 using namespace jtx;
90 using namespace loan;
91 using namespace std::chrono_literals;
92
93 Env env{*this, features};
94
95 Account const lender{"poc_lender4"};
96 Account const borrower{"poc_borrower4"};
97 env.fund(XRP(3'000'000), lender, borrower);
98 env.close();
99
100 PrettyAsset const asset{xrpIssue(), 1'000'000};
101 BrokerParameters const brokerParams{};
102 auto const broker = createVaultAndBroker(env, asset, lender, brokerParams);
103
104 // Create a 3-payment loan so full-payment path is enabled after 1
105 // periodic payment.
106 auto const loanSetFee = Fee(env.current()->fees().base * 2);
107 Number const principalRequest = asset(1000).value();
108 auto const originationFee = asset(0).value();
109 auto const serviceFee = asset(1).value();
110 auto const serviceFeePA = asset(1);
111 auto const lateFee = asset(0).value();
112 auto const closeFee = asset(0).value();
113 auto const interest = percentageToTenthBips(12);
114 auto const lateInterest = percentageToTenthBips(12) / 10;
115 auto const closeInterest = percentageToTenthBips(12) / 10;
116 auto const overpaymentInterest = percentageToTenthBips(12) / 10;
117 auto const total = 3u;
118 auto const interval = 600u;
119 auto const grace = 60u;
120
121 auto const createJtx = env.jt(
122 set(borrower, broker.brokerID, principalRequest, 0),
123 Sig(sfCounterpartySignature, lender),
124 kLoanOriginationFee(originationFee),
125 kLoanServiceFee(serviceFee),
126 kLatePaymentFee(lateFee),
127 kClosePaymentFee(closeFee),
128 kOverpaymentFee(percentageToTenthBips(5) / 10),
129 kInterestRate(interest),
130 kLateInterestRate(lateInterest),
131 kCloseInterestRate(closeInterest),
132 kOverpaymentInterestRate(overpaymentInterest),
133 kPaymentTotal(total),
134 kPaymentInterval(interval),
135 kGracePeriod(grace),
136 Fee(loanSetFee));
137
138 auto const brokerSle = env.le(keylet::loanBroker(broker.brokerID));
139 BEAST_EXPECT(brokerSle);
140 auto const loanSequence = brokerSle ? brokerSle->at(sfLoanSequence) : 0;
141 auto const loanKeylet = keylet::loan(broker.brokerID, SeqProxy::rawSequence(loanSequence));
142
143 env(createJtx);
144 env.close();
145
146 // Compute a regular periodic due and pay it early (before next due).
147 auto const state = getCurrentState(env, broker, loanKeylet);
148 Number const periodicRate = loanPeriodicRate(state.interestRate, state.paymentInterval);
149 auto const components = xrpl::detail::computePaymentComponents(
150 env.current()->rules(),
151 asset.raw(),
152 state.loanScale,
153 state.totalValue,
154 state.principalOutstanding,
155 state.managementFeeOutstanding,
156 state.periodicPayment,
157 periodicRate,
158 state.paymentRemaining,
159 brokerParams.managementFeeRate);
160 STAmount const regularDue{asset, components.trackedValueDelta + serviceFeePA.number()};
161 // now < nextDue immediately after creation, so this is an early pay.
162 env(pay(borrower, loanKeylet.key, regularDue));
163 env.close();
164
165 // Immediately attempt a full payoff. Compute the exact full-payment
166 // due to ensure the tx applies.
167 auto const after = getCurrentState(env, broker, loanKeylet);
168 auto const loanSle = env.le(loanKeylet);
169 BEAST_EXPECT(loanSle);
170 auto const brokerSle2 = env.le(keylet::loanBroker(broker.brokerID));
171 BEAST_EXPECT(brokerSle2);
172
173 auto const closePaymentFee = loanSle ? loanSle->at(sfClosePaymentFee) : Number{};
174 auto const closeInterestRate =
175 loanSle ? TenthBips32{loanSle->at(sfCloseInterestRate)} : TenthBips32{};
176 auto const managementFeeRate =
177 brokerSle2 ? TenthBips16{brokerSle2->at(sfManagementFeeRate)} : TenthBips16{};
178
179 Number const periodicRate2 = loanPeriodicRate(after.interestRate, after.paymentInterval);
180 // Accrued + prepayment-penalty interest based on current periodic
181 // schedule
182 auto const fullPaymentInterest = computeFullPaymentInterest(
184 env.current()->rules(),
185 after.periodicPayment,
186 periodicRate2,
187 after.paymentRemaining),
188 periodicRate2,
189 env.current()->parentCloseTime(),
190 after.paymentInterval,
191 after.previousPaymentDate,
192 static_cast<std::uint32_t>(after.startDate.time_since_epoch().count()),
193 closeInterestRate);
194
195 // Round to asset scale and split interest/fee parts
196 auto const roundedInterest =
197 roundToAsset(asset.raw(), fullPaymentInterest, after.loanScale);
198 Number const roundedFullMgmtFee =
199 computeManagementFee(asset.raw(), roundedInterest, managementFeeRate, after.loanScale);
200 Number const roundedFullInterest = roundedInterest - roundedFullMgmtFee;
201
202 // Show both signed and unsigned deltas to highlight the underflow.
203 auto const nowSecs =
204 static_cast<std::uint32_t>(env.current()->parentCloseTime().time_since_epoch().count());
205 auto const startSecs =
206 static_cast<std::uint32_t>(after.startDate.time_since_epoch().count());
207 auto const lastPaymentDate = std::max(after.previousPaymentDate, startSecs);
208 auto const signedDelta =
209 static_cast<std::int64_t>(nowSecs) - static_cast<std::int64_t>(lastPaymentDate);
210 auto const unsignedDelta = static_cast<std::uint32_t>(nowSecs - lastPaymentDate);
211 log << "PoC window: prev=" << after.previousPaymentDate << " start=" << startSecs
212 << " now=" << nowSecs << " signedDelta=" << signedDelta
213 << " unsignedDelta=" << unsignedDelta << std::endl;
214
215 // Reference (clamped) computation: emulate a non-negative accrual
216 // window by clamping prevPaymentDate to 'now' for the full-pay path.
217 auto const prevClamped = std::min(after.previousPaymentDate, nowSecs);
218 auto const fullPaymentInterestClamped = computeFullPaymentInterest(
220 env.current()->rules(),
221 after.periodicPayment,
222 periodicRate2,
223 after.paymentRemaining),
224 periodicRate2,
225 env.current()->parentCloseTime(),
226 after.paymentInterval,
227 prevClamped,
228 startSecs,
229 closeInterestRate);
230 auto const roundedInterestClamped =
231 roundToAsset(asset.raw(), fullPaymentInterestClamped, after.loanScale);
232 Number const roundedFullMgmtFeeClamped = computeManagementFee(
233 asset.raw(), roundedInterestClamped, managementFeeRate, after.loanScale);
234 Number const roundedFullInterestClamped =
235 roundedInterestClamped - roundedFullMgmtFeeClamped;
236 STAmount const fullDueClamped{
237 asset,
238 after.principalOutstanding + roundedFullInterestClamped + roundedFullMgmtFeeClamped +
239 closePaymentFee};
240
241 // Collect vault NAV before closing payment
242 auto const vaultId2 = brokerSle2 ? brokerSle2->at(sfVaultID) : UInt256{};
243 auto const vaultKey2 = keylet::vault(vaultId2);
244 auto const vaultBefore = env.le(vaultKey2);
245 BEAST_EXPECT(vaultBefore);
246 Number const assetsTotalBefore = vaultBefore ? vaultBefore->at(sfAssetsTotal) : Number{};
247
248 STAmount const fullDue{
249 asset,
250 after.principalOutstanding + roundedFullInterest + roundedFullMgmtFee +
251 closePaymentFee};
252
253 log << "PoC payoff: principalOutstanding=" << after.principalOutstanding
254 << " roundedFullInterest=" << roundedFullInterest
255 << " roundedFullMgmtFee=" << roundedFullMgmtFee << " closeFee=" << closePaymentFee
256 << " fullDue=" << to_string(fullDue.getJson()) << std::endl;
257 log << "PoC reference (clamped): roundedFullInterestClamped=" << roundedFullInterestClamped
258 << " roundedFullMgmtFeeClamped=" << roundedFullMgmtFeeClamped
259 << " fullDueClamped=" << to_string(fullDueClamped.getJson()) << std::endl;
260
261 env(pay(borrower, loanKeylet.key, fullDue), Txflags(tfLoanFullPayment));
262 env.close();
263
264 // Sanity: underflow present (unsigned delta very large relative to
265 // interval)
266 BEAST_EXPECT(unsignedDelta > after.paymentInterval);
267
268 // Compare vault NAV before/after the full close
269 auto const vaultAfter = env.le(vaultKey2);
270 BEAST_EXPECT(vaultAfter);
271 if (vaultAfter)
272 {
273 auto const assetsTotalAfter = vaultAfter->at(sfAssetsTotal);
274 log << "PoC NAV: assetsTotalBefore=" << assetsTotalBefore
275 << " assetsTotalAfter=" << assetsTotalAfter
276 << " delta=" << (assetsTotalAfter - assetsTotalBefore) << std::endl;
277
278 // Regression check: the underflowed window must be clamped so the
279 // payoff matches the non-underflow reference, i.e. no overcharge.
280 BEAST_EXPECT(fullDue == fullDueClamped);
281 if (fullDue != fullDueClamped)
282 log << "PoC delta: overcharge (fullDue > clamped)" << std::endl;
283 }
284
285 // Loan should be paid off
286 auto const finalLoan = env.le(loanKeylet);
287 BEAST_EXPECT(finalLoan);
288 if (finalLoan)
289 {
290 BEAST_EXPECT(finalLoan->at(sfPaymentRemaining) == 0);
291 BEAST_EXPECT(finalLoan->at(sfPrincipalOutstanding) == 0);
292 }
293 }
294
295 void
297 {
298 using namespace jtx;
299
300 testcase("RIPD-3831");
301
302 Account const issuer("issuer");
303 Account const lender("lender");
304 Account const borrower("borrower");
305
306 BrokerParameters const brokerParams{
307 .vaultDeposit = 100000,
308 .debtMax = 0,
309 .coverRateMin = TenthBips32{0},
310 // .managementFeeRate = TenthBips16{5919},
311 .coverRateLiquidation = TenthBips32{0},
312 };
313 LoanParameters const loanParams{
314 .account = lender,
315 .counter = borrower,
316 .principalRequest = Number{200'000, -6},
317 .lateFee = Number{200, -6},
318 .interest = TenthBips32{50'000},
319 .payTotal = 10,
320 .payInterval = 150,
321 };
322
323 auto const assetType = AssetType::XRP;
324
325 Env env{*this, features};
326
327 auto loanResult =
328 createLoan(env, assetType, brokerParams, loanParams, issuer, lender, borrower);
329
330 if (BEAST_EXPECT(loanResult); !loanResult.has_value())
331 return;
332
333 auto const broker = std::get<BrokerInfo>(*loanResult);
334 auto const loanKeylet = std::get<Keylet>(*loanResult);
335
336 using Tp = NetClock::time_point;
337 using D = NetClock::duration;
338
339 auto const state = getCurrentState(env, broker, loanKeylet);
340 if (auto const loan = env.le(loanKeylet); BEAST_EXPECT(loan))
341 {
342 env.close(Tp{D{loan->at(sfNextPaymentDueDate) + loan->at(sfGracePeriod) + 1}});
343 }
344
345 topUpBorrower(env, broker, issuer, borrower, state, loanParams.serviceFee);
346
347 using namespace jtx::loan;
348
349 auto const jv = pay(borrower, loanKeylet.key, drops(XRPAmount(state.totalValue)));
350
351 {
352 auto const submitParam = to_string(jv);
353 auto const jr = env.rpc("submit", borrower.name(), submitParam);
354
355 BEAST_EXPECT(jr.isMember(jss::result));
356 }
357
358 env.close();
359
360 // Make sure the system keeps responding
361 env(noop(borrower));
362 env.close();
363 env(noop(issuer));
364 env.close();
365 env(noop(lender));
366 env.close();
367 }
368
369 void
371 {
372 testcase("RIPD-3459 - LoanBroker incorrect debt total");
373
374 using namespace jtx;
375
376 Account const issuer("issuer");
377 Account const lender("lender");
378 Account const borrower("borrower");
379
380 BrokerParameters const brokerParams{
381 .vaultDeposit = 200'000,
382 .debtMax = 0,
383 .coverRateMin = TenthBips32{0},
384 .managementFeeRate = TenthBips16{500},
385 .coverRateLiquidation = TenthBips32{0},
386 };
387 LoanParameters const loanParams{
388 .account = lender,
389 .counter = borrower,
390 .principalRequest = Number{100'000, -4},
391 .interest = TenthBips32{100'000},
392 .payTotal = 10,
393 };
394
395 auto const assetType = AssetType::MPT;
396
397 Env env{*this, features};
398
399 auto loanResult =
400 createLoan(env, assetType, brokerParams, loanParams, issuer, lender, borrower);
401
402 if (BEAST_EXPECT(loanResult); !loanResult.has_value())
403 return;
404
405 auto const broker = std::get<BrokerInfo>(*loanResult);
406 auto const loanKeylet = std::get<Keylet>(*loanResult);
407 auto const pseudoAcct = std::get<Account>(*loanResult);
408
409 VerifyLoanStatus const verifyLoanStatus(env, broker, pseudoAcct, loanKeylet);
410
411 if (auto const brokerSle = env.le(broker.brokerKeylet()); BEAST_EXPECT(brokerSle))
412 {
413 if (auto const loanSle = env.le(loanKeylet); BEAST_EXPECT(loanSle))
414 {
415 BEAST_EXPECT(brokerSle->at(sfDebtTotal) == loanSle->at(sfTotalValueOutstanding));
416 }
417 }
418
420 env,
421 broker,
422 loanParams,
423 loanKeylet,
424 verifyLoanStatus,
425 issuer,
426 lender,
427 borrower,
428 PaymentParameters{.showStepBalances = true});
429
430 if (auto const brokerSle = env.le(broker.brokerKeylet()); BEAST_EXPECT(brokerSle))
431 {
432 if (auto const loanSle = env.le(loanKeylet); BEAST_EXPECT(loanSle))
433 {
434 BEAST_EXPECT(brokerSle->at(sfDebtTotal) == loanSle->at(sfTotalValueOutstanding));
435 BEAST_EXPECT(brokerSle->at(sfDebtTotal) == beast::kZero);
436 }
437 }
438 }
439
440 void
442 {
443 testcase("Crash with tfLoanOverpayment");
444 using namespace jtx;
445 using namespace loan;
446 Account const lender{"lender"};
447 Account const issuer{"issuer"};
448 Account const borrower{"borrower"};
449 Account const depositor{"depositor"};
450 auto const txFee = Fee(XRP(100));
451
452 // Under featureLendingProtocolV1_1 LoanBrokerSet::preclaim only
453 // accepts closed-ended vaults, so build one and advance past
454 // SubscriptionDate before creating the broker and the loan.
455 Env env(*this);
456 Vault const vault(env);
457
458 env.fund(XRP(10'000), lender, issuer, borrower, depositor);
459 env.close();
460
461 auto [tx, vaultKeyLet, subscriptionDate] =
462 vault.createClosedEnded({.owner = lender, .asset = xrpIssue()});
463 env(tx, txFee);
464 env.close();
465
466 env(vault.deposit({.depositor = depositor, .id = vaultKeyLet.key, .amount = XRP(1'000)}),
467 txFee);
468 env.close();
469
470 // Move into the Investment phase before creating the broker and
471 // the loan.
472 vault.closePastSubscription(subscriptionDate);
473
474 auto const brokerKeyLet =
475 keylet::loanBroker(lender.id(), SeqProxy::rawSequence(env.seq(lender)));
476
477 env(loan_broker::set(lender, vaultKeyLet.key), txFee);
478 env.close();
479
480 STAmount const debtMaximumRequest = XRPAmount(200'000);
481
482 env(set(borrower, brokerKeyLet.key, debtMaximumRequest),
483 Sig(sfCounterpartySignature, lender),
484 kInterestRate(TenthBips32(50'000)),
485 kPaymentTotal(2),
486 kPaymentInterval(150),
487 Txflags(tfLoanOverpayment),
488 txFee);
489 env.close();
490
491 std::uint32_t const loanSequence = 1;
492 auto const loanKeylet = keylet::loan(brokerKeyLet.key, SeqProxy::rawSequence(loanSequence));
493
494 if (auto const loan = env.le(loanKeylet); env.test.BEAST_EXPECT(loan))
495 {
496 env(loan::pay(borrower, loanKeylet.key, XRPAmount(150'001)),
497 Txflags(tfLoanOverpayment),
498 txFee);
499 env.close();
500 }
501 }
502
503 void
505 {
506 testcase("RIPD-3902 - 1 IOU loan payments");
507
508 using namespace jtx;
509
510 Account const issuer("issuer");
511 Account const lender("lender");
512 Account const borrower("borrower");
513
514 BrokerParameters const brokerParams{
515 .vaultDeposit = 10,
516 .debtMax = 0,
517 .coverRateMin = TenthBips32{0},
518 .managementFeeRate = TenthBips16{0},
519 .coverRateLiquidation = TenthBips32{0},
520 };
521 LoanParameters const loanParams{
522 .account = lender,
523 .counter = borrower,
524 .principalRequest = Number{1, 0},
525 .interest = TenthBips32{100'000},
526 .payTotal = 5,
527 .payInterval = 150,
528 .gracePd = 60,
529 };
530
531 auto const assetType = AssetType::IOU;
532
533 Env env{*this, features};
534
535 auto loanResult =
536 createLoan(env, assetType, brokerParams, loanParams, issuer, lender, borrower);
537
538 if (BEAST_EXPECT(loanResult); !loanResult.has_value())
539 return;
540
541 auto const broker = std::get<BrokerInfo>(*loanResult);
542 auto const loanKeylet = std::get<Keylet>(*loanResult);
543 auto const pseudoAcct = std::get<Account>(*loanResult);
544
545 VerifyLoanStatus const verifyLoanStatus(env, broker, pseudoAcct, loanKeylet);
546
548 env,
549 broker,
550 loanParams,
551 loanKeylet,
552 verifyLoanStatus,
553 issuer,
554 lender,
555 borrower,
556 PaymentParameters{.showStepBalances = true});
557 }
558
559 // Verify that with fixCleanup3_4_0:
560 // 1. A loan cannot be impaired before its payment is late.
561 // 2. Impairing a late loan does not change sfNextPaymentDueDate.
562 // 3. The unimpair operation does not change sfNextPaymentDueDate.
563 void
565 {
566 using namespace jtx;
567 using namespace loan;
568 using namespace std::chrono_literals;
569
570 testcase("Impairment does not change payment due date");
571
572 Env env(*this, all_ | fixCleanup3_4_0);
573 BEAST_EXPECT(env.enabled(fixCleanup3_4_0));
574
575 Account const lender{"lender"};
576 Account const borrower{"borrower"};
577
578 env.fund(XRP(100'000'000), lender, borrower);
579 env.close();
580
581 PrettyAsset const xrpAsset{xrpIssue(), 1'000'000};
582 auto const broker = createVaultAndBroker(env, xrpAsset, lender);
583
584 auto const sleBroker = env.le(keylet::loanBroker(broker.brokerID));
585 if (!BEAST_EXPECT(sleBroker))
586 return;
587 auto const loanKeylet =
588 keylet::loan(broker.brokerID, SeqProxy::rawSequence(sleBroker->at(sfLoanSequence)));
589
590 Number const principalRequest{1, 3};
591 env(set(borrower, broker.brokerID, broker.asset(principalRequest).value()),
592 Sig(sfCounterpartySignature, lender),
593 kPaymentTotal(12),
594 kPaymentInterval(600),
595 Fee(env.current()->fees().base * 2));
596 env.close();
597
598 auto const loanSle = env.le(loanKeylet);
599 if (!BEAST_EXPECT(loanSle))
600 return;
601 std::uint32_t const originalNextDueDate = loanSle->at(sfNextPaymentDueDate);
602 BEAST_EXPECT(originalNextDueDate > 0);
603
604 // 1. Impairment must fail when payment is not yet late
605 env(manage(lender, loanKeylet.key, tfLoanImpair), Ter(tecTOO_SOON));
606
607 {
608 auto const loan = env.le(loanKeylet);
609 BEAST_EXPECT(loan->at(sfNextPaymentDueDate) == originalNextDueDate);
610 }
611
612 // 1b. Impairment must still fail at the exact due date instant: a
613 // payment due "now" is not yet late (strict/Exclusive comparison).
614 // Temporarily set NextPaymentDueDate to exactly the current
615 // parentCloseTime (without closing the ledger again), exercise the
616 // check, then restore the original due date.
617 {
618 std::uint32_t const exactNow =
619 env.current()->parentCloseTime().time_since_epoch().count();
620 setLoanNextPaymentDueDate(env, loanKeylet, exactNow);
621
622 env(manage(lender, loanKeylet.key, tfLoanImpair), Ter(tecTOO_SOON));
623
624 setLoanNextPaymentDueDate(env, loanKeylet, originalNextDueDate);
625 }
626
627 {
628 auto const loan = env.le(loanKeylet);
629 BEAST_EXPECT(loan->at(sfNextPaymentDueDate) == originalNextDueDate);
630 }
631
632 env.close(NetClock::time_point{NetClock::duration{originalNextDueDate}} + 1s);
633
634 // 2. Impairment succeeds when payment is late
635 env(manage(lender, loanKeylet.key, tfLoanImpair), Ter(tesSUCCESS));
636
637 {
638 auto const loan = env.le(loanKeylet);
639 if (!BEAST_EXPECT(loan))
640 return;
641 BEAST_EXPECT(loan->isFlag(lsfLoanImpaired));
642 BEAST_EXPECT(loan->at(sfNextPaymentDueDate) == originalNextDueDate);
643 }
644
645 // 3. Unimpair also does not change sfNextPaymentDueDate
646 env(manage(lender, loanKeylet.key, tfLoanUnimpair), Ter(tesSUCCESS));
647
648 {
649 auto const loan = env.le(loanKeylet);
650 if (!BEAST_EXPECT(loan))
651 return;
652 BEAST_EXPECT(!loan->isFlag(lsfLoanImpaired));
653 BEAST_EXPECT(loan->at(sfNextPaymentDueDate) == originalNextDueDate);
654 }
655 }
656
657 // Verify that without fixCleanup3_4_0, the pre-amendment
658 // impair/unimpair behaviour is preserved:
659 // 1. Impairing a loan before its payment is late moves
660 // sfNextPaymentDueDate to "now".
661 // 2a. Unimpair within the original payment interval restores
662 // sfNextPaymentDueDate to StartDate + PaymentInterval.
663 // 2b. Unimpair after the original due date sets
664 // sfNextPaymentDueDate to now + PaymentInterval.
665 void
667 {
668 using namespace jtx;
669 using namespace loan;
670 using namespace std::chrono_literals;
671
672 testcase("Pre-amendment impair/unimpair date restoration");
673
674 Env env(*this, all_ - fixCleanup3_4_0);
675 BEAST_EXPECT(!env.enabled(fixCleanup3_4_0));
676
677 Account const lender{"lender"};
678 Account const borrower{"borrower"};
679
680 env.fund(XRP(100'000'000), lender, borrower);
681 env.close();
682
683 PrettyAsset const xrpAsset{xrpIssue(), 1'000'000};
684 auto const broker = createVaultAndBroker(env, xrpAsset, lender);
685
686 Number const principalRequest{1, 3};
687 auto const createNewLoan = [&] {
688 auto const sleBroker = env.le(keylet::loanBroker(broker.brokerID));
689 if (!BEAST_EXPECT(sleBroker))
690 return keylet::loan(UInt256{});
691 auto const lk =
692 keylet::loan(broker.brokerID, SeqProxy::rawSequence(sleBroker->at(sfLoanSequence)));
693 env(set(borrower, broker.brokerID, broker.asset(principalRequest).value()),
694 Sig(sfCounterpartySignature, lender),
695 kPaymentTotal(12),
696 kPaymentInterval(600),
697 Fee(env.current()->fees().base * 2));
698 env.close();
699 return lk;
700 };
701
702 // Default + delete a loan and replenish first-loss capital so the
703 // broker is ready for the next loan.
704 auto const cleanupLoan = [&](Keylet const& loanKeylet, std::uint32_t dueDate) {
705 env.close(NetClock::time_point{NetClock::duration{dueDate + 60}} + 1s);
706 env(manage(lender, loanKeylet.key, tfLoanDefault), Ter(tesSUCCESS));
707 env.close();
708
709 auto const brokerSle = env.le(keylet::loanBroker(broker.brokerID));
710 if (!BEAST_EXPECT(brokerSle))
711 return;
712 auto const coverNeeded =
713 broker.asset(broker.params.coverDeposit).value() - brokerSle->at(sfCoverAvailable);
714 if (coverNeeded > 0)
715 {
717 lender, broker.brokerID, STAmount{broker.asset, coverNeeded}));
718 env.close();
719 }
720 env(del(lender, loanKeylet.key));
721 env.close();
722 };
723
724 // ---- Case A: impair before late, unimpair within original interval ----
725 {
726 auto const loanKeylet = createNewLoan();
727 auto const loanSle = env.le(loanKeylet);
728 if (!BEAST_EXPECT(loanSle))
729 return;
730 std::uint32_t const startDate = loanSle->at(sfStartDate);
731 std::uint32_t const originalNextDueDate = loanSle->at(sfNextPaymentDueDate);
732 BEAST_EXPECT(originalNextDueDate == startDate + 600);
733
734 // Payment is not late yet - impair succeeds and moves due date
735 // to now (pre-amendment allows immediate impairment)
736 env(manage(lender, loanKeylet.key, tfLoanImpair), Ter(tesSUCCESS));
737
738 {
739 auto const loan = env.le(loanKeylet);
740 if (!BEAST_EXPECT(loan))
741 return;
742 BEAST_EXPECT(loan->isFlag(lsfLoanImpaired));
743 std::uint32_t const movedDueDate = loan->at(sfNextPaymentDueDate);
744 BEAST_EXPECT(movedDueDate != originalNextDueDate);
745 BEAST_EXPECT(movedDueDate < originalNextDueDate);
746 }
747
748 // Unimpair while still within the original payment interval. The
749 // normal due date (startDate + 600) has not yet expired, so it
750 // should be restored.
751 env(manage(lender, loanKeylet.key, tfLoanUnimpair), Ter(tesSUCCESS));
752
753 {
754 auto const loan = env.le(loanKeylet);
755 if (!BEAST_EXPECT(loan))
756 return;
757 BEAST_EXPECT(!loan->isFlag(lsfLoanImpaired));
758 BEAST_EXPECT(loan->at(sfNextPaymentDueDate) == originalNextDueDate);
759 }
760
761 cleanupLoan(loanKeylet, originalNextDueDate);
762 }
763
764 // ---- Case B: impair before late, unimpair after original due date ----
765 {
766 auto const loanKeylet = createNewLoan();
767 auto const loanSle = env.le(loanKeylet);
768 if (!BEAST_EXPECT(loanSle))
769 return;
770 std::uint32_t const startDate = loanSle->at(sfStartDate);
771 std::uint32_t const originalNextDueDate = loanSle->at(sfNextPaymentDueDate);
772 BEAST_EXPECT(originalNextDueDate == startDate + 600);
773
774 env(manage(lender, loanKeylet.key, tfLoanImpair), Ter(tesSUCCESS));
775
776 env.close(NetClock::time_point{NetClock::duration{originalNextDueDate}} + 10s);
777
778 auto const timeBeforeUnimpair =
779 env.current()->header().parentCloseTime.time_since_epoch().count();
780
781 env(manage(lender, loanKeylet.key, tfLoanUnimpair), Ter(tesSUCCESS));
782
783 {
784 auto const loan = env.le(loanKeylet);
785 if (!BEAST_EXPECT(loan))
786 return;
787 BEAST_EXPECT(!loan->isFlag(lsfLoanImpaired));
788 std::uint32_t const newDueDate = loan->at(sfNextPaymentDueDate);
789 BEAST_EXPECT(newDueDate > originalNextDueDate);
790 BEAST_EXPECT(newDueDate == timeBeforeUnimpair + 600);
791 }
792 }
793 }
794
795 // FN-68: a borrower must not be able to bypass late-payment charges by
796 // paying an impaired, overdue loan with a plain LoanPay. Under
797 // fixCleanup3_4_0 impairment no longer moves the due date, so
798 // the payment logic sees the real (overdue) date: a regular payment is
799 // rejected with tecEXPIRED, and only a tfLoanLatePayment (which charges
800 // the late fee + late interest) is accepted.
801 void
803 {
804 using namespace jtx;
805 using namespace loan;
806 using namespace std::chrono_literals;
807
808 testcase("Impaired overdue LoanPay requires late-payment flag");
809
810 Env env(*this, all_ | fixCleanup3_4_0);
811 BEAST_EXPECT(env.enabled(fixCleanup3_4_0));
812
813 Account const lender{"lender"};
814 Account const borrower{"borrower"};
815
816 env.fund(XRP(100'000'000), lender, borrower);
817 env.close();
818
819 PrettyAsset const xrpAsset{xrpIssue(), 1'000'000};
820 auto const broker = createVaultAndBroker(env, xrpAsset, lender);
821
822 auto const sleBroker = env.le(keylet::loanBroker(broker.brokerID));
823 if (!BEAST_EXPECT(sleBroker))
824 return;
825 auto const loanKeylet =
826 keylet::loan(broker.brokerID, SeqProxy::rawSequence(sleBroker->at(sfLoanSequence)));
827
828 // Loan with non-zero late-payment terms, so the late path carries a
829 // real penalty that the exploit would otherwise avoid.
830 Number const principalRequest{1, 3};
831 env(set(borrower, broker.brokerID, broker.asset(principalRequest).value()),
832 Sig(sfCounterpartySignature, lender),
833 kPaymentTotal(12),
834 kPaymentInterval(600),
835 kLatePaymentFee(broker.asset(3).number()),
836 kLateInterestRate(TenthBips32{30322}),
837 Fee(env.current()->fees().base * 2));
838 env.close();
839
840 auto const loanSle = env.le(loanKeylet);
841 if (!BEAST_EXPECT(loanSle))
842 return;
843 std::uint32_t const originalNextDueDate = loanSle->at(sfNextPaymentDueDate);
844 std::uint32_t const paymentsBefore = loanSle->at(sfPaymentRemaining);
845 BEAST_EXPECT(originalNextDueDate > 0);
846
847 // Advance past the due date so the loan is overdue, then impair it
848 // (impairment is only allowed once the payment is late).
849 env.close(NetClock::time_point{NetClock::duration{originalNextDueDate}} + 1s);
850 env(manage(lender, loanKeylet.key, tfLoanImpair), Ter(tesSUCCESS));
851 env.close();
852
853 {
854 auto const loan = env.le(loanKeylet);
855 if (!BEAST_EXPECT(loan))
856 return;
857 BEAST_EXPECT(loan->isFlag(lsfLoanImpaired));
858 BEAST_EXPECT(loan->at(sfNextPaymentDueDate) == originalNextDueDate);
859 }
860
861 auto const payAmount = broker.asset(500).value();
862
863 // The exploit: a plain LoanPay (Flags = 0) on an impaired, overdue
864 // loan must be rejected. Before FN-9 the auto-unimpair pushed the due
865 // date into the future and this returned tesSUCCESS, letting the
866 // borrower skip the late fee and late interest.
867 env(pay(borrower, loanKeylet.key, payAmount), Ter(tecEXPIRED));
868 env.close();
869
870 {
871 auto const loan = env.le(loanKeylet);
872 if (!BEAST_EXPECT(loan))
873 return;
874 BEAST_EXPECT(loan->isFlag(lsfLoanImpaired));
875 BEAST_EXPECT(loan->at(sfPaymentRemaining) == paymentsBefore);
876 BEAST_EXPECT(loan->at(sfNextPaymentDueDate) == originalNextDueDate);
877 }
878
879 env(pay(borrower, loanKeylet.key, payAmount, tfLoanLatePayment), Ter(tesSUCCESS));
880 env.close();
881 {
882 auto const loan = env.le(loanKeylet);
883 if (!BEAST_EXPECT(loan))
884 return;
885 BEAST_EXPECT(!loan->isFlag(lsfLoanImpaired));
886 BEAST_EXPECT(loan->at(sfPaymentRemaining) == paymentsBefore - 1);
887 }
888
889 {
890 auto const vaultSle = env.le(broker.vaultKeylet());
891 if (!BEAST_EXPECT(vaultSle))
892 return;
893 BEAST_EXPECT(vaultSle->at(sfLossUnrealized) == 0);
894 }
895 }
896
897 // FN-68 (pre-amendment): documents the original vulnerability. Without
898 // fixCleanup3_4_0, impairing moves the due date and LoanPay
899 // auto-unimpair pushes it into the future before the late check, so a
900 // plain (Flags = 0) LoanPay on an impaired, overdue loan is accepted as
901 // on-time (tesSUCCESS) and the borrower dodges the late-payment charges.
902 // This is what testImpairedOverdueLoanPayRequiresLateFlag closes once the
903 // amendment is enabled.
904 void
906 {
907 using namespace jtx;
908 using namespace loan;
909 using namespace std::chrono_literals;
910
911 testcase("Impaired overdue LoanPay bypass (pre-amendment)");
912
913 Env env(*this, all_ - fixCleanup3_4_0);
914 BEAST_EXPECT(!env.enabled(fixCleanup3_4_0));
915
916 Account const lender{"lender"};
917 Account const borrower{"borrower"};
918
919 env.fund(XRP(100'000'000), lender, borrower);
920 env.close();
921
922 PrettyAsset const xrpAsset{xrpIssue(), 1'000'000};
923 auto const broker = createVaultAndBroker(env, xrpAsset, lender);
924
925 auto const sleBroker = env.le(keylet::loanBroker(broker.brokerID));
926 if (!BEAST_EXPECT(sleBroker))
927 return;
928 auto const loanKeylet =
929 keylet::loan(broker.brokerID, SeqProxy::rawSequence(sleBroker->at(sfLoanSequence)));
930
931 Number const principalRequest{1, 3};
932 env(set(borrower, broker.brokerID, broker.asset(principalRequest).value()),
933 Sig(sfCounterpartySignature, lender),
934 kPaymentTotal(12),
935 kPaymentInterval(600),
936 kLatePaymentFee(broker.asset(3).number()),
937 kLateInterestRate(TenthBips32{30322}),
938 Fee(env.current()->fees().base * 2));
939 env.close();
940
941 auto const loanSle = env.le(loanKeylet);
942 if (!BEAST_EXPECT(loanSle))
943 return;
944 std::uint32_t const originalNextDueDate = loanSle->at(sfNextPaymentDueDate);
945 BEAST_EXPECT(originalNextDueDate > 0);
946
947 env(manage(lender, loanKeylet.key, tfLoanImpair), Ter(tesSUCCESS));
948 env.close();
949
950 env.close(NetClock::time_point{NetClock::duration{originalNextDueDate}} + 1s);
951
952 {
953 auto const loan = env.le(loanKeylet);
954 if (!BEAST_EXPECT(loan))
955 return;
956 BEAST_EXPECT(loan->isFlag(lsfLoanImpaired));
957 }
958
959 auto const payAmount = broker.asset(500).value();
960
961 // The bug: a plain LoanPay is accepted as on-time and clears the
962 // loan's impaired flag, so the late fee / late interest are never
963 // charged.
964 env(pay(borrower, loanKeylet.key, payAmount), Ter(tesSUCCESS));
965 env.close();
966 {
967 auto const loan = env.le(loanKeylet);
968 if (!BEAST_EXPECT(loan))
969 return;
970 BEAST_EXPECT(!loan->isFlag(lsfLoanImpaired));
971 }
972 }
973
974 // Default uses NextPaymentDueDate + GracePeriod. Once fixCleanup3_4_0
975 // is enabled, that gate is Exclusive, matching impair/isPaymentLate:
976 // default is allowed only after grace has passed, not at the instant
977 // it expires.
978 void
980 {
981 testcase("LoanManage default at exact grace expiry rejected with fixCleanup3_4_0");
982
983 using namespace jtx;
984 using namespace loan;
985 using namespace std::chrono_literals;
986
987 Env env(*this, all_);
988 BEAST_EXPECT(env.enabled(fixCleanup3_4_0));
989
990 Account const lender{"lender"};
991 Account const borrower{"borrower"};
992
993 env.fund(XRP(100'000'000), lender, borrower);
994 env.close();
995
996 PrettyAsset const xrpAsset{xrpIssue(), 1'000'000};
997 auto const broker = createVaultAndBroker(env, xrpAsset, lender);
998
999 auto const sleBroker = env.le(keylet::loanBroker(broker.brokerID));
1000 if (!BEAST_EXPECT(sleBroker))
1001 return;
1002 auto const loanKeylet =
1003 keylet::loan(broker.brokerID, SeqProxy::rawSequence(sleBroker->at(sfLoanSequence)));
1004
1005 env(set(borrower, broker.brokerID, broker.asset(Number{1, 3}).value()),
1006 Sig(sfCounterpartySignature, lender),
1007 kPaymentTotal(12),
1008 kPaymentInterval(600),
1009 kGracePeriod(60),
1010 Fee(env.current()->fees().base * 2));
1011 env.close();
1012
1013 // Advance far enough that parentCloseTime > GracePeriod, so
1014 // (now - grace) cannot underflow when pinning the exact expiry.
1015 env.close(env.now() + 1000s);
1016
1017 auto const loanSle = env.le(loanKeylet);
1018 if (!BEAST_EXPECT(loanSle))
1019 return;
1020 auto const grace = loanSle->at(sfGracePeriod);
1021 std::uint32_t const now = env.current()->parentCloseTime().time_since_epoch().count();
1022 BEAST_EXPECT(now > grace + 1);
1023
1024 // parentCloseTime == NextPaymentDueDate + GracePeriod: grace expires
1025 // this instant, so default must still be too soon.
1026 setLoanNextPaymentDueDate(env, loanKeylet, now - grace);
1027 env(manage(lender, loanKeylet.key, tfLoanDefault), Ter(tecTOO_SOON));
1028 {
1029 auto const loan = env.le(loanKeylet);
1030 if (!BEAST_EXPECT(loan))
1031 return;
1032 BEAST_EXPECT(!loan->isFlag(lsfLoanDefault));
1033 }
1034
1035 // One second after grace expires, default succeeds.
1036 setLoanNextPaymentDueDate(env, loanKeylet, now - grace - 1);
1037 env(manage(lender, loanKeylet.key, tfLoanDefault), Ter(tesSUCCESS));
1038 {
1039 auto const loan = env.le(loanKeylet);
1040 if (!BEAST_EXPECT(loan))
1041 return;
1042 BEAST_EXPECT(loan->isFlag(lsfLoanDefault));
1043 }
1044 }
1045
1046 void
1048 {
1049 testcase("LoanManage default at exact grace expiry succeeds without fixCleanup3_4_0");
1050
1051 using namespace jtx;
1052 using namespace loan;
1053 using namespace std::chrono_literals;
1054
1055 Env env(*this, all_ - fixCleanup3_4_0);
1056 BEAST_EXPECT(!env.enabled(fixCleanup3_4_0));
1057
1058 Account const lender{"lender"};
1059 Account const borrower{"borrower"};
1060
1061 env.fund(XRP(100'000'000), lender, borrower);
1062 env.close();
1063
1064 PrettyAsset const xrpAsset{xrpIssue(), 1'000'000};
1065 auto const broker = createVaultAndBroker(env, xrpAsset, lender);
1066
1067 auto const sleBroker = env.le(keylet::loanBroker(broker.brokerID));
1068 if (!BEAST_EXPECT(sleBroker))
1069 return;
1070 auto const loanKeylet =
1071 keylet::loan(broker.brokerID, SeqProxy::rawSequence(sleBroker->at(sfLoanSequence)));
1072
1073 env(set(borrower, broker.brokerID, broker.asset(Number{1, 3}).value()),
1074 Sig(sfCounterpartySignature, lender),
1075 kPaymentTotal(12),
1076 kPaymentInterval(600),
1077 kGracePeriod(60),
1078 Fee(env.current()->fees().base * 2));
1079 env.close();
1080
1081 env.close(env.now() + 1000s);
1082
1083 auto const loanSle = env.le(loanKeylet);
1084 if (!BEAST_EXPECT(loanSle))
1085 return;
1086 auto const grace = loanSle->at(sfGracePeriod);
1087 std::uint32_t const now = env.current()->parentCloseTime().time_since_epoch().count();
1088 BEAST_EXPECT(now > grace);
1089
1090 setLoanNextPaymentDueDate(env, loanKeylet, now - grace);
1091 env(manage(lender, loanKeylet.key, tfLoanDefault), Ter(tesSUCCESS));
1092 {
1093 auto const loan = env.le(loanKeylet);
1094 if (!BEAST_EXPECT(loan))
1095 return;
1096 BEAST_EXPECT(loan->isFlag(lsfLoanDefault));
1097 }
1098 }
1099
1100 // Every signature on a transaction covered the same bytes before
1101 // fixCleanup3_4_0, so a signature could be moved from the role that made
1102 // it into another role. Here the lender signs a LoanSet as the
1103 // counterparty, and the borrower copies that signature into the
1104 // SponsorSignature, making the lender pay the fee without the lender ever
1105 // agreeing to sponsor it.
1106 void
1108 {
1109 testcase(
1110 std::string("Counterparty signature copied into the sponsor slot") +
1111 (fixEnabled ? "" : " (pre-amendment)"));
1112
1113 using namespace jtx;
1114 using namespace loan;
1115
1116 Env env(*this, fixEnabled ? all_ : all_ - fixCleanup3_4_0);
1117 BEAST_EXPECT(env.enabled(fixCleanup3_4_0) == fixEnabled);
1118
1119 Account const lender{"lender"};
1120 Account const borrower{"borrower"};
1121
1122 env.fund(XRP(100'000'000), lender, borrower);
1123 env.close();
1124
1125 PrettyAsset const xrpAsset{xrpIssue(), 1'000'000};
1126 auto const broker = createVaultAndBroker(env, xrpAsset, lender);
1127
1128 auto const feeAmt = XRP(1);
1129
1130 // The lender agrees to the loan by signing the Counterparty slot of a
1131 // LoanSet that names the lender as the fee sponsor. The lender signs
1132 // nothing else.
1133 auto loanSet = env.json(
1134 set(borrower, broker.brokerID, broker.asset(Number{1, 3}).value()),
1135 sponsor::As(lender, spfSponsorFee),
1136 Sig(sfCounterpartySignature, lender),
1137 Fee(feeAmt));
1138
1139 // The borrower copies the lender's signature into the sponsor slot.
1140 loanSet[sfSponsorSignature.jsonName] = loanSet[sfCounterpartySignature.jsonName];
1141
1142 auto const lenderBalance = env.balance(lender);
1143 auto const borrowerBalance = env.balance(borrower);
1144
1145 env(loanSet, Ter(fixEnabled ? TER{telENV_RPC_FAILED} : TER{tesSUCCESS}));
1146 env.close();
1147
1148 if (fixEnabled)
1149 {
1150 // The copied signature does not verify in the sponsor slot, so
1151 // nothing happens at all.
1152 BEAST_EXPECT(env.balance(lender) == lenderBalance);
1153 BEAST_EXPECT(env.balance(borrower) == borrowerBalance);
1154 }
1155 else
1156 {
1157 // The lender paid the fee, and the borrower got the loan.
1158 BEAST_EXPECT(env.balance(lender) == lenderBalance - feeAmt);
1159 BEAST_EXPECT(env.balance(borrower).value() > borrowerBalance.value());
1160 }
1161 }
1162
1163 void
1176
1177 // Tests run under each entry in amendmentCombinations().
1178 void
1180 {
1182 testRIPD3831(features);
1183 testRIPD3459(features);
1184 testRIPD3902(features);
1185 }
1186
1187public:
1188 void
1189 run() override
1190 {
1192 for (auto const& features : jtx::amendmentCombinations(
1193 {fixCleanup3_1_3, fixCleanup3_2_0, featureMPTokensV2}, all_))
1194 runAmendmentSensitive(features);
1195 }
1196};
1197
1198BEAST_DEFINE_TESTSUITE(LoanSecurity, tx, xrpl);
1199
1200} // namespace xrpl::test
A generic endpoint for log messages.
Definition Journal.h:44
LogOs< char > log
Logging output stream.
Definition suite.h:150
TestcaseT testcase
Memberspace for declaring test cases.
Definition suite.h:155
std::chrono::time_point< NetClock > time_point
Definition chrono.h:48
std::chrono::duration< rep, period > duration
Definition chrono.h:47
Number is a floating point type that can represent a wide range of values.
Definition Number.h:351
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
json::Value getJson(JsonOptions=JsonOptions::Values::None) const override
STAmount const & value() const noexcept
Definition STAmount.h:610
static constexpr SeqProxy rawSequence(std::uint32_t v)
Factory function to return a sequence-based SeqProxy.
Definition SeqProxy.h:62
virtual OpenLedger & getOpenLedger()=0
void testRIPD3902(FeatureBitset features)
void runAmendmentSensitive(FeatureBitset features)
void setLoanNextPaymentDueDate(jtx::Env &env, Keylet const &loanKeylet, std::uint32_t dueDate)
void testSignatureCopiedBetweenRoles(bool fixEnabled)
void testRIPD3459(FeatureBitset features)
void run() override
Runs the suite.
void testPoCUnsignedUnderflowOnFullPayAfterEarlyPeriodic(FeatureBitset features)
void testRIPD3831(FeatureBitset features)
Shared base for the Loan*_test family under src/test/app/lending/.
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.
void makeLoanPayments(jtx::Env &env, BrokerInfo const &broker, LoanParameters const &loanParams, Keylet const &loanKeylet, VerifyLoanStatus const &verifyLoanStatus, jtx::Account const &issuer, jtx::Account const &lender, jtx::Account const &borrower, PaymentParameters const &paymentParams=PaymentParameters::defaults())
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 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
std::string const & name() const
Return the name.
Definition jtx/Account.h:75
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
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
std::uint32_t seq(Account const &account) const
Returns the next sequence number on account.
Definition Env.cpp:302
json::Value rpc(unsigned apiVersion, std::unordered_map< std::string, std::string > const &headers, std::string const &cmd, Args &&... args)
Execute an RPC command.
Definition Env.h:1058
JTx jt(JsonValue &&jv, FN const &... fN)
Create a JTx from parameters.
Definition Env.h:723
PrettyAmount balance(Account const &account) const
Returns the XRP balance on an account.
Definition Env.cpp:201
beast::unit_test::Suite & test
Definition Env.h:163
std::shared_ptr< OpenView const > current() const
Returns the current ledger.
Definition Env.h:377
NetClock::time_point now()
Returns the current network time.
Definition Env.h:326
Set the fee on a JTx.
Definition fee.h:20
Set the regular signature on a JTx.
Definition sig.h:19
Set the expected result code for a JTx The test will fail if the code doesn't match.
Definition ter.h:18
Set the flags on a JTx.
Definition txflags.h:14
T endl(T... args)
T make_shared(T... args)
T max(T... args)
T min(T... args)
constexpr Zero kZero
Definition Zero.h:30
Number loanPrincipalFromPeriodicPayment(Rules const &rules, Number const &periodicPayment, Number const &periodicRate, std::uint32_t paymentsRemaining)
PaymentComponents computePaymentComponents(Rules const &rules, Asset const &asset, std::int32_t scale, Number const &totalValueOutstanding, Number const &principalOutstanding, Number const &managementFeeOutstanding, Number const &periodicPayment, Number const &periodicRate, std::uint32_t paymentRemaining, TenthBips16 managementFeeRate)
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 loan(UInt256 const &loanBrokerID, SeqProxy const &loanSeq) noexcept
Definition Indexes.cpp:577
json::Value set(AccountID const &account, UInt256 const &vaultId, uint32_t flags)
json::Value coverDeposit(AccountID const &account, UInt256 const &brokerID, STAmount const &amount, uint32_t flags)
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
XRPAmount txFee(Env const &env, std::uint16_t n)
PrettyAmount drops(Integer i)
Returns an XRP PrettyAmount, which is trivially convertible to STAmount.
BEAST_DEFINE_TESTSUITE(AMMClawback, app, xrpl)
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
constexpr FlagValue spfSponsorFee
Definition TxFlags.h:467
@ telENV_RPC_FAILED
Definition TER.h:54
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
TenthBips< std::uint32_t > TenthBips32
Definition Units.h:454
TenthBips< std::uint16_t > TenthBips16
Definition Units.h:453
std::string to_string(BaseUInt< Bits, Tag > const &a)
Definition base_uint.h:658
BaseUInt< 256 > UInt256
Definition base_uint.h:581
bool after(NetClock::time_point now, std::uint32_t mark)
Has the specified time passed?
Definition View.cpp:668
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
Number computeManagementFee(Asset const &asset, Number const &interest, TenthBips32 managementFeeRate, std::int32_t scale)
TERSubset< CanCvtToTER > TER
Definition TER.h:657
@ tecTOO_SOON
Definition TER.h:329
@ tecEXPIRED
Definition TER.h:325
@ 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)
A pair of SHAMap key and LedgerEntryType.
Definition Keylet.h:20
UInt256 key
Definition Keylet.h:21
Helper class to compare the expected state of a loan and loan broker against the data in the ledger.
STAmount const & value() const