xrpld
Loading...
Searching...
No Matches
LoanInvariants_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/mpt.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/beast/unit_test/suite.h>
16#include <xrpl/json/json_value.h>
17#include <xrpl/ledger/helpers/LendingHelpers.h>
18#include <xrpl/ledger/helpers/VaultHelpers.h>
19#include <xrpl/protocol/Asset.h>
20#include <xrpl/protocol/Feature.h>
21#include <xrpl/protocol/Indexes.h>
22#include <xrpl/protocol/Issue.h>
23#include <xrpl/protocol/Protocol.h>
24#include <xrpl/protocol/SField.h>
25#include <xrpl/protocol/STAmount.h>
26#include <xrpl/protocol/SeqProxy.h>
27#include <xrpl/protocol/TER.h>
28#include <xrpl/protocol/TxFlags.h>
29#include <xrpl/protocol/Units.h>
30
31#include <algorithm>
32#include <cstdint>
33#include <optional>
34
35namespace xrpl::test {
36
38{
39private:
40 // Each of these regression tests reproduces a single fuzzer-found (FIND-*)
41 // scenario against xrpl::detail::computePeriodicPayment /
42 // loanComputePaymentParts. They're merged into one function, one block
43 // per finding, because each is a narrow, self-contained repro that
44 // shares little beyond the surrounding scaffold.
45 void
47 {
48 using namespace jtx;
49 using namespace std::chrono_literals;
50 using namespace lending;
51
52 // From FIND-012
53 {
54 testcase << "LoanPay xrpl::detail::computePeriodicPayment : "
55 "valid rate";
56
57 Env env(*this, features);
58
59 Account const issuer{"issuer"};
60 Account const lender{"lender"};
61 Account const borrower{"borrower"};
62
63 BrokerParameters const brokerParams;
64 env.fund(XRP(brokerParams.vaultDeposit * 100), issuer, lender, borrower);
65 env.close();
66
67 PrettyAsset const xrpAsset{xrpIssue(), 1'000'000};
68 BrokerInfo const broker{createVaultAndBroker(env, xrpAsset, lender, brokerParams)};
69
70 using namespace loan;
71
72 auto const loanSetFee = Fee(env.current()->fees().base * 2);
73 Number const principalRequest{640562, -5};
74
75 Number const serviceFee{2462611968};
76 std::uint32_t const numPayments{4294967295 / 800};
77
78 auto createJson = env.json(
79 set(borrower, broker.brokerID, principalRequest),
80 Fee(loanSetFee),
81 kLoanServiceFee(serviceFee),
82 kPaymentTotal(numPayments),
83 Json(sfCounterpartySignature, json::ValueType::Object));
84
85 createJson["CloseInterestRate"] = 55374;
86 createJson["ClosePaymentFee"] = "3825205248";
87 createJson["LatePaymentFee"] = "237";
88 createJson["LoanOriginationFee"] = "0";
89 createJson["OverpaymentFee"] = 35167;
90 createJson["OverpaymentInterestRate"] = 1360;
91 createJson["PaymentInterval"] = 727;
92
93 auto const keylet = nextLoanKeylet(env, broker);
94
95 createJson = env.json(createJson, Sig(sfCounterpartySignature, lender));
96 // Fails in preclaim because principal requested can't be
97 // represented as XRP
98 env(createJson, Ter(tecPRECISION_LOSS));
99 env.close();
100
101 BEAST_EXPECT(!env.le(keylet));
102
103 Number const actualPrincipal{6};
104
105 createJson[sfPrincipalRequested] = actualPrincipal;
106 createJson.removeMember(sfSequence.jsonName);
107 createJson = env.json(createJson, Sig(sfCounterpartySignature, lender));
108 // Fails in doApply because the payment is too small to be
109 // represented as XRP.
110 env(createJson, Ter(tecPRECISION_LOSS));
111 env.close();
112 }
113
114 // From FIND-010
115 {
116 testcase << "xrpl::loanComputePaymentParts : valid total interest";
117
118 Env env(*this, features);
119
120 Account const issuer{"issuer"};
121 Account const lender{"lender"};
122 Account const borrower{"borrower"};
123
124 PrettyAsset const iouAsset = createFundedIouAsset(env, issuer, lender, borrower);
125
126 BrokerInfo const broker{createVaultAndBroker(env, iouAsset, lender)};
127
128 using namespace loan;
129
130 auto const loanSetFee = Fee(env.current()->fees().base * 2);
131 Number const principalRequest{1, 3};
132
133 auto createJson = env.json(
134 set(borrower, broker.brokerID, principalRequest),
135 Fee(loanSetFee),
136 Json(sfCounterpartySignature, json::ValueType::Object));
137
138 createJson["CloseInterestRate"] = 47299;
139 createJson["ClosePaymentFee"] = "3985819770";
140 createJson["InterestRate"] = 92;
141 createJson["LatePaymentFee"] = "3866894865";
142 createJson["LoanOriginationFee"] = "0";
143 createJson["LoanServiceFee"] = "2348810240";
144 createJson["OverpaymentFee"] = 58545;
145 createJson["PaymentInterval"] = 60;
146 createJson["PaymentTotal"] = 1;
147 createJson["PrincipalRequested"] = "0.000763058";
148
149 auto const keylet = nextLoanKeylet(env, broker);
150
151 createJson = env.json(createJson, Sig(sfCounterpartySignature, lender));
152 env(createJson);
153 env.close();
154
155 auto loanPayTx = env.json(pay(borrower, keylet.key, STAmount{broker.asset, Number{}}));
156 loanPayTx["Amount"]["value"] = "0.000281284125490196";
157 env(loanPayTx, Ter(tecINSUFFICIENT_PAYMENT));
158 env.close();
159 }
160
161 // From FIND-009
162 {
163 testcase << "xrpl::loanComputePaymentParts : totalPrincipalPaid "
164 "rounded";
165
166 Env env(*this, features);
167
168 Account const issuer{"issuer"};
169 Account const lender{"lender"};
170 Account const borrower{"borrower"};
171
172 PrettyAsset const iouAsset = createFundedIouAsset(env, issuer, lender, borrower);
173
174 BrokerInfo const broker{createVaultAndBroker(env, iouAsset, lender)};
175
176 using namespace loan;
177
178 auto const loanSetFee = Fee(env.current()->fees().base * 2);
179 Number const principalRequest{1, 3};
180
181 auto createJson = env.json(
182 set(borrower, broker.brokerID, principalRequest),
183 Fee(loanSetFee),
184 Json(sfCounterpartySignature, json::ValueType::Object));
185
186 createJson["ClosePaymentFee"] = "0";
187 createJson["InterestRate"] = 24346;
188 createJson["LateInterestRate"] = 65535;
189 createJson["LatePaymentFee"] = "0";
190 createJson["LoanOriginationFee"] = "218";
191 createJson["LoanServiceFee"] = "0";
192 createJson["PaymentInterval"] = 60;
193 createJson["PaymentTotal"] = 5678;
194 createJson["PrincipalRequested"] = "9924.81";
195
196 auto const keylet = nextLoanKeylet(env, broker);
197
198 createJson = env.json(createJson, Sig(sfCounterpartySignature, lender));
199 env(createJson, Ter(tesSUCCESS));
200 env.close();
201
202 auto const baseFee = env.current()->fees().base;
203
204 auto const stateBefore = getCurrentState(env, broker, keylet);
205
206 {
207 auto loanPayTx =
208 env.json(pay(borrower, keylet.key, STAmount{broker.asset, Number{}}));
209 Number const amount{3074'745'058'823'529, -12};
210 BEAST_EXPECT(to_string(amount) == "3074.745058823529");
211 XRPAmount const payFee{
212 baseFee *
213 (amount / stateBefore.periodicPayment / kLoanPaymentsPerFeeIncrement + 1)};
214 loanPayTx["Amount"]["value"] = to_string(amount);
215 env(loanPayTx, Fee(payFee), Ter(tesSUCCESS));
216 env.close();
217 }
218
219 {
220 auto loanPayTx =
221 env.json(pay(borrower, keylet.key, STAmount{broker.asset, Number{}}));
222 Number const amount{6732'118'170'944'051, -12};
223 BEAST_EXPECT(to_string(amount) == "6732.118170944051");
224 XRPAmount const payFee{
225 baseFee *
226 (amount / stateBefore.periodicPayment / kLoanPaymentsPerFeeIncrement + 1)};
227 loanPayTx["Amount"]["value"] = to_string(amount);
228 env(loanPayTx, Fee(payFee), Ter(tesSUCCESS));
229 env.close();
230 }
231
232 auto const stateAfter = getCurrentState(env, broker, keylet);
233 // Total interest outstanding is non-negative
234 BEAST_EXPECT(stateAfter.totalValue >= stateAfter.principalOutstanding);
235 // Principal paid is non-negative
236 BEAST_EXPECT(stateBefore.principalOutstanding >= stateAfter.principalOutstanding);
237 // Total value change is non-negative
238 BEAST_EXPECT(stateBefore.totalValue >= stateAfter.totalValue);
239 // Value delta is larger or same as principal delta (meaning
240 // non-negative interest paid)
241 BEAST_EXPECT(
242 (stateBefore.totalValue - stateAfter.totalValue) >=
243 (stateBefore.principalOutstanding - stateAfter.principalOutstanding));
244 }
245
246 // From FIND-008
247 {
248 testcase << "xrpl::loanComputePaymentParts : loanValueChange rounded";
249
250 Env env(*this, features);
251
252 Account const issuer{"issuer"};
253 Account const lender{"lender"};
254 Account const borrower{"borrower"};
255
256 PrettyAsset const iouAsset =
257 createFundedIouAsset(env, issuer, lender, borrower, 100'000'000, 10'000'000);
258
259 BrokerInfo const broker{createVaultAndBroker(env, iouAsset, lender)};
260 {
261 auto const coverDepositValue =
262 broker.asset(broker.params.coverDeposit * 10).value();
263 env(loan_broker::coverDeposit(lender, broker.brokerID, coverDepositValue));
264 env.close();
265 }
266
267 using namespace loan;
268
269 auto const loanSetFee = Fee(env.current()->fees().base * 2);
270 Number const principalRequest{1, 3};
271
272 auto createJson = env.json(
273 set(borrower, broker.brokerID, principalRequest),
274 Fee(loanSetFee),
275 Json(sfCounterpartySignature, json::ValueType::Object));
276
277 createJson["ClosePaymentFee"] = "0";
278 createJson["InterestRate"] = 12833;
279 createJson["LateInterestRate"] = 77048;
280 createJson["LatePaymentFee"] = "0";
281 createJson["LoanOriginationFee"] = "218";
282 createJson["LoanServiceFee"] = "0";
283 createJson["PaymentInterval"] = 752;
284 createJson["PaymentTotal"] = 5678;
285 createJson["PrincipalRequested"] = "9924.81";
286
287 auto const keylet = nextLoanKeylet(env, broker);
288
289 createJson = env.json(createJson, Sig(sfCounterpartySignature, lender));
290 env(createJson, Ter(tesSUCCESS));
291 env.close();
292
293 auto const baseFee = env.current()->fees().base;
294
295 auto const stateBefore = getCurrentState(env, broker, keylet);
296 BEAST_EXPECT(stateBefore.paymentRemaining == 5678);
297 BEAST_EXPECT(stateBefore.paymentRemaining > kLoanMaximumPaymentsPerTransaction);
298
299 auto loanPayTx = env.json(pay(borrower, keylet.key, STAmount{broker.asset, Number{}}));
300 Number const amount{9924'81, -2};
301 BEAST_EXPECT(to_string(amount) == "9924.81");
302 XRPAmount const payFee{
303 baseFee *
304 (amount / stateBefore.periodicPayment / kLoanPaymentsPerFeeIncrement + 1)};
305 loanPayTx["Amount"]["value"] = to_string(amount);
306 env(loanPayTx, Fee(payFee), Ter(tesSUCCESS));
307 env.close();
308
309 auto const stateAfter = getCurrentState(env, broker, keylet);
310 BEAST_EXPECT(
311 stateAfter.paymentRemaining ==
312 stateBefore.paymentRemaining - kLoanMaximumPaymentsPerTransaction);
313 }
314 }
315
316 void
318 {
319 // From FIND-007
320 testcase << "LoanPay xrpl::LoanPay::doApply : debtDecrease "
321 "rounding good";
322
323 using namespace jtx;
324 using namespace std::chrono_literals;
325 using namespace lending;
326 Env env(*this, features);
327
328 Account const issuer{"issuer"};
329 Account const lender{"lender"};
330 Account const borrower{"borrower"};
331
332 PrettyAsset const iouAsset = createFundedIouAsset(env, issuer, lender, borrower);
333
334 BrokerInfo const broker{createVaultAndBroker(env, iouAsset, lender)};
335
336 using namespace loan;
337
338 auto const baseFee = env.current()->fees().base;
339 auto const loanSetFee = Fee(baseFee * 2);
340 Number const principalRequest{1, 3};
341
342 auto createJson = env.json(
343 set(borrower, broker.brokerID, principalRequest),
344 Fee(loanSetFee),
345 Json(sfCounterpartySignature, json::ValueType::Object));
346
347 createJson["ClosePaymentFee"] = "0";
348 createJson["GracePeriod"] = 60;
349 createJson["InterestRate"] = 24346;
350 createJson["LateInterestRate"] = 65535;
351 createJson["LatePaymentFee"] = "0";
352 createJson["LoanOriginationFee"] = "218";
353 createJson["LoanServiceFee"] = "0";
354 createJson["PaymentInterval"] = 60;
355 createJson["PaymentTotal"] = 5678;
356 createJson["PrincipalRequested"] = "9924.81";
357
358 auto const keylet = nextLoanKeylet(env, broker);
359
360 createJson = env.json(createJson, Sig(sfCounterpartySignature, lender));
361 env(createJson, Ter(tesSUCCESS));
362 env.close();
363
364 auto const pseudoAcct = brokerPseudoAccount(env, broker, lender);
365
366 VerifyLoanStatus const verifyLoanStatus(env, broker, pseudoAcct, keylet);
367 auto const originalState = getCurrentState(env, broker, keylet);
368 verifyLoanStatus(originalState);
369
370 Number const payment{3'269'349'176'470'588, -12};
371 XRPAmount const payFee{
372 baseFee *
373 ((payment / originalState.periodicPayment) / kLoanPaymentsPerFeeIncrement + 1)};
374 auto const loanPayTx =
375 env.json(pay(borrower, keylet.key, STAmount{broker.asset, payment}), Fee(payFee));
376 BEAST_EXPECT(to_string(payment) == "3269.349176470588");
377 env(loanPayTx, Ter(tesSUCCESS));
378 env.close();
379
380 auto const newState = getCurrentState(env, broker, keylet);
381 BEAST_EXPECT(
382 isRounded(broker.asset, newState.managementFeeOutstanding, originalState.loanScale));
383 BEAST_EXPECT(newState.managementFeeOutstanding < originalState.managementFeeOutstanding);
384 BEAST_EXPECT(isRounded(broker.asset, newState.totalValue, originalState.loanScale));
385 BEAST_EXPECT(
386 isRounded(broker.asset, newState.principalOutstanding, originalState.loanScale));
387 }
388
389 // Verify an overpayment cannot reduce principal without covering and
390 // advancing at least one scheduled instalment: reject an extra-only amount,
391 // but accept an instalment plus extra. Enable V1_1 explicitly because
392 // LoanTestBase::all_ excludes it.
393 void
395 {
396 testcase("LoanPay overpayment schedule advancement");
397
398 using namespace jtx;
399 using namespace loan;
400
401 Env env{*this, features | featureLendingProtocolV1_1};
402
403 Account const lender{"lender"};
404 Account const borrower{"borrower"};
405
406 env.fund(XRP(10'000'000), lender, borrower);
407 env.close();
408
409 PrettyAsset const asset{xrpIssue(), 1000};
410
411 BrokerInfo const broker = createVaultAndBroker(
412 env,
413 asset,
414 lender,
415 {
416 .vaultDeposit = asset(100'000).value(),
417 .managementFeeRate = TenthBips16(10'000),
418 });
419
420 auto const loanSetFee = Fee(env.current()->fees().base * 2);
421
422 // Principal 10,000 over 3 payments, overpayment enabled. One scheduled
423 // payment is ~3,333, so an amount well below that cannot cover one.
424 auto const loanKeylet = nextLoanKeylet(env, broker);
425 env(loan::set(borrower, broker.brokerID, asset(10'000).value(), tfLoanOverpayment),
426 Sig(sfCounterpartySignature, lender),
427 loan::kPaymentInterval(86400 * 30),
430 loanSetFee);
431 env.close();
432
433 auto const before = getCurrentState(env, broker, loanKeylet);
434 BEAST_EXPECT(before.paymentRemaining == 3);
435
436 STAmount const belowOnePayment = asset(1'000).value();
437 BEAST_EXPECT((belowOnePayment < STAmount{asset, before.periodicPayment}));
438
439 auto const payFee = Fee(env.current()->fees().base * 2);
440
441 // The amount does not cover a scheduled payment, so makeRegularPayment makes zero scheduled
442 // payments and returns tecINSUFFICIENT_PAYMENT before the Extra branch runs. Were the
443 // payment to succeed while touching only principal, PaymentRemaining and NextPaymentDueDate
444 // would silently fail to advance.
445 env(pay(borrower, loanKeylet.key, belowOnePayment, tfLoanOverpayment),
446 payFee,
448 env.close();
449
450 auto const afterReject = getCurrentState(env, broker, loanKeylet);
451 BEAST_EXPECT(afterReject.paymentRemaining == before.paymentRemaining);
452 BEAST_EXPECT(afterReject.principalOutstanding == before.principalOutstanding);
453 BEAST_EXPECT(afterReject.nextPaymentDate == before.nextPaymentDate);
454
455 // PaymentRemaining drops by one, NextPaymentDueDate advances by one interval, and
456 // PrincipalOutstanding strictly decreases (by more than a plain payment thanks to the
457 // extra).
458 STAmount const onePaymentPlusExtra = asset(5'000).value();
459 env(pay(borrower, loanKeylet.key, onePaymentPlusExtra, tfLoanOverpayment), payFee);
460 env.close();
461
462 auto const afterPay = getCurrentState(env, broker, loanKeylet);
463 BEAST_EXPECT(afterPay.paymentRemaining == before.paymentRemaining - 1);
464 BEAST_EXPECT(afterPay.principalOutstanding < before.principalOutstanding);
465 BEAST_EXPECT(afterPay.nextPaymentDate == before.nextPaymentDate + before.paymentInterval);
466 }
467
468 void
470 {
471 // (From FIND-006)
472 testcase << "LoanSet trigger xrpl::accountSendMPT : minimum amount "
473 "and MPT";
474
475 using namespace jtx;
476 using namespace std::chrono_literals;
477 Env env(*this, features);
478
479 Account const issuer{"issuer"};
480 Account const lender{"lender"};
481 Account const borrower{"borrower"};
482
483 env.fund(XRP(1'000'000), issuer, lender, borrower);
484 env.close();
485
486 MPTTester mptt{env, issuer, kMptInitNoFund};
487 mptt.create({.flags = tfMPTCanClawback | tfMPTCanTransfer | tfMPTCanLock});
488 PrettyAsset const mptAsset = mptt.issuanceID();
489 mptt.authorize({.account = lender});
490 mptt.authorize({.account = borrower});
491 env(pay(issuer, lender, mptAsset(2'000'000)));
492 env(pay(issuer, borrower, mptAsset(1'000)));
493 env.close();
494
495 BrokerInfo const broker{createVaultAndBroker(env, mptAsset, lender)};
496
497 using namespace loan;
498
499 auto const loanSetFee = Fee(env.current()->fees().base * 2);
500 Number const principalRequest{1, 3};
501
502 auto createJson = env.json(
503 set(borrower, broker.brokerID, principalRequest),
504 Fee(loanSetFee),
505 Json(sfCounterpartySignature, json::ValueType::Object));
506
507 createJson["CloseInterestRate"] = 76671;
508 createJson["ClosePaymentFee"] = "2061925410";
509 createJson["GracePeriod"] = 434;
510 createJson["InterestRate"] = 50302;
511 createJson["LateInterestRate"] = 30322;
512 createJson["LatePaymentFee"] = "294427911";
513 createJson["LoanOriginationFee"] = "3250635102";
514 createJson["LoanServiceFee"] = "9557386";
515 createJson["OverpaymentFee"] = 51249;
516 createJson["OverpaymentInterestRate"] = 14304;
517 createJson["PaymentInterval"] = 434;
518 createJson["PaymentTotal"] = "2891743748";
519 createJson["PrincipalRequested"] = "8516.98";
520
521 createJson = env.json(createJson, Sig(sfCounterpartySignature, lender));
522 env(createJson, Ter(temINVALID));
523 env.close();
524 }
525
526 // Verify that LoanPay, LoanBrokerCoverWithdraw, and LoanSet all use the
527 // same vault-scale minimum cover when fixCleanup3_2_0 is enabled.
528 // Before the amendment, each transactor computed its minimum cover at a
529 // different precision (loanScale, debtScale, or the raw unrounded
530 // tenthBipsOfValue), which could lead to inconsistent decisions for the
531 // same broker state. After the amendment all three use
532 // minimumBrokerCover at vaultScale.
533 void
535 {
536 using namespace jtx;
537 using namespace loan;
538 using namespace loan_broker;
539
540 bool const withAmendment = features[fixCleanup3_2_0];
541
542 struct Ctx
543 {
544 jtx::Account issuer;
545 jtx::Account lender;
546 jtx::Account borrower;
548 BrokerInfo broker;
549 BrokerParameters brokerParams;
550 };
551
552 // Shared setup, parametrized by vaultDeposit (the only varying setup
553 // field across the three scenarios). Each call runs in its own Env
554 // so multiple invocations within one scenario cannot interfere.
555 // The caller is responsible for invoking testcase(...) before the
556 // first runTest call of each scenario.
557 auto const runTest = [&](Number vaultDeposit, auto&& body) {
558 Env env(*this, features);
559
560 Account const issuer{"issuer"};
561 Account const lender{"lender"};
562 Account const borrower{"borrower"};
563
564 env.fund(XRP(1'000'000'000), issuer, lender, borrower);
565 env.close();
566
567 // Enable clawback on the issuer *before* any trust lines exist
568 // (asfAllowTrustLineClawback requires an empty owner directory).
569 env(fset(issuer, asfAllowTrustLineClawback));
570 env.close();
571
572 PrettyAsset const iou = issuer[iouCurrency_];
573 env(trust(lender, iou(1'000'000'000)));
574 env(trust(borrower, iou(1'000'000'000)));
575 env.close();
576 env(pay(issuer, lender, iou(100'000'000)));
577 env(pay(issuer, borrower, iou(100'000'000)));
578 env.close();
579
580 // 13.37% — non-round rate produces a messier minimum.
581 BrokerParameters const brokerParams{
582 .vaultDeposit = vaultDeposit,
583 .debtMax = 0,
584 .coverRateMin = TenthBips32{13'370},
585 .coverDeposit = 5'000,
586 .managementFeeRate = TenthBips16{500},
587 };
588
589 BrokerInfo const broker = createVaultAndBroker(env, iou, lender, brokerParams);
590
591 body(
592 env,
593 Ctx{
594 .issuer = issuer,
595 .lender = lender,
596 .borrower = borrower,
597 .iou = iou,
598 .broker = broker,
599 .brokerParams = brokerParams,
600 });
601 };
602
603 // Scenario 1 — LoanPay
604 //
605 // Verify that LoanPay's minimum cover check uses vault scale (not
606 // loan scale). Before the amendment, different loans could produce
607 // different fee routing decisions for the same broker-level state.
608 // Small vault deposit => vaultScale = -12.
609 testcase("LoanPay minimum cover scale consistency");
610 {
611 struct LoanKeylets
612 {
613 Keylet tiny;
614 Keylet big;
615 };
616
617 // Create the tiny + big loans and reduce cover via clawback so
618 // that subsequent LoanPay calls hit the minimum-cover boundary.
619 // Used by the two pay-and-check sub-tests below so each can run
620 // in its own Env.
621 auto setupLoansAndClawback = [&](Env& env, Ctx const& c) -> std::optional<LoanKeylets> {
622 Asset const asset{c.iou};
623
624 // Create the TINY loan first (while vaultScale is still
625 // small). principal 0.01, 0% interest, 1 payment =>
626 // loanScale = vaultScale.
627 auto const brokerSle1 = env.le(keylet::loanBroker(c.broker.brokerID));
628 if (!BEAST_EXPECT(brokerSle1))
629 return std::nullopt;
630 auto const tinyLoanSeq = brokerSle1->at(sfLoanSequence);
631 auto const tinyLoanKeylet =
632 keylet::loan(c.broker.brokerID, SeqProxy::rawSequence(tinyLoanSeq));
633
634 env(set(c.borrower, c.broker.brokerID, Number{1, -2}),
635 Sig(sfCounterpartySignature, c.lender),
636 kInterestRate(TenthBips32{0}),
637 kPaymentTotal(1),
638 kPaymentInterval(86400 * 365),
639 Fee(XRP(10)));
640 env.close();
641
642 // Create the BIG loan second. 100% annual interest over 20
643 // payments pushes totalValueOutstanding high enough that
644 // loanScale > vaultScale.
645 auto const brokerSle2 = env.le(keylet::loanBroker(c.broker.brokerID));
646 if (!BEAST_EXPECT(brokerSle2))
647 return std::nullopt;
648 auto const bigLoanSeq = brokerSle2->at(sfLoanSequence);
649 auto const bigLoanKeylet =
650 keylet::loan(c.broker.brokerID, SeqProxy::rawSequence(bigLoanSeq));
651
652 env(set(c.borrower, c.broker.brokerID, Number{500}),
653 Sig(sfCounterpartySignature, c.lender),
654 kInterestRate(TenthBips32{100'000}),
655 kPaymentTotal(20),
656 kPaymentInterval(86400 * 365),
657 Fee(XRP(10)));
658 env.close();
659
660 // The tiny loan's scale is frozen at the vault's pre-big-loan
661 // scale, so it is strictly smaller than the big loan's.
662 // After the big loan is created the vault absorbs its value,
663 // pushing vaultScale up to match bigLoanScale.
664 auto const tinyLoanSle = env.le(tinyLoanKeylet);
665 auto const bigLoanSle = env.le(bigLoanKeylet);
666 auto const vaultSle = env.le(keylet::vault(c.broker.vaultID));
667 if (!BEAST_EXPECT(tinyLoanSle) || !BEAST_EXPECT(bigLoanSle) ||
668 !BEAST_EXPECT(vaultSle))
669 return std::nullopt;
670 if (!BEAST_EXPECT(tinyLoanSle->at(sfLoanScale) == -12) ||
671 !BEAST_EXPECT(bigLoanSle->at(sfLoanScale) == -11) ||
672 !BEAST_EXPECT(getVaultScale(vaultSle) == -11))
673 return std::nullopt;
674
675 // Use issuer clawback to reduce cover to the minimum the
676 // clawback transactor allows. Compute the amount as
677 // initialCover - expectedCoverAfter so we exercise the exact
678 // clawback rather than relying on the transactor to clip
679 // down.
680 //
681 // Before the amendment the clawback minimum is the
682 // *unrounded* tenthBipsOfValue — strictly less than the
683 // rounded-at-vaultScale minimum LoanPay uses for the big
684 // loan. After the amendment both clawback and LoanPay use
685 // the same rounded minimum (via minimumBrokerCover), so
686 // cover lands exactly at that threshold.
687 Number const expectedCoverAfter = withAmendment ? Number{1330651855688460000, -15}
688 : Number{1330651855688458000, -15};
689 Number const clawbackAmount =
690 Number{c.brokerParams.coverDeposit} - expectedCoverAfter;
691
692 env(coverClawback(c.issuer),
693 kLoanBrokerId(c.broker.brokerID),
695 env.close();
696
697 auto const brokerSle = env.le(keylet::loanBroker(c.broker.brokerID));
698 if (!BEAST_EXPECT(brokerSle) ||
699 !BEAST_EXPECT(brokerSle->at(sfCoverAvailable) == expectedCoverAfter))
700 return std::nullopt;
701
702 return LoanKeylets{.tiny = tinyLoanKeylet, .big = bigLoanKeylet};
703 };
704
705 // Pay one loan and report whether the fee went to the broker's
706 // pseudo account (the fallback when cover < minimum) rather
707 // than to the owner.
708 auto feeGoesToPseudo = [&](Env& env, Ctx const& c, Keylet const& loanKeylet) -> bool {
709 Asset const asset{c.iou};
710 auto const brokerSle = env.le(keylet::loanBroker(c.broker.brokerID));
711 if (!BEAST_EXPECT(brokerSle))
712 return false;
713 auto const pseudoAcct = Account("pseudo", brokerSle->at(sfAccount));
714 auto const pseudoBefore = env.balance(pseudoAcct, c.iou);
715
716 auto const payLoan = env.le(loanKeylet);
717 if (!BEAST_EXPECT(payLoan))
718 return false;
719 auto const periodicPayment = payLoan->at(sfPeriodicPayment);
720 auto const serviceFee = payLoan->at(sfLoanServiceFee);
721 std::int32_t const loanScale = payLoan->at(sfLoanScale);
722
723 auto const payment = roundPeriodicPayment(asset, periodicPayment, loanScale);
724 auto const payAmt = STAmount{asset, payment + serviceFee};
725
726 env(loan::pay(c.borrower, loanKeylet.key, payAmt), Fee(XRP(10)));
727 env.close();
728
729 auto const pseudoAfter = env.balance(pseudoAcct, c.iou);
730 return pseudoAfter.number() > pseudoBefore.number();
731 };
732
733 // Pay the BIG loan in its own Env so its outcome cannot affect
734 // the TINY-loan check. With the fix, LoanPay and clawback use
735 // the same vaultScale minimum (cover == minAtVaultScale =>
736 // fee to owner). Without the fix, LoanPay uses bigLoanScale=-11,
737 // rounds up to a larger minimum than what clawback used =>
738 // cover < min => fee to pseudo.
739 runTest(/*vaultDeposit=*/1'000, [&](Env& env, Ctx const& c) {
740 auto const loans = setupLoansAndClawback(env, c);
741 if (!loans)
742 return;
743 BEAST_EXPECT(feeGoesToPseudo(env, c, loans->big) == !withAmendment);
744 });
745
746 // Pay the TINY loan in its own Env. Fee goes to the owner
747 // either way:
748 // - With the fix: LoanPay uses vaultScale=-11 (same as
749 // clawback) => owner.
750 // - Without the fix: LoanPay uses tinyLoanScale=-12, rounds
751 // up at -12 (a no-op) => min == cover => owner.
752 runTest(/*vaultDeposit=*/1'000, [&](Env& env, Ctx const& c) {
753 auto const loans = setupLoansAndClawback(env, c);
754 if (!loans)
755 return;
756 BEAST_EXPECT(!feeGoesToPseudo(env, c, loans->tiny));
757 });
758 }
759
760 // Scenario 2 — LoanBrokerCoverWithdraw
761 //
762 // Verify that CoverWithdraw's minimum cover check uses vault scale
763 // (not scale(debtTotal, asset)). Before the amendment, CoverWithdraw
764 // used:
765 // roundToAsset(asset, tenthBipsOfValue(debt, rate), scale(debt, asset))
766 // which could disagree with LoanPay's minimum (which used loanScale).
767 //
768 // Use a large vault deposit so that vaultScale (from AssetsTotal) is
769 // strictly larger than debtScale (from DebtTotal). With
770 // vaultDeposit = 100,000: after the big loan
771 // AssetsTotal ≈ 109,500 → vaultScale = -10
772 // DebtTotal ≈ 10,000 → debtScale = -11
773 // The one-order-of-magnitude gap makes roundToAsset at -10 truncate
774 // more aggressively than at -11, exposing the bug.
775 testcase("CoverWithdraw minimum cover scale consistency");
776 runTest(
777 /*vaultDeposit=*/100'000, [&](Env& env, Ctx const& c) {
778 Asset const asset{c.iou};
779
780 // Create only the big loan to push DebtTotal up to ~10,000
781 // while AssetsTotal stays around 109,500 (dominated by the
782 // large vault deposit).
783 env(set(c.borrower, c.broker.brokerID, Number{500}),
784 Sig(sfCounterpartySignature, c.lender),
785 kInterestRate(TenthBips32{100'000}),
786 kPaymentTotal(20),
787 kPaymentInterval(86400 * 365),
788 Fee(XRP(10)));
789 env.close();
790
791 // Read broker state and compute both old and new minimums.
792 auto const brokerSle = env.le(keylet::loanBroker(c.broker.brokerID));
793 auto const vaultSle = env.le(keylet::vault(c.broker.vaultID));
794 if (!BEAST_EXPECT(brokerSle) || !BEAST_EXPECT(vaultSle))
795 return;
796
797 auto const coverAvail = brokerSle->at(sfCoverAvailable);
798 auto const debtTotal = brokerSle->at(sfDebtTotal);
799 auto const vaultScale = getVaultScale(vaultSle);
800 auto const debtScale = scale(debtTotal, asset);
801
802 // Sanity: debt scale differs from vault scale for this setup.
803 BEAST_EXPECT(debtScale < vaultScale);
804
805 auto const oldMin = [&] {
807 return roundToAsset(
808 asset,
809 tenthBipsOfValue(debtTotal, TenthBips32{c.brokerParams.coverRateMin}),
810 debtScale);
811 }();
812 auto const newMin = minimumBrokerCover(
813 debtTotal, TenthBips32{c.brokerParams.coverRateMin}, vaultSle);
814
815 // The new (vaultScale) minimum must be strictly larger than
816 // the old (debtScale) minimum — that is the gap the amendment
817 // closes.
818 Number const expectedNewMin{1330650518688500000, -15};
819 Number const expectedOldMin{1330650518688472000, -15};
820 BEAST_EXPECT(newMin == expectedNewMin);
821 BEAST_EXPECT(oldMin == expectedOldMin);
822
823 // Try to withdraw so that remaining cover lands between the
824 // two minimums: oldMin < target < newMin.
825 auto const target = oldMin + (newMin - oldMin) / 2;
826 auto const withdrawAmount = STAmount{asset, coverAvail - target};
827
828 if (withAmendment)
829 {
830 // CoverWithdraw now uses vaultScale: target < newMin
831 // => FAILS.
832 env(coverWithdraw(c.lender, c.broker.brokerID, withdrawAmount),
834 }
835 else
836 {
837 // Old CoverWithdraw uses debtScale: target > oldMin
838 // => SUCCEEDS.
839 env(coverWithdraw(c.lender, c.broker.brokerID, withdrawAmount));
840 }
841 env.close();
842 });
843
844 // Scenario 3 — LoanSet
845 //
846 // Verify that LoanSet's minimum cover check uses vault scale (not the
847 // raw unrounded tenthBipsOfValue). Before the amendment, LoanSet
848 // used tenthBipsOfValue(newDebtTotal, coverRateMinimum) (no
849 // roundToAsset), while clawback/withdraw used different formulas.
850 // After the amendment all use minimumBrokerCover at vaultScale, and
851 // rounding at a coarser scale can absorb a tiny debt increase —
852 // allowing a loan that would otherwise be rejected.
853 testcase("LoanSet minimum cover scale consistency");
854 runTest(
855 /*vaultDeposit=*/1'000, [&](Env& env, Ctx const& c) {
856 // Create the tiny loan (scale -12) AND the big loan (scale
857 // -11). Both loans are needed so that DebtTotal has a full
858 // 16-digit mantissa — a "messy" value where roundToAsset at
859 // vaultScale actually truncates digits and produces a
860 // different result from the raw tenthBipsOfValue. With only
861 // the big loan, DebtTotal has ~4 significant digits and
862 // rounding at scale -11 is a no-op, masking the amendment's
863 // effect.
864 env(set(c.borrower, c.broker.brokerID, Number{1, -2}),
865 Sig(sfCounterpartySignature, c.lender),
866 kInterestRate(TenthBips32{0}),
867 kPaymentTotal(1),
868 kPaymentInterval(86400 * 365),
869 Fee(XRP(10)));
870 env.close();
871
872 env(set(c.borrower, c.broker.brokerID, Number{500}),
873 Sig(sfCounterpartySignature, c.lender),
874 kInterestRate(TenthBips32{100'000}),
875 kPaymentTotal(20),
876 kPaymentInterval(86400 * 365),
877 Fee(XRP(10)));
878 env.close();
879
880 // Clawback to reduce cover to the clawback transactor's
881 // minimum. Pass the exact amount rather than relying on the
882 // transactor to clip down; the setup matches Scenario 1 so
883 // the same residual-cover values apply.
884 Number const expectedCoverAfter = withAmendment ? Number{1330651855688460000, -15}
885 : Number{1330651855688458000, -15};
886 Number const clawbackAmount =
887 Number{c.brokerParams.coverDeposit} - expectedCoverAfter;
888 env(coverClawback(c.issuer),
889 kLoanBrokerId(c.broker.brokerID),
890 kAmount(c.iou(clawbackAmount)));
891 env.close();
892
893 // Verify scales.
894 auto const vaultSle = env.le(keylet::vault(c.broker.vaultID));
895 if (!BEAST_EXPECT(vaultSle))
896 return;
897 auto const vaultScale = getVaultScale(vaultSle);
898 BEAST_EXPECT(vaultScale == -11);
899
900 // Now try to create a tiny additional loan. Principal is
901 // 1e-11 (the smallest value that survives the precision
902 // check at loanScale = vaultScale = -11), with 0% interest
903 // and 1 payment.
904 //
905 // The tiny debt increase adds ~1.337e-12 to the unrounded
906 // minimum.
907 // - Without the amendment: the old LoanSet formula rounds
908 // up during tenthBipsOfValue (16-digit Number
909 // normalisation), pushing the minimum past the cover left
910 // by clawback => tecINSUFFICIENT_FUNDS.
911 // - With the amendment: minimumBrokerCover rounds at
912 // vaultScale=-11, which absorbs the tiny increase — the
913 // rounded minimum stays the same => tesSUCCESS.
914 auto const tinyPrincipal = Number{1, -11};
915
916 if (withAmendment)
917 {
918 env(set(c.borrower, c.broker.brokerID, tinyPrincipal),
919 Sig(sfCounterpartySignature, c.lender),
920 kInterestRate(TenthBips32{0}),
921 kPaymentTotal(1),
922 kPaymentInterval(86400 * 365),
923 Fee(XRP(10)));
924 }
925 else
926 {
927 env(set(c.borrower, c.broker.brokerID, tinyPrincipal),
928 Sig(sfCounterpartySignature, c.lender),
929 kInterestRate(TenthBips32{0}),
930 kPaymentTotal(1),
931 kPaymentInterval(86400 * 365),
932 Fee(XRP(10)),
934 }
935 env.close();
936 });
937 }
938
939 void
941 {
942 using namespace jtx;
943 using namespace loan;
944
945 auto const runCase = [&](bool coarseBorrower) {
946 testcase(
947 coarseBorrower ? "LoanSet borrower balance uses coarsest scale"
948 : "LoanSet broker owner balance uses coarsest scale");
949
950 Env env(*this, all_ | featureLendingProtocolV1_1);
951 Account const issuer{"issuer"};
952 Account const lender{"lender"};
953 Account const borrower{"borrower"};
954
955 Number const coarseBalance{100'000'000'000LL};
956 Number const regularBalance{100'000'000};
958 env,
959 issuer,
960 lender,
961 borrower,
962 coarseBorrower ? regularBalance : coarseBalance,
963 coarseBorrower ? coarseBalance : regularBalance);
964
965 BrokerParameters const brokerParams{
966 .vaultDeposit = 1'000'000,
967 .debtMax = 0,
968 .coverRateMin = TenthBips32{0},
969 .coverDeposit = 0,
970 .managementFeeRate = TenthBips16{0},
971 .coverRateLiquidation = TenthBips32{0},
972 };
973 BrokerInfo const broker = createVaultAndBroker(env, asset, lender, brokerParams);
974
975 Number const principal{1'012'345, -5};
976 Number const originationFee{123'456, -6};
977 Account const& recipient = coarseBorrower ? borrower : lender;
978 Number const expected = coarseBorrower ? principal : originationFee;
979 auto const before = env.balance(recipient, asset);
980
981 if (coarseBorrower)
982 {
983 env(set(borrower, broker.brokerID, principal),
984 kCounterparty(lender),
985 Sig(sfCounterpartySignature, lender),
986 kInterestRate(TenthBips32{0}),
987 kPaymentTotal(1),
988 Fee(env.current()->fees().base * 2),
989 Ter(tesSUCCESS));
990 }
991 else
992 {
993 env(set(borrower, broker.brokerID, principal),
994 kCounterparty(lender),
995 Sig(sfCounterpartySignature, lender),
996 kLoanOriginationFee(originationFee),
997 kInterestRate(TenthBips32{0}),
998 kPaymentTotal(1),
999 Fee(env.current()->fees().base * 2),
1000 Ter(tesSUCCESS));
1001 }
1002 env.close();
1003
1004 auto const after = env.balance(recipient, asset);
1005 Number const received = after.number() - before.number();
1006 auto const recipientScale =
1007 std::max(before.value().exponent(), after.value().exponent());
1008 auto const vaultScale = broker.vaultScale(env);
1009 Number const tolerance{1, recipientScale};
1010
1011 BEAST_EXPECT(recipientScale > vaultScale);
1012 BEAST_EXPECT(received != expected);
1013 BEAST_EXPECT(
1014 abs(roundToAsset(asset, received, recipientScale) -
1015 roundToAsset(asset, expected, recipientScale)) <= tolerance);
1016 };
1017
1018 runCase(/*coarseBorrower=*/true);
1019 runCase(/*coarseBorrower=*/false);
1020 }
1021
1022 // Under featureLendingProtocolV1_1, ValidLoan::finalize enforces
1023 // TotalValueOutstanding >= PrincipalOutstanding + ManagementFeeOutstanding
1024 // ("interest due is non-negative"). This test drives the transactor
1025 // through a multi-payment scenario with a non-zero management fee and
1026 // messy IOU-scale rounding; if any rounding path in LoanPay were to
1027 // inflate PrincipalOutstanding or ManagementFeeOutstanding relative to
1028 // TotalValueOutstanding by even one ULP, the invariant would fire and
1029 // the LoanPay would return tecINVARIANT_FAILED instead of tesSUCCESS.
1030 void
1032 {
1033 testcase("LoanPay interest-due non-negative invariant");
1034
1035 using namespace jtx;
1036 using namespace loan;
1037
1038 Env env(*this, all_ | featureLendingProtocolV1_1);
1039
1040 Account const issuer{"issuer"};
1041 Account const lender{"lender"};
1042 Account const borrower{"borrower"};
1043
1044 PrettyAsset const iouAsset = createFundedIouAsset(env, issuer, lender, borrower);
1045
1046 // Default broker params carry managementFeeRate = 100 tenth-bips
1047 // (1%), which is what makes managementFeeOutstanding accumulate
1048 // non-trivially through the payment schedule.
1049 BrokerInfo const broker{createVaultAndBroker(env, iouAsset, lender)};
1050
1051 auto const loanSetFee = Fee(env.current()->fees().base * 2);
1052 auto const loanKeylet = nextLoanKeylet(env, broker);
1053
1054 // Messy interest rate, non-trivial payment count. Values chosen so
1055 // that periodicPayment and each roundedInterest/managementFee share
1056 // are unlikely to be representable exactly at loanScale.
1057 env(set(borrower, broker.brokerID, Number{1'000}),
1058 Sig(sfCounterpartySignature, lender),
1059 kInterestRate(TenthBips32{24'346}),
1060 kPaymentTotal(24),
1061 kPaymentInterval(86400 * 30),
1062 loanSetFee);
1063 env.close();
1064
1065 auto const payFee = Fee(env.current()->fees().base * 2);
1066 // Boundary check up front on the freshly-created loan.
1067 {
1068 auto const initial = getCurrentState(env, broker, loanKeylet);
1069 BEAST_EXPECT(
1070 initial.totalValue >=
1071 initial.principalOutstanding + initial.managementFeeOutstanding);
1072 }
1073
1074 // Six regular scheduled payments. If the invariant fires the
1075 // Ter(tesSUCCESS) assertion below catches it; the identity check
1076 // then re-asserts it in the test for a clearer failure message.
1077 std::uint32_t prevPaymentRemaining = 24;
1078 for (int i = 0; i < 6; ++i)
1079 {
1080 auto const loanSle = env.le(loanKeylet);
1081 if (!BEAST_EXPECT(loanSle))
1082 return;
1083 // Match the amount LoanPay expects for a scheduled payment:
1084 // periodicPayment rounded at loanScale, plus the flat service
1085 // fee (0 here by default, but included for robustness).
1086 auto const payAmount = STAmount{
1087 iouAsset,
1089 iouAsset, loanSle->at(sfPeriodicPayment), loanSle->at(sfLoanScale)) +
1090 loanSle->at(sfLoanServiceFee)};
1091 env(pay(borrower, loanKeylet.key, payAmount), payFee, Ter(tesSUCCESS));
1092 env.close();
1093
1094 auto const state = getCurrentState(env, broker, loanKeylet);
1095 BEAST_EXPECT(
1096 state.totalValue >= state.principalOutstanding + state.managementFeeOutstanding);
1097 BEAST_EXPECT(state.paymentRemaining == prevPaymentRemaining - 1);
1098 prevPaymentRemaining = state.paymentRemaining;
1099 }
1100 }
1101
1102 // Tests run under each entry in amendmentCombinations().
1103 void
1112
1113public:
1114 void
1115 run() override
1116 {
1119 for (auto const& features : jtx::amendmentCombinations(
1120 {fixCleanup3_1_3, fixCleanup3_2_0, featureMPTokensV2}, all_))
1121 runAmendmentSensitive(features);
1122 }
1123};
1124
1125BEAST_DEFINE_TESTSUITE(LoanInvariants, tx, xrpl);
1126
1127} // namespace xrpl::test
TestcaseT testcase
Memberspace for declaring test cases.
Definition suite.h:155
Number is a floating point type that can represent a wide range of values.
Definition Number.h:351
static constexpr SeqProxy rawSequence(std::uint32_t v)
Factory function to return a sequence-based SeqProxy.
Definition SeqProxy.h:62
void runAmendmentSensitive(FeatureBitset features)
void testLoanPayDebtDecreaseInvariant(FeatureBitset features)
void testLoanPayComputePeriodicPaymentInvariants(FeatureBitset features)
void testAccountSendMptMinAmountInvariant(FeatureBitset features)
void run() override
Runs the suite.
void testLoanPayOverpaymentScheduleInvariant(FeatureBitset features)
void testMinimumBrokerCoverConsistency(FeatureBitset features)
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_
jtx::Account brokerPseudoAccount(jtx::Env const &env, BrokerInfo const &broker, jtx::Account const &fallback)
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)
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_
Immutable cryptographic account descriptor.
Definition jtx/Account.h:21
A transaction testing environment.
Definition Env.h:161
bool close(NetClock::time_point closeTime, std::optional< std::chrono::milliseconds > consensusDelay=std::nullopt)
Close and advance the ledger.
Definition Env.cpp:133
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
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< 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
Test helper for creating, mutating, and asserting MPT and confidential MPT ledger state.
Definition mpt.h:512
MPTID const & issuanceID() const
Definition mpt.h:777
void create(MPTCreate const &arg=MPTCreate{}, std::source_location const &loc=std::source_location::current())
Definition mpt.cpp:346
void authorize(MPTAuthorize const &arg=MPTAuthorize{}, std::source_location const &loc=std::source_location::current())
Definition mpt.cpp:459
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 max(T... args)
@ 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 loan(UInt256 const &loanBrokerID, SeqProxy const &loanSeq) noexcept
Definition Indexes.cpp:577
Keylet keylet(test::jtx::Account const &subject, test::jtx::Account const &issuer, std::string_view credType)
Definition credentials.h:21
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 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
static MPTInit const kMptInitNoFund
Definition mpt.h:201
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
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
STAmount clawbackAmount(SLE::ConstRef vault, std::optional< STAmount > const &maybeAmount, AccountID const &account)
constexpr TenthBips32 percentageToTenthBips(std::uint32_t percentage)
Definition Protocol.h:127
constexpr T tenthBipsOfValue(T value, TenthBips< TBips > bips)
Definition Protocol.h:139
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
TenthBips< std::uint16_t > TenthBips16
Definition Units.h:453
std::string to_string(BaseUInt< Bits, Tag > const &a)
Definition base_uint.h:658
Number minimumBrokerCover(Number const &debtTotal, TenthBips32 coverRateMinimum, SLE::ConstRef vaultSle)
Minimum required broker cover, rounded up.
bool after(NetClock::time_point now, std::uint32_t mark)
Has the specified time passed?
Definition View.cpp:668
constexpr Number abs(Number x) noexcept
Definition Number.h:880
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 roundPeriodicPayment(Asset const &asset, Number const &periodicPayment, std::int32_t scale)
Ensure the periodic payment is always rounded consistently.
@ temINVALID
Definition TER.h:98
@ tecINSUFFICIENT_FUNDS
Definition TER.h:336
@ tecPRECISION_LOSS
Definition TER.h:374
@ tecINSUFFICIENT_PAYMENT
Definition TER.h:338
@ tesSUCCESS
Definition TER.h:253
bool isRounded(Asset const &asset, Number const &value, std::int32_t scale)
A pair of SHAMap key and LedgerEntryType.
Definition Keylet.h:20
UInt256 key
Definition Keylet.h:21
int vaultScale(jtx::Env const &env) const
Helper class to compare the expected state of a loan and loan broker against the data in the ledger.
T to_string(T... args)