xrpld
Loading...
Searching...
No Matches
LoanLifecycle_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/batch.h>
7#include <test/jtx/fee.h>
8#include <test/jtx/flags.h>
9#include <test/jtx/jtx_json.h>
10#include <test/jtx/mpt.h>
11#include <test/jtx/pay.h>
12#include <test/jtx/ter.h>
13#include <test/jtx/trust.h>
14#include <test/jtx/utility.h>
15#include <test/jtx/vault.h>
16
17#include <xrpl/basics/Number.h>
18#include <xrpl/basics/base_uint.h>
19#include <xrpl/basics/strHex.h>
20#include <xrpl/beast/unit_test/suite.h>
21#include <xrpl/json/json_value.h>
22#include <xrpl/json/to_string.h>
23#include <xrpl/protocol/Feature.h>
24#include <xrpl/protocol/HashPrefix.h>
25#include <xrpl/protocol/Indexes.h>
26#include <xrpl/protocol/Issue.h>
27#include <xrpl/protocol/SField.h>
28#include <xrpl/protocol/SecretKey.h>
29#include <xrpl/protocol/SeqProxy.h>
30#include <xrpl/protocol/Serializer.h>
31#include <xrpl/protocol/TER.h>
32#include <xrpl/protocol/TxFlags.h>
33#include <xrpl/protocol/jss.h>
34
35#include <array>
36#include <cstddef>
37#include <cstdint>
38#include <map>
39#include <string_view>
40#include <vector>
41
42namespace xrpl::test {
43
45{
46private:
47 void
49 {
50 testcase("Lifecycle");
51 using namespace jtx;
52
53 // Create 3 loan brokers: one for XRP, one for an IOU, and one for
54 // an MPT. That'll require three corresponding SAVs.
55 Env env(*this, features);
56
57 Account const issuer{"issuer"};
58 // For simplicity, lender will be the sole actor for the vault &
59 // brokers.
60 Account const lender{"lender"};
61 // Borrower only wants to borrow
62 Account const borrower{"borrower"};
63 // Evan will attempt to be naughty
64 Account const evan{"evan"};
65 // Do not fund alice
66 Account const alice{"alice"};
67
68 // Fund the accounts and trust lines with the same amount so that
69 // tests can use the same values regardless of the asset.
70 env.fund(XRP(100'000'000), issuer, noripple(lender, borrower, evan));
71 env.close();
72
73 // Create assets
74 PrettyAsset const xrpAsset{xrpIssue(), 1'000'000};
75 PrettyAsset const iouAsset = issuer[iouCurrency_];
76 env(trust(lender, iouAsset(10'000'000)));
77 env(trust(borrower, iouAsset(10'000'000)));
78 env(trust(evan, iouAsset(10'000'000)));
79 env(pay(issuer, evan, iouAsset(1'000'000)));
80 env(pay(issuer, lender, iouAsset(10'000'000)));
81 // Fund the borrower with enough to cover interest and fees
82 env(pay(issuer, borrower, iouAsset(10'000)));
83 env.close();
84
85 MPTTester mptt{env, issuer, kMptInitNoFund};
86 mptt.create({.flags = tfMPTCanClawback | tfMPTCanTransfer | tfMPTCanLock});
87 // Scale the MPT asset a little bit so we can get some interest
88 PrettyAsset const mptAsset{mptt.issuanceID(), 100};
89 mptt.authorize({.account = lender});
90 mptt.authorize({.account = borrower});
91 mptt.authorize({.account = evan});
92 env(pay(issuer, lender, mptAsset(10'000'000)));
93 env(pay(issuer, evan, mptAsset(1'000'000)));
94 // Fund the borrower with enough to cover interest and fees
95 env(pay(issuer, borrower, mptAsset(10'000)));
96 env.close();
97
98 std::array const assets{iouAsset, xrpAsset, mptAsset};
99
100 // Create vaults and loan brokers
102 brokers.reserve(assets.size());
103 for (auto const& asset : assets)
104 {
106 env, asset, lender, BrokerParameters{.data = "spam spam spam spam"}));
107 }
108
109 // Create and update Loans
110 for (auto const& broker : brokers)
111 {
112 for (int amountExponent = 3; amountExponent >= 3; --amountExponent)
113 {
114 Number const loanAmount{1, amountExponent};
115 for (int interestExponent = 0; interestExponent >= 0; --interestExponent)
116 {
117 testCaseWrapper(env, mptt, assets, broker, loanAmount, interestExponent);
118 }
119 }
120
121 if (auto brokerSle = env.le(keylet::loanBroker(broker.brokerID));
122 BEAST_EXPECT(brokerSle))
123 {
124 BEAST_EXPECT(brokerSle->at(sfOwnerCount) == 0);
125 BEAST_EXPECT(brokerSle->at(sfDebtTotal) == 0);
126
127 auto const coverAvailable = brokerSle->at(sfCoverAvailable);
129 lender, broker.brokerID, STAmount(broker.asset, coverAvailable)));
130 env.close();
131
132 brokerSle = env.le(keylet::loanBroker(broker.brokerID));
133 BEAST_EXPECT(brokerSle && brokerSle->at(sfCoverAvailable) == 0);
134 }
135 // Verify we can delete the loan broker
136 env(loan_broker::del(lender, broker.brokerID));
137 env.close();
138 }
139 }
140
141 void
143 {
144 testcase << "Self Loan";
145
146 using namespace jtx;
147 using namespace std::chrono_literals;
148 // Create 3 loan brokers: one for XRP, one for an IOU, and one for
149 // an MPT. That'll require three corresponding SAVs.
150 Env env(*this, features);
151
152 Account const issuer{"issuer"};
153 // For simplicity, lender will be the sole actor for the vault &
154 // brokers.
155 Account const lender{"lender"};
156
157 // Fund the accounts and trust lines with the same amount so that
158 // tests can use the same values regardless of the asset.
159 env.fund(XRP(100'000'000), issuer, noripple(lender));
160 env.close();
161
162 // Use an XRP asset for simplicity
163 PrettyAsset const xrpAsset{xrpIssue(), 1'000'000};
164
165 // Create vaults and loan brokers
166 BrokerInfo broker{createVaultAndBroker(env, xrpAsset, lender)};
167
168 using namespace loan;
169
170 auto const loanSetFee = Fee(env.current()->fees().base * 2);
171 Number const principalRequest{1, 3};
172
173 // The LoanSet json can be created without a counterparty signature,
174 // but it will not pass preflight
175 auto createJson = env.json(
176 set(lender, broker.brokerID, broker.asset(principalRequest).value()), Fee(loanSetFee));
177 env(createJson, Ter(temBAD_SIGNER));
178
179 // Adding an empty counterparty signature object also fails, but
180 // at the RPC level.
181 createJson = env.json(createJson, Json(sfCounterpartySignature, json::ValueType::Object));
182 env(createJson, Ter(telENV_RPC_FAILED));
183
184 if (auto const jt = env.jt(createJson); BEAST_EXPECT(jt.stx))
185 {
186 Serializer s;
187 jt.stx->add(s);
188 auto const jr = env.rpc("submit", strHex(s.slice()));
189
190 BEAST_EXPECT(jr.isMember(jss::result));
191 auto const jResult = jr[jss::result];
192 BEAST_EXPECT(jResult[jss::error] == "invalidTransaction");
193 BEAST_EXPECT(!jResult.isMember(jss::error_code));
194 BEAST_EXPECT(jResult[jss::error_message].isNull());
195 BEAST_EXPECT(
196 jResult[jss::error_exception] ==
197 "fails local checks: Transaction has bad signature.");
198 }
199
200 // Copy the transaction signature into the counterparty signature.
201 json::Value counterpartyJson{json::ValueType::Object};
202 counterpartyJson[sfTxnSignature] = createJson[sfTxnSignature];
203 counterpartyJson[sfSigningPubKey] = createJson[sfSigningPubKey];
204 if (!BEAST_EXPECT(!createJson.isMember(jss::Signers)))
205 counterpartyJson[sfSigners] = createJson[sfSigners];
206
207 // The duplicated signature does not work: the counterparty signs a
208 // different prefix than the account.
209 env(env.json(createJson, Json(sfCounterpartySignature, counterpartyJson)),
211
212 // Signing the counterparty field itself works, even though the lender
213 // is both the borrower and the counterparty.
214 createJson = env.json(createJson, Sig(sfCounterpartySignature, lender));
215 env(createJson);
216
217 env.close();
218
219 auto const startDate = env.current()->header().parentCloseTime;
220
221 // Loan is successfully created
222 {
223 auto const res = env.rpc("account_objects", lender.human());
224 auto const objects = res[jss::result][jss::account_objects];
225
227 BEAST_EXPECT(objects.size() == 4);
228 for (auto const& object : objects)
229 {
230 ++types[object[sfLedgerEntryType].asString()];
231 }
232 BEAST_EXPECT(types.size() == 4);
233 for (std::string const type : {"MPToken", "Vault", "LoanBroker", "Loan"})
234 {
235 BEAST_EXPECT(types[type] == 1);
236 }
237 }
238 auto const loanID = [&] {
240 params[jss::account] = lender.human();
241 params[jss::type] = "Loan";
242 auto const res = env.rpc("json", "account_objects", to_string(params));
243 auto const objects = res[jss::result][jss::account_objects];
244
245 BEAST_EXPECT(objects.size() == 1);
246
247 auto const loan = objects[0u];
248 BEAST_EXPECT(loan[sfBorrower] == lender.human());
249 // soeDEFAULT fields are not returned if they're in the default
250 // state
251 BEAST_EXPECT(!loan.isMember(sfCloseInterestRate));
252 BEAST_EXPECT(!loan.isMember(sfClosePaymentFee));
253 BEAST_EXPECT(loan[sfFlags] == 0);
254 BEAST_EXPECT(loan[sfGracePeriod] == 60);
255 BEAST_EXPECT(!loan.isMember(sfInterestRate));
256 BEAST_EXPECT(!loan.isMember(sfLateInterestRate));
257 BEAST_EXPECT(!loan.isMember(sfLatePaymentFee));
258 BEAST_EXPECT(loan[sfLoanBrokerID] == to_string(broker.brokerID));
259 BEAST_EXPECT(!loan.isMember(sfLoanOriginationFee));
260 BEAST_EXPECT(loan[sfLoanSequence] == 1);
261 BEAST_EXPECT(!loan.isMember(sfLoanServiceFee));
262 BEAST_EXPECT(loan[sfNextPaymentDueDate] == loan[sfStartDate].asUInt() + 60);
263 BEAST_EXPECT(!loan.isMember(sfOverpaymentFee));
264 BEAST_EXPECT(!loan.isMember(sfOverpaymentInterestRate));
265 BEAST_EXPECT(loan[sfPaymentInterval] == 60);
266 BEAST_EXPECT(loan[sfPeriodicPayment] == "1000000000");
267 BEAST_EXPECT(loan[sfPaymentRemaining] == 1);
268 BEAST_EXPECT(!loan.isMember(sfPreviousPaymentDueDate));
269 BEAST_EXPECT(loan[sfPrincipalOutstanding] == "1000000000");
270 BEAST_EXPECT(loan[sfTotalValueOutstanding] == "1000000000");
271 BEAST_EXPECT(!loan.isMember(sfLoanScale));
272 BEAST_EXPECT(loan[sfStartDate].asUInt() == startDate.time_since_epoch().count());
273
274 return loan["index"].asString();
275 }();
276 auto const loanKeylet{keylet::loan(UInt256{std::string_view(loanID)})};
277
278 env.close(startDate);
279
280 // Make a payment
281 env(pay(lender, loanKeylet.key, broker.asset(1000)));
282 }
283
284 void
286 {
287 testcase << "Issuer Loan";
288
289 using namespace jtx;
290 using namespace loan;
291 Account const issuer("issuer");
292 Account const borrower = issuer;
293 Account const lender("lender");
294 Env env(*this);
295
296 env.fund(XRP(1'000), issuer, lender);
297
298 static constexpr std::int64_t kIssuerBalance = 10'000'000;
299 MPTTester const asset(
300 {.env = env, .issuer = issuer, .holders = {lender}, .pay = kIssuerBalance});
301
302 BrokerParameters const brokerParams{
303 .debtMax = 200,
304 };
305 auto const broker = createVaultAndBroker(env, asset, lender, brokerParams);
306 auto const loanSetFee = Fee(env.current()->fees().base * 2);
307 // Create Loan
308 env(set(borrower, broker.brokerID, 200), Sig(sfCounterpartySignature, lender), loanSetFee);
309 env.close();
310 // Issuer should not create MPToken
311 BEAST_EXPECT(!env.le(keylet::mptoken(asset.issuanceID(), issuer)));
312 // Issuer "borrowed" 200, OutstandingAmount decreased by 200
313 BEAST_EXPECT(env.balance(issuer, asset) == asset(-kIssuerBalance + 200));
314 // Pay Loan
315 auto const loanKeylet = keylet::loan(broker.brokerID, SeqProxy::rawSequence(1));
316 env(pay(borrower, loanKeylet.key, asset(200)));
317 env.close();
318 // Issuer "re-payed" 200, OutstandingAmount increased by 200
319 BEAST_EXPECT(env.balance(issuer, asset) == asset(-kIssuerBalance));
320 }
321
322 void
324 {
325 testcase("Test Borrower is Broker");
326 using namespace jtx;
327 using namespace loan;
328 Account const broker{"broker"};
329 Account const issuer{"issuer"};
330 Account const borrower{"borrower"};
331 Account const depositor{"depositor"};
332
333 auto const testLoanAsset = [&](auto&& getMaxDebt, auto const& borrower) {
334 Env env(*this);
335 Vault const vault(env);
336
337 if (borrower == broker)
338 {
339 env.fund(XRP(10'000), broker, issuer, depositor);
340 }
341 else
342 {
343 env.fund(XRP(10'000), broker, borrower, issuer, depositor);
344 }
345 env.close();
346
347 auto const xrpFee = XRP(100);
348 auto const txFee = Fee(xrpFee);
349
350 STAmount const debtMaximumRequest = getMaxDebt(env);
351
352 auto const& asset = debtMaximumRequest.asset();
353 auto const initialVault = asset(debtMaximumRequest * 100);
354
355 // Under featureLendingProtocolV1_1 LoanBrokerSet::preclaim
356 // only accepts closed-ended vaults, so build one and advance
357 // past SubscriptionDate before creating broker/loan.
358 auto [tx, vaultKeylet, subscriptionDate] =
359 vault.createClosedEnded({.owner = broker, .asset = asset});
360 env(tx, txFee);
361 env.close();
362
363 env(vault.deposit(
364 {.depositor = depositor, .id = vaultKeylet.key, .amount = initialVault}),
365 txFee);
366 env.close();
367
368 vault.closePastSubscription(subscriptionDate);
369
370 auto const brokerKeylet =
371 keylet::loanBroker(broker.id(), SeqProxy::rawSequence(env.seq(broker)));
372
373 env(loan_broker::set(broker, vaultKeylet.key), txFee);
374 env.close();
375
376 auto const serviceFee = 101;
377
378 env(set(broker, brokerKeylet.key, debtMaximumRequest),
379 kCounterparty(borrower),
380 Sig(sfCounterpartySignature, borrower),
381 kLoanServiceFee(serviceFee),
382 kPaymentTotal(10),
383 txFee);
384 env.close();
385
386 std::uint32_t const loanSequence = 1;
387 auto const loanKeylet =
388 keylet::loan(brokerKeylet.key, SeqProxy::rawSequence(loanSequence));
389
390 auto const brokerBalanceBefore = env.balance(broker, asset);
391
392 if (auto const loanSle = env.le(loanKeylet); env.test.BEAST_EXPECT(loanSle))
393 {
394 auto const payment = loanSle->at(sfPeriodicPayment);
395 auto const totalPayment = payment + serviceFee;
396 env(loan::pay(borrower, loanKeylet.key, asset(totalPayment)), txFee);
397 env.close();
398 if (auto const vaultSle = env.le(vaultKeylet); BEAST_EXPECT(vaultSle))
399 {
400 auto const expected = [&] {
401 // The service fee is transferred to the broker if
402 // a borrower is not the broker
403 if (borrower != broker)
404 return brokerBalanceBefore.number() + serviceFee;
405 // Since a borrower is the broker, the payment is
406 // transferred to the Vault from the broker but not
407 // the service fee.
408 // If the asset is XRP then the broker pays the txFee.
409 if (asset.native())
410 return brokerBalanceBefore.number() - payment - xrpFee.number();
411 return brokerBalanceBefore.number() - payment;
412 }();
413 BEAST_EXPECT(env.balance(broker, asset).value() == asset(expected).value());
414 }
415 }
416 };
417 // Test when a borrower is the broker and is not to verify correct
418 // service fee transfer in both cases.
419 for (auto const& borrowerAcct : {broker, borrower})
420 {
421 testLoanAsset(
422 [&](Env&) -> STAmount { return STAmount{XRPAmount{200'000}}; }, borrowerAcct);
423 testLoanAsset(
424 [&](Env& env) -> STAmount {
425 auto const iou = issuer["USD"];
426 env(trust(broker, iou(1'000'000'000)));
427 env(trust(depositor, iou(1'000'000'000)));
428 env(pay(issuer, broker, iou(100'000'000)));
429 env(pay(issuer, depositor, iou(100'000'000)));
430 env.close();
431 return iou(200'000);
432 },
433 borrowerAcct);
434 testLoanAsset(
435 [&](Env& env) -> STAmount {
436 MPTTester const mpt({
437 .env = env,
438 .issuer = issuer,
439 .holders = {broker, depositor},
440 .pay = 100'000'000,
441 });
442 return mpt(200'000);
443 },
444 borrowerAcct);
445 }
446 }
447
448 void
450 {
451 testcase("RIPD-4096 - Issuer as borrower");
452
453 using namespace jtx;
454
455 Account const issuer("issuer");
456 Account const lender("lender");
457
458 BrokerParameters const brokerParams{
459 .vaultDeposit = 100'000,
460 .debtMax = 0,
461 .coverRateMin = TenthBips32{0},
462 .managementFeeRate = TenthBips16{0},
463 .coverRateLiquidation = TenthBips32{0},
464 };
465 LoanParameters const loanParams{
466 .account = lender,
467 .counter = issuer,
468 .principalRequest = Number{10000},
469 };
470
471 auto const assetType = AssetType::IOU;
472
473 Env env{*this, features};
474
475 auto loanResult =
476 createLoan(env, assetType, brokerParams, loanParams, issuer, lender, issuer);
477
478 if (BEAST_EXPECT(loanResult); !loanResult.has_value())
479 return;
480
481 auto const broker = std::get<BrokerInfo>(*loanResult);
482 auto const loanKeylet = std::get<Keylet>(*loanResult);
483 auto const pseudoAcct = std::get<Account>(*loanResult);
484
485 VerifyLoanStatus const verifyLoanStatus(env, broker, pseudoAcct, loanKeylet);
486
488 env,
489 broker,
490 loanParams,
491 loanKeylet,
492 verifyLoanStatus,
493 issuer,
494 lender,
495 issuer,
496 PaymentParameters{.showStepBalances = true});
497 }
498
499 void
501 {
502 // From FIND-001
503 testcase << "Batch Bypass Counterparty";
504
505 bool const lendingBatchEnabled = features[featureLendingProtocolV1_2];
506
507 using namespace jtx;
508 using namespace std::chrono_literals;
509 Env env(*this, features);
510
511 Account const lender{"lender"};
512 Account const borrower{"borrower"};
513
514 BrokerParameters const brokerParams;
515 env.fund(XRP(brokerParams.vaultDeposit * 100), lender, borrower);
516 env.close();
517
518 PrettyAsset const xrpAsset{xrpIssue(), 1'000'000};
519
520 BrokerInfo const broker{createVaultAndBroker(env, xrpAsset, lender, brokerParams)};
521
522 using namespace loan;
523
524 auto const loanSetFee = Fee(env.current()->fees().base * 2);
525 Number const principalRequest{1, 3};
526
527 auto forgedLoanSet = set(borrower, broker.brokerID, principalRequest, 0);
528
530 randomData[jss::SigningPubKey] = json::StaticString{"2600"};
532 sigObject[jss::SigningPubKey] = strHex(lender.pk().slice());
533 Serializer ss;
535 parse(randomData).addWithoutSigningFields(ss);
536 auto const sig = xrpl::sign(borrower.pk(), borrower.sk(), ss.slice());
537 sigObject[jss::TxnSignature] = strHex(Slice{sig.data(), sig.size()});
538
539 forgedLoanSet[json::StaticString{"CounterpartySignature"}] = sigObject;
540
541 // ? Fails because the lender hasn't signed the tx
542 env(env.json(forgedLoanSet, Fee(loanSetFee)), Ter(telENV_RPC_FAILED));
543
544 auto const seq = env.seq(borrower);
545 auto const batchFee = batch::calcBatchFee(env, 1, 2);
546 // ! Should fail because the lender hasn't signed the tx
547 env(batch::outer(borrower, seq, batchFee, tfAllOrNothing),
548 batch::Inner(forgedLoanSet, seq + 1),
549 batch::Inner(pay(borrower, lender, XRP(1)), seq + 2),
550 Ter(lendingBatchEnabled ? temBAD_SIGNATURE : temINVALID_INNER_BATCH));
551 env.close();
552
553 // ? Check that the loan was NOT created
554 {
556 params[jss::account] = borrower.human();
557 params[jss::type] = "Loan";
558 auto const res = env.rpc("json", "account_objects", to_string(params));
559 auto const objects = res[jss::result][jss::account_objects];
560 BEAST_EXPECT(objects.size() == 0);
561 }
562 }
563
564 // Integration test: full lifecycle of a $1B loan in the bug regime.
565 // Verifies that the vault collects the economically-correct interest
566 // income and that conservation holds at the trust-line level.
567 //
568 // Pre-fix (closed-form `power(1+r, n) - 1`): vault collected only
569 // ~$0.058 per $1B due to cancellation of `(1+r)^n - 1` at r*n ~ 5.7e-10.
570 // Post-fix (hybrid binomial path): vault collects ~$0.38 per $1B,
571 // matching the value computed independently with arbitrary-precision
572 // Decimal arithmetic.
573 void
575 {
576 testcase("integration: full loan lifecycle, vault interest at near-zero rate");
577
578 using namespace jtx;
579 using namespace jtx::loan;
580 using namespace std::chrono_literals;
581 Env env(*this, all_);
582
583 Account const issuer{"issuer"};
584 Account const lender{"lender"};
585 Account const borrower{"borrower"};
586
587 env.fund(XRP(1'000'000), issuer, lender, borrower);
588 env.close();
589 env(fset(issuer, asfDefaultRipple));
590 env.close();
591
592 PrettyAsset const iouAsset = issuer["USD"];
593 STAmount const trustLimit{iouAsset.raw(), Number{1, 17}};
594 env(trust(lender, trustLimit));
595 env(trust(borrower, trustLimit));
596 env.close();
597 env(pay(issuer, lender, iouAsset(5'000'000'000LL)));
598 env(pay(issuer, borrower, iouAsset(5'000'000'000LL)));
599 env.close();
600
601 auto const usdBalance = [&](Account const& a) {
602 return env.balance(a, iouAsset.raw().get<Issue>()).value();
603 };
604 STAmount const borrowerStartBal = usdBalance(borrower);
605
606 BrokerParameters const brokerParams{
607 .vaultDeposit = Number{2, 9},
608 .debtMax = Number{0},
609 .coverRateMin = TenthBips32{0},
610 .coverDeposit = 0,
611 .managementFeeRate = TenthBips16{0},
612 .coverRateLiquidation = TenthBips32{0},
613 };
614 BrokerInfo const broker{createVaultAndBroker(env, iouAsset, lender, brokerParams)};
615
616 auto const vaultBefore = env.le(broker.vaultKeylet());
617 if (!BEAST_EXPECT(vaultBefore))
618 return;
619 Number const vaultAvailableBefore = vaultBefore->at(sfAssetsAvailable);
620
621 // Loan: $1B principal, 3 payments, 600s interval, rate=1 TenthBips32.
622 auto const loanSetFee = Fee(env.current()->fees().base * 2);
623 Number const principalRequest{1, 9};
624 auto createJson = env.json(
625 set(borrower, broker.brokerID, principalRequest),
626 Fee(loanSetFee),
627 Json(sfCounterpartySignature, json::ValueType::Object));
628 createJson["InterestRate"] = 1;
629 createJson["PaymentTotal"] = 3;
630 createJson["PaymentInterval"] = 600;
631
632 auto const loanKeylet = nextLoanKeylet(env, broker);
633 createJson = env.json(createJson, Sig(sfCounterpartySignature, lender));
634 env(createJson, Ter(tesSUCCESS));
635 env.close();
636
637 auto const loanSle = env.le(loanKeylet);
638 if (!BEAST_EXPECT(loanSle))
639 return;
640 Number const expectedTotalInterest =
641 loanSle->at(sfTotalValueOutstanding) - loanSle->at(sfPrincipalOutstanding);
642
643 env(pay(borrower, loanKeylet.key, iouAsset(1'500'000'000LL)), Ter(tesSUCCESS));
644 env.close();
645
646 auto const vaultAfter = env.le(broker.vaultKeylet());
647 if (!BEAST_EXPECT(vaultAfter))
648 return;
649 Number const vaultAvailableAfter = vaultAfter->at(sfAssetsAvailable);
650 Number const vaultGain = vaultAvailableAfter - vaultAvailableBefore;
651
652 STAmount const borrowerEndBal = usdBalance(borrower);
653 STAmount const borrowerNetOut = borrowerStartBal - borrowerEndBal;
654
655 // Self-consistency: vault gained exactly the expected interest
656 // computed at LoanSet, and the borrower's outflow matches.
657 BEAST_EXPECT(vaultGain == expectedTotalInterest);
658 BEAST_EXPECT(Number(borrowerNetOut) == expectedTotalInterest);
659
660 // Mathematical correctness: the total interest for this loan
661 // configuration is 0.38051750382930729983, calculated
662 // independently using 50-digit Decimal arithmetic (no
663 // cancellation possible at that precision). At Number's 19-digit
664 // mantissa this rounds to 0.38051750382930729 — the literal
665 // below. The vault's actual gain must agree to within
666 // sub-microcent precision.
667 Number const decimalReference{38051750382930729LL, -17};
668 Number const tolerance{1, -6}; // 1e-6 USD = sub-microcent
669 Number const error = abs(vaultGain - decimalReference);
670 BEAST_EXPECTS(
671 error < tolerance,
672 "vault gain " + to_string(vaultGain) + " differs from Decimal reference " +
673 to_string(decimalReference) + " by " + to_string(error) + " — exceeds tolerance " +
674 to_string(tolerance));
675 }
676
677 void
684
685 // Tests run under each entry in amendmentCombinations().
686 void
688 {
689 testLifecycle(features);
690 testSelfLoan(features);
691 testIssuerIsBorrower(features);
693 }
694
695public:
696 void
697 run() override
698 {
700 for (auto const& features : jtx::amendmentCombinations(
701 {fixCleanup3_1_3, fixCleanup3_2_0, featureMPTokensV2}, all_))
702 runAmendmentSensitive(features);
703 }
704};
705
706BEAST_DEFINE_TESTSUITE(LoanLifecycle, tx, xrpl);
707
708} // namespace xrpl::test
TestcaseT testcase
Memberspace for declaring test cases.
Definition suite.h:155
Lightweight wrapper to tag static string.
Definition json_value.h:52
Represents a JSON value.
Definition json_value.h:121
constexpr TIss const & get() const
A currency issued by an account.
Definition Issue.h:18
Number is a floating point type that can represent a wide range of values.
Definition Number.h:351
Slice slice() const noexcept
Definition PublicKey.h:115
Asset const & asset() const
Definition STAmount.h:496
static constexpr SeqProxy rawSequence(std::uint32_t v)
Factory function to return a sequence-based SeqProxy.
Definition SeqProxy.h:62
Slice slice() const noexcept
Definition Serializer.h:141
An immutable linear range of bytes.
Definition Slice.h:28
void runAmendmentSensitive(FeatureBitset features)
void testBatchBypassCounterparty(FeatureBitset features)
void testSelfLoan(FeatureBitset features)
void testIssuerIsBorrower(FeatureBitset features)
void run() override
Runs the suite.
void testLifecycle(FeatureBitset features)
Shared base for the Loan*_test family under src/test/app/lending/.
void testCaseWrapper(jtx::Env &env, jtx::MPTTester &mptt, std::array< TAsset, NAsset > const &assets, BrokerInfo const &broker, Number const &loanAmount, int interestExponent)
Wrapper to run a series of lifecycle tests for a given asset and loan amount.
FeatureBitset const all_
BrokerInfo createVaultAndBroker(jtx::Env &env, jtx::PrettyAsset const &asset, jtx::Account const &lender, BrokerParameters const &params=BrokerParameters::defaults())
Keylet nextLoanKeylet(jtx::Env const &env, BrokerInfo const &broker)
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)
std::string const iouCurrency_
Immutable cryptographic account descriptor.
Definition jtx/Account.h:21
SecretKey const & sk() const
Return the secret key.
Definition jtx/Account.h:93
std::string const & human() const
Returns the human readable public key.
PublicKey const & pk() const
Return the public key.
Definition jtx/Account.h:84
AccountID id() const
Returns the Account ID.
A transaction testing environment.
Definition Env.h:161
bool close(NetClock::time_point closeTime, std::optional< std::chrono::milliseconds > consensusDelay=std::nullopt)
Close and advance the ledger.
Definition Env.cpp:133
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
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
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
Adds an inner Batch transaction to a JTx and autofills it.
Definition batch.h:91
T emplace_back(T... args)
@ Object
object value (collection of name/value pairs).
Definition json_value.h:33
Keylet mptoken(MPTID const &issuanceID, AccountID const &holder) noexcept
Definition Indexes.cpp:547
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 outer(jtx::Account const &account, uint32_t seq, STAmount const &fee, std::uint32_t flags)
Build an outer Batch transaction JSON object.
Definition batch.cpp:55
XRPAmount calcBatchFee(jtx::Env const &env, uint32_t const &numSigners, uint32_t const &txns=0)
Calculate the expected outer Batch transaction fee.
Definition batch.cpp:37
json::Value set(AccountID const &account, UInt256 const &vaultId, uint32_t flags)
json::Value coverWithdraw(AccountID const &account, UInt256 const &brokerID, STAmount const &amount, uint32_t flags)
json::Value del(AccountID const &account, UInt256 const &brokerID, 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
XRPAmount txFee(Env const &env, std::uint16_t n)
std::array< Account, 1+sizeof...(Args)> noripple(Account const &account, Args const &... args)
Designate accounts as no-ripple in Env::fund.
Definition Env.h:86
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
@ 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
std::string strHex(FwdIt begin, FwdIt end)
Definition strHex.h:13
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
constexpr Number abs(Number x) noexcept
Definition Number.h:880
@ TxSign
inner transaction to sign
Definition HashPrefix.h:64
@ temBAD_SIGNATURE
Definition TER.h:93
@ temINVALID_INNER_BATCH
Definition TER.h:131
@ temBAD_SIGNER
Definition TER.h:103
Buffer sign(PublicKey const &pk, SecretKey const &sk, Slice const &message)
Generate a signature for a message.
@ tesSUCCESS
Definition TER.h:253
T parse(T... args)
T reserve(T... args)
T size(T... args)
Helper class to compare the expected state of a loan and loan broker against the data in the ledger.
STAmount const & value() const