xrpld
Loading...
Searching...
No Matches
LoanSet_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/mpt.h>
9#include <test/jtx/multisign.h>
10#include <test/jtx/noop.h>
11#include <test/jtx/pay.h>
12#include <test/jtx/trust.h>
13#include <test/jtx/vault.h>
14
15#include <xrpl/basics/Number.h>
16#include <xrpl/basics/chrono.h>
17#include <xrpl/beast/unit_test/suite.h>
18#include <xrpl/beast/utility/Zero.h>
19#include <xrpl/json/json_value.h>
20#include <xrpl/ledger/helpers/LendingHelpers.h>
21#include <xrpl/protocol/Feature.h>
22#include <xrpl/protocol/Indexes.h>
23#include <xrpl/protocol/Issue.h>
24#include <xrpl/protocol/LedgerFormats.h>
25#include <xrpl/protocol/Protocol.h>
26#include <xrpl/protocol/SField.h>
27#include <xrpl/protocol/STAmount.h>
28#include <xrpl/protocol/SeqProxy.h>
29#include <xrpl/protocol/TER.h>
30#include <xrpl/protocol/TxFlags.h>
31#include <xrpl/protocol/Units.h>
32#include <xrpl/protocol/XRPAmount.h>
33#include <xrpl/tx/transactors/lending/LoanSet.h>
34
35#include <array>
36#include <cstdint>
37#include <functional>
38#include <string>
39#include <utility>
40#include <vector>
41
42namespace xrpl::test {
43
45{
46private:
47 void
49 {
50 using namespace jtx;
51
52 Account const issuer{"issuer"};
53 Account const lender{"lender"};
54 Account const borrower{"borrower"};
55
56 struct CaseArgs
57 {
58 bool requireAuth = false;
59 bool authorizeBorrower = false;
60 int initialXRP = 1'000'000;
61 };
62
63 auto const testCase = [&, this](
64 std::function<void(Env&, BrokerInfo const&, MPTTester&)> mptTest,
65 std::function<void(Env&, BrokerInfo const&)> iouTest,
66 CaseArgs args = {}) {
67 Env env(*this, features);
68 env.fund(XRP(args.initialXRP), issuer, lender, borrower);
69 env.close();
70 if (args.requireAuth)
71 {
72 env(fset(issuer, asfRequireAuth));
73 env.close();
74 }
75
76 // We need two different asset types, MPT and IOU. Prepare MPT
77 // first
78 MPTTester mptt{env, issuer, kMptInitNoFund};
79
80 auto const kNone = LedgerSpecificFlags(0);
81 mptt.create({
82 .flags =
83 tfMPTCanTransfer | tfMPTCanLock | (args.requireAuth ? tfMPTRequireAuth : kNone),
84 });
85 env.close();
86 PrettyAsset const mptAsset = mptt.issuanceID();
87 mptt.authorize({.account = lender});
88 mptt.authorize({.account = borrower});
89 env.close();
90 if (args.requireAuth)
91 {
92 mptt.authorize({.account = issuer, .holder = lender});
93 if (args.authorizeBorrower)
94 mptt.authorize({.account = issuer, .holder = borrower});
95 env.close();
96 }
97
98 env(pay(issuer, lender, mptAsset(10'000'000)));
99 env.close();
100
101 // Prepare IOU
102 PrettyAsset const iouAsset = issuer[iouCurrency_];
103 env(trust(lender, iouAsset(10'000'000)));
104 env(trust(borrower, iouAsset(10'000'000)));
105 env.close();
106 if (args.requireAuth)
107 {
108 env(trust(issuer, iouAsset(0), lender, tfSetfAuth));
109 env(pay(issuer, lender, iouAsset(10'000'000)));
110 if (args.authorizeBorrower)
111 {
112 env(trust(issuer, iouAsset(0), borrower, tfSetfAuth));
113 env(pay(issuer, borrower, iouAsset(10'000)));
114 }
115 }
116 else
117 {
118 env(pay(issuer, lender, iouAsset(10'000'000)));
119 env(pay(issuer, borrower, iouAsset(10'000)));
120 }
121 env.close();
122
123 // Create vaults and loan brokers
124 std::array const assets{mptAsset, iouAsset};
126 brokers.reserve(assets.size());
127 for (auto const& asset : assets)
128 {
129 brokers.emplace_back(createVaultAndBroker(env, asset, lender));
130 }
131
132 if (mptTest)
133 mptTest(env, brokers[0], mptt);
134 if (iouTest)
135 iouTest(env, brokers[1]);
136 };
137
138 testCase(
139 [&, this](Env& env, BrokerInfo const& broker, auto&) {
140 using namespace loan;
141 Number const principalRequest = broker.asset(1'000).value();
142
143 testcase("MPT issuer is borrower, issuer submits");
144 env(set(issuer, broker.brokerID, principalRequest),
145 kCounterparty(lender),
146 Sig(sfCounterpartySignature, lender),
147 Fee(env.current()->fees().base * 5));
148
149 testcase("MPT issuer is borrower, lender submits");
150 env(set(lender, broker.brokerID, principalRequest),
151 kCounterparty(issuer),
152 Sig(sfCounterpartySignature, issuer),
153 Fee(env.current()->fees().base * 5));
154 },
155 [&, this](Env& env, BrokerInfo const& broker) {
156 using namespace loan;
157 Number const principalRequest = broker.asset(1'000).value();
158
159 testcase("IOU issuer is borrower, issuer submits");
160 env(set(issuer, broker.brokerID, principalRequest),
161 kCounterparty(lender),
162 Sig(sfCounterpartySignature, lender),
163 Fee(env.current()->fees().base * 5));
164
165 testcase("IOU issuer is borrower, lender submits");
166 env(set(lender, broker.brokerID, principalRequest),
167 kCounterparty(issuer),
168 Sig(sfCounterpartySignature, issuer),
169 Fee(env.current()->fees().base * 5));
170 },
171 CaseArgs{.requireAuth = true});
172
173 testCase(
174 [&, this](Env& env, BrokerInfo const& broker, auto&) {
175 using namespace loan;
176 Number const principalRequest = broker.asset(1'000).value();
177
178 testcase("MPT unauthorized borrower, borrower submits");
179 env(set(borrower, broker.brokerID, principalRequest),
180 kCounterparty(lender),
181 Sig(sfCounterpartySignature, lender),
182 Fee(env.current()->fees().base * 5),
183 Ter{tecNO_AUTH});
184
185 testcase("MPT unauthorized borrower, lender submits");
186 env(set(lender, broker.brokerID, principalRequest),
187 kCounterparty(borrower),
188 Sig(sfCounterpartySignature, borrower),
189 Fee(env.current()->fees().base * 5),
190 Ter{tecNO_AUTH});
191 },
192 [&, this](Env& env, BrokerInfo const& broker) {
193 using namespace loan;
194 Number const principalRequest = broker.asset(1'000).value();
195
196 testcase("IOU unauthorized borrower, borrower submits");
197 env(set(borrower, broker.brokerID, principalRequest),
198 kCounterparty(lender),
199 Sig(sfCounterpartySignature, lender),
200 Fee(env.current()->fees().base * 5),
201 Ter{tecNO_AUTH});
202
203 testcase("IOU unauthorized borrower, lender submits");
204 env(set(lender, broker.brokerID, principalRequest),
205 kCounterparty(borrower),
206 Sig(sfCounterpartySignature, borrower),
207 Fee(env.current()->fees().base * 5),
208 Ter{tecNO_AUTH});
209 },
210 CaseArgs{.requireAuth = true});
211
212 auto const [acctReserve, incReserve] = [this] -> std::pair<int, int> {
213 Env const env{*this, testableAmendments()};
214 return {
215 env.current()->fees().accountReserve(0, 1).drops() / kDropsPerXrp.drops(),
216 env.current()->fees().increment.drops() / kDropsPerXrp.drops()};
217 }();
218
219 testCase(
220 [&, this](Env& env, BrokerInfo const& broker, MPTTester& mptt) {
221 using namespace loan;
222 Number const principalRequest = broker.asset(1'000).value();
223
224 testcase(
225 "MPT authorized borrower, borrower submits, borrower has "
226 "no reserve");
227 mptt.authorize({.account = borrower, .flags = tfMPTUnauthorize});
228 env.close();
229
230 auto const mptoken = keylet::mptoken(mptt.issuanceID(), borrower);
231 auto const sleMPT1 = env.le(mptoken);
232 BEAST_EXPECT(sleMPT1 == nullptr);
233
234 // Burn some XRP
235 env(noop(borrower), Fee(XRP((acctReserve * 2) + (incReserve * 2))));
236 env.close();
237
238 // Cannot create loan, not enough reserve to create MPToken
239 env(set(borrower, broker.brokerID, principalRequest),
240 kCounterparty(lender),
241 Sig(sfCounterpartySignature, lender),
242 Fee(env.current()->fees().base * 5),
243 Ter{tecINSUFFICIENT_RESERVE});
244 env.close();
245
246 // Can create loan now, will implicitly create MPToken
247 env(pay(issuer, borrower, XRP(incReserve)));
248 env.close();
249 env(set(borrower, broker.brokerID, principalRequest),
250 kCounterparty(lender),
251 Sig(sfCounterpartySignature, lender),
252 Fee(env.current()->fees().base * 5));
253 env.close();
254
255 auto const sleMPT2 = env.le(mptoken);
256 BEAST_EXPECT(sleMPT2 != nullptr);
257 },
258 {},
259 CaseArgs{.initialXRP = (acctReserve * 2) + (incReserve * 8) + 1});
260
261 testCase(
262 {},
263 [&, this](Env& env, BrokerInfo const& broker) {
264 using namespace loan;
265 Number const principalRequest = broker.asset(1'000).value();
266
267 testcase(
268 "IOU authorized borrower, borrower submits, borrower has "
269 "no reserve");
270 // Remove trust line from borrower to issuer
271 env.trust(broker.asset(0), borrower);
272 env.close();
273
274 env(pay(borrower, issuer, broker.asset(10'000)));
275 env.close();
276 auto const trustline = keylet::trustLine(borrower, broker.asset.raw().get<Issue>());
277 auto const sleLine1 = env.le(trustline);
278 BEAST_EXPECT(sleLine1 == nullptr);
279
280 // Burn some XRP
281 env(noop(borrower), Fee(XRP((acctReserve * 2) + (incReserve * 2))));
282 env.close();
283
284 // Cannot create loan, not enough reserve to create trust line
285 env(set(borrower, broker.brokerID, principalRequest),
286 kCounterparty(lender),
287 Sig(sfCounterpartySignature, lender),
288 Fee(env.current()->fees().base * 5),
289 Ter{tecNO_LINE_INSUF_RESERVE});
290 env.close();
291
292 // Can create loan now, will implicitly create trust line
293 env(pay(issuer, borrower, XRP(incReserve)));
294 env.close();
295 env(set(borrower, broker.brokerID, principalRequest),
296 kCounterparty(lender),
297 Sig(sfCounterpartySignature, lender),
298 Fee(env.current()->fees().base * 5));
299 env.close();
300
301 auto const sleLine2 = env.le(trustline);
302 BEAST_EXPECT(sleLine2 != nullptr);
303 },
304 CaseArgs{.initialXRP = (acctReserve * 2) + (incReserve * 8) + 1});
305
306 testCase(
307 [&, this](Env& env, BrokerInfo const& broker, MPTTester& mptt) {
308 using namespace loan;
309 Number const principalRequest = broker.asset(1'000).value();
310
311 testcase(
312 "MPT authorized borrower, borrower submits, lender has "
313 "no reserve");
314 auto const mptoken = keylet::mptoken(mptt.issuanceID(), lender);
315 auto const sleMPT1 = env.le(mptoken);
316 BEAST_EXPECT(sleMPT1 != nullptr);
317
318 env(pay(lender, issuer, broker.asset(sleMPT1->at(sfMPTAmount))));
319 env.close();
320
321 mptt.authorize({.account = lender, .flags = tfMPTUnauthorize});
322 env.close();
323
324 auto const sleMPT2 = env.le(mptoken);
325 BEAST_EXPECT(sleMPT2 == nullptr);
326
327 // Burn some XRP
328 env(noop(lender), Fee(XRP(incReserve)));
329 env.close();
330
331 // Cannot create loan, not enough reserve to create MPToken
332 env(set(borrower, broker.brokerID, principalRequest),
333 kLoanOriginationFee(broker.asset(1).value()),
334 kCounterparty(lender),
335 Sig(sfCounterpartySignature, lender),
336 Fee(env.current()->fees().base * 5),
337 Ter{tecINSUFFICIENT_RESERVE});
338 env.close();
339
340 // Can create loan now, will implicitly create MPToken
341 env(pay(issuer, lender, XRP(incReserve)));
342 env.close();
343 env(set(borrower, broker.brokerID, principalRequest),
344 kLoanOriginationFee(broker.asset(1).value()),
345 kCounterparty(lender),
346 Sig(sfCounterpartySignature, lender),
347 Fee(env.current()->fees().base * 5));
348 env.close();
349
350 auto const sleMPT3 = env.le(mptoken);
351 BEAST_EXPECT(sleMPT3 != nullptr);
352 },
353 {},
354 CaseArgs{.initialXRP = (acctReserve * 2) + (incReserve * 8) + 1});
355
356 testCase(
357 {},
358 [&, this](Env& env, BrokerInfo const& broker) {
359 using namespace loan;
360 Number const principalRequest = broker.asset(1'000).value();
361
362 testcase(
363 "IOU authorized borrower, borrower submits, lender has no "
364 "reserve");
365 // Remove trust line from lender to issuer
366 env.trust(broker.asset(0), lender);
367 env.close();
368
369 auto const trustline = keylet::trustLine(lender, broker.asset.raw().get<Issue>());
370 auto const sleLine1 = env.le(trustline);
371 BEAST_EXPECT(sleLine1 != nullptr);
372
373 env(pay(lender, issuer, broker.asset(abs(sleLine1->at(sfBalance).value()))));
374 env.close();
375 auto const sleLine2 = env.le(trustline);
376 BEAST_EXPECT(sleLine2 == nullptr);
377
378 // Burn some XRP
379 env(noop(lender), Fee(XRP(incReserve)));
380 env.close();
381
382 // Cannot create loan, not enough reserve to create trust line
383 env(set(borrower, broker.brokerID, principalRequest),
384 kLoanOriginationFee(broker.asset(1).value()),
385 kCounterparty(lender),
386 Sig(sfCounterpartySignature, lender),
387 Fee(env.current()->fees().base * 5),
388 Ter{tecNO_LINE_INSUF_RESERVE});
389 env.close();
390
391 // Can create loan now, will implicitly create trust line
392 env(pay(issuer, lender, XRP(incReserve)));
393 env.close();
394 env(set(borrower, broker.brokerID, principalRequest),
395 kLoanOriginationFee(broker.asset(1).value()),
396 kCounterparty(lender),
397 Sig(sfCounterpartySignature, lender),
398 Fee(env.current()->fees().base * 5));
399 env.close();
400
401 auto const sleLine3 = env.le(trustline);
402 BEAST_EXPECT(sleLine3 != nullptr);
403 },
404 CaseArgs{.initialXRP = (acctReserve * 2) + (incReserve * 8) + 1});
405
406 testCase(
407 [&, this](Env& env, BrokerInfo const& broker, MPTTester& mptt) {
408 using namespace loan;
409 Number const principalRequest = broker.asset(1'000).value();
410
411 testcase("MPT authorized borrower, unauthorized lender");
412 auto const mptoken = keylet::mptoken(mptt.issuanceID(), lender);
413 auto const sleMPT1 = env.le(mptoken);
414 BEAST_EXPECT(sleMPT1 != nullptr);
415
416 env(pay(lender, issuer, broker.asset(sleMPT1->at(sfMPTAmount))));
417 env.close();
418
419 mptt.authorize({.account = lender, .flags = tfMPTUnauthorize});
420 env.close();
421
422 auto const sleMPT2 = env.le(mptoken);
423 BEAST_EXPECT(sleMPT2 == nullptr);
424
425 // Cannot create loan, lender not authorized to receive fee
426 env(set(borrower, broker.brokerID, principalRequest),
427 kLoanOriginationFee(broker.asset(1).value()),
428 kCounterparty(lender),
429 Sig(sfCounterpartySignature, lender),
430 Fee(env.current()->fees().base * 5),
431 Ter{tecNO_AUTH});
432 env.close();
433
434 // Cannot create loan, even without an origination fee
435 env(set(borrower, broker.brokerID, principalRequest),
436 kCounterparty(lender),
437 Sig(sfCounterpartySignature, lender),
438 Fee(env.current()->fees().base * 5),
439 Ter{tecNO_AUTH});
440 env.close();
441
442 // No MPToken for lender - no authorization and no payment
443 auto const sleMPT3 = env.le(mptoken);
444 BEAST_EXPECT(sleMPT3 == nullptr);
445 },
446 {},
447 CaseArgs{.requireAuth = true, .authorizeBorrower = true});
448
449 testCase(
450 [&, this](Env& env, BrokerInfo const& broker, auto&) {
451 using namespace loan;
452 Number const principalRequest = broker.asset(1'000).value();
453
454 testcase("MPT authorized borrower, borrower submits");
455 env(set(borrower, broker.brokerID, principalRequest),
456 kCounterparty(lender),
457 Sig(sfCounterpartySignature, lender),
458 Fee(env.current()->fees().base * 5));
459 },
460 [&, this](Env& env, BrokerInfo const& broker) {
461 using namespace loan;
462 Number const principalRequest = broker.asset(1'000).value();
463
464 testcase("IOU authorized borrower, borrower submits");
465 env(set(borrower, broker.brokerID, principalRequest),
466 kCounterparty(lender),
467 Sig(sfCounterpartySignature, lender),
468 Fee(env.current()->fees().base * 5));
469 },
470 CaseArgs{.requireAuth = true, .authorizeBorrower = true});
471
472 testCase(
473 [&, this](Env& env, BrokerInfo const& broker, auto&) {
474 using namespace loan;
475 Number const principalRequest = broker.asset(1'000).value();
476
477 testcase("MPT authorized borrower, lender submits");
478 env(set(lender, broker.brokerID, principalRequest),
479 kCounterparty(borrower),
480 Sig(sfCounterpartySignature, borrower),
481 Fee(env.current()->fees().base * 5));
482 },
483 [&, this](Env& env, BrokerInfo const& broker) {
484 using namespace loan;
485 Number const principalRequest = broker.asset(1'000).value();
486
487 testcase("IOU authorized borrower, lender submits");
488 env(set(lender, broker.brokerID, principalRequest),
489 kCounterparty(borrower),
490 Sig(sfCounterpartySignature, borrower),
491 Fee(env.current()->fees().base * 5));
492 },
493 CaseArgs{.requireAuth = true, .authorizeBorrower = true});
494
495 jtx::Account const alice{"alice"};
496 jtx::Account const bella{"bella"};
497 auto const msigSetup = [&](Env& env, Account const& account) {
498 json::Value const tx1 = signers(account, 2, {{alice, 1}, {bella, 1}});
499 env(tx1);
500 env.close();
501 };
502
503 testCase(
504 [&, this](Env& env, BrokerInfo const& broker, auto&) {
505 using namespace loan;
506 msigSetup(env, lender);
507 Number const principalRequest = broker.asset(1'000).value();
508
509 testcase(
510 "MPT authorized borrower, borrower submits, lender "
511 "multisign");
512 env(set(borrower, broker.brokerID, principalRequest),
513 kCounterparty(lender),
514 Msig(sfCounterpartySignature, alice, bella),
515 Fee(env.current()->fees().base * 5));
516 },
517 [&, this](Env& env, BrokerInfo const& broker) {
518 using namespace loan;
519 msigSetup(env, lender);
520 Number const principalRequest = broker.asset(1'000).value();
521
522 testcase(
523 "IOU authorized borrower, borrower submits, lender "
524 "multisign");
525 env(set(borrower, broker.brokerID, principalRequest),
526 kCounterparty(lender),
527 Msig(sfCounterpartySignature, alice, bella),
528 Fee(env.current()->fees().base * 5));
529 },
530 CaseArgs{.requireAuth = true, .authorizeBorrower = true});
531
532 testCase(
533 [&, this](Env& env, BrokerInfo const& broker, auto&) {
534 using namespace loan;
535 msigSetup(env, borrower);
536 Number const principalRequest = broker.asset(1'000).value();
537
538 testcase(
539 "MPT authorized borrower, lender submits, borrower "
540 "multisign");
541 env(set(lender, broker.brokerID, principalRequest),
542 kCounterparty(borrower),
543 Msig(sfCounterpartySignature, alice, bella),
544 Fee(env.current()->fees().base * 5));
545 },
546 [&, this](Env& env, BrokerInfo const& broker) {
547 using namespace loan;
548 msigSetup(env, borrower);
549 Number const principalRequest = broker.asset(1'000).value();
550
551 testcase(
552 "IOU authorized borrower, lender submits, borrower "
553 "multisign");
554 env(set(lender, broker.brokerID, principalRequest),
555 kCounterparty(borrower),
556 Msig(sfCounterpartySignature, alice, bella),
557 Fee(env.current()->fees().base * 5));
558 },
559 CaseArgs{.requireAuth = true, .authorizeBorrower = true});
560
561 testCase(
562 [&, this](Env& env, BrokerInfo const& broker, auto&) {
563 using namespace loan;
564 Number const principalRequest = broker.asset(1'000).value();
565 Vault const vault{env};
566 auto tx = vault.set({.owner = lender, .id = broker.vaultID});
567 tx[sfAssetsMaximum] = BrokerParameters::defaults().vaultDeposit;
568 env(tx);
569 env.close();
570
571 testcase("Vault at maximum value");
572 env(set(issuer, broker.brokerID, principalRequest),
573 kCounterparty(lender),
574 kInterestRate(TenthBips32(10'000)),
575 Sig(sfCounterpartySignature, lender),
576 Fee(env.current()->fees().base * 5),
578 },
579 nullptr);
580
581 testCase(
582 [&, this](Env& env, BrokerInfo const& broker, auto&) {
583 using namespace loan;
584 Number const principalRequest = broker.asset(1'000).value();
585 Vault const vault{env};
586 auto tx = vault.set({.owner = lender, .id = broker.vaultID});
587 tx[sfAssetsMaximum] =
588 BrokerParameters::defaults().vaultDeposit + broker.asset(1).number();
589 env(tx);
590 env.close();
591
592 testcase("Vault maximum value exceeded");
593 env(set(issuer, broker.brokerID, principalRequest),
594 kCounterparty(lender),
595 kInterestRate(TenthBips32(100'000)),
596 Sig(sfCounterpartySignature, lender),
597 Fee(env.current()->fees().base * 5),
598 kPaymentTotal(2),
599 kPaymentInterval(3600 * 24),
601 },
602 nullptr);
603 }
604
605 void
607 {
608 using namespace jtx;
609 using namespace loan;
610
611 bool const fix340Enabled = features[fixCleanup3_4_0];
612 testcase << "LoanSet: borrower and broker owner missing MPToken"
613 << (fix340Enabled ? "" : " pre-fixCleanup3_4_0");
614
615 Account const issuer{"issuer"};
616 Account const lender{"lender"};
617 Account const borrower{"borrower"};
618
619 Env env(*this, features);
620 env.fund(XRP(1'000'000), issuer, lender, borrower);
621 env.close();
622
623 MPTTester mptt{env, issuer, kMptInitNoFund};
624 mptt.create({.flags = tfMPTCanTransfer | tfMPTCanLock});
625 env.close();
626 PrettyAsset const asset = mptt.issuanceID();
627 mptt.authorize({.account = lender});
628 mptt.authorize({.account = borrower});
629 env.close();
630
631 env(pay(issuer, lender, asset(10'000'000)));
632 env.close();
633
634 auto const broker = createVaultAndBroker(env, asset, lender);
635
636 // Delete borrower's asset MPToken.
637 mptt.authorize({.account = borrower, .flags = tfMPTUnauthorize});
638 env.close();
639
640 // Pay out and delete the broker owner's asset MPToken.
641 auto const lenderMPToken = keylet::mptoken(mptt.issuanceID(), lender);
642 auto const sleLenderMPT = env.le(lenderMPToken);
643 if (!BEAST_EXPECT(sleLenderMPT))
644 return;
645 env(pay(lender, issuer, asset(sleLenderMPT->at(sfMPTAmount))));
646 env.close();
647 mptt.authorize({.account = lender, .flags = tfMPTUnauthorize});
648 env.close();
649
650 auto const borrowerMPToken = keylet::mptoken(mptt.issuanceID(), borrower);
651 auto const brokerKeylet = keylet::loanBroker(broker.brokerID);
652 auto const sleBrokerBefore = env.le(brokerKeylet);
653 if (!BEAST_EXPECT(sleBrokerBefore))
654 return;
655 auto const loanSequence = sleBrokerBefore->at(sfLoanSequence);
656 auto const debtTotalBefore = sleBrokerBefore->at(sfDebtTotal);
657 auto const loanKeylet = keylet::loan(broker.brokerID, SeqProxy::rawSequence(loanSequence));
658
659 auto const sleVaultBefore = env.le(keylet::vault(broker.vaultID));
660 if (!BEAST_EXPECT(sleVaultBefore))
661 return;
662 auto const assetsAvailableBefore = sleVaultBefore->at(sfAssetsAvailable);
663
664 env(set(borrower, broker.brokerID, asset(1'000).value()),
665 kLoanOriginationFee(asset(1).value()),
666 kCounterparty(lender),
667 Sig(sfCounterpartySignature, lender),
668 Fee(env.current()->fees().base * 5),
669 Ter{fix340Enabled ? TER{tesSUCCESS} : TER{tecINVARIANT_FAILED}});
670 env.close();
671
672 auto const sleBorrowerAfter = env.le(borrowerMPToken);
673 auto const sleLenderAfter = env.le(lenderMPToken);
674 auto const sleLoanAfter = env.le(loanKeylet);
675 auto const sleBrokerAfter = env.le(brokerKeylet);
676 auto const sleVaultAfter = env.le(keylet::vault(broker.vaultID));
677 if (!BEAST_EXPECT(sleVaultAfter))
678 return;
679 if (fix340Enabled)
680 {
681 if (!BEAST_EXPECT(sleBorrowerAfter && sleLenderAfter && sleLoanAfter && sleBrokerAfter))
682 return;
683 BEAST_EXPECT(sleBorrowerAfter->at(sfMPTAmount) == 999);
684 BEAST_EXPECT(sleLenderAfter->at(sfMPTAmount) == 1);
685 BEAST_EXPECT(sleLoanAfter->at(sfPrincipalOutstanding) == Number{1'000});
686 BEAST_EXPECT(sleBrokerAfter->at(sfLoanSequence) == loanSequence + 1);
687 BEAST_EXPECT(
688 sleVaultAfter->at(sfAssetsAvailable) == assetsAvailableBefore - Number{1'000});
689 }
690 else
691 {
692 // The whole transaction must roll back.
693 BEAST_EXPECT(!sleBorrowerAfter);
694 BEAST_EXPECT(!sleLenderAfter);
695 BEAST_EXPECT(!sleLoanAfter);
696 if (!BEAST_EXPECT(sleBrokerAfter))
697 return;
698 BEAST_EXPECT(sleBrokerAfter->at(sfLoanSequence) == loanSequence);
699 BEAST_EXPECT(sleBrokerAfter->at(sfDebtTotal) == debtTotalBefore);
700 BEAST_EXPECT(sleVaultAfter->at(sfAssetsAvailable) == assetsAvailableBefore);
701 }
702 }
703
704 // Regression test: a Legacy Vault's broker DebtTotal must be rounded at
705 // the Vault scale captured *before* this origination's AssetsTotal
706 // update, not after. Origination credits AssetsTotal with the loan's
707 // InterestDue; when AssetsTotal is already at its 16-digit precision
708 // limit, adding InterestDue can carry into a new integer digit, which
709 // forces the stored value to drop a decimal digit to stay within 16
710 // significant digits (e.g. 999999.9999999999 at 10 decimal places plus
711 // a positive InterestDue becomes a value with only 9 decimal places).
712 // If DebtTotal were rounded at that *new*, coarser scale instead of the
713 // scale the Vault had before this transaction, it would disagree with
714 // develop by a unit of the old grid. This test deliberately engineers
715 // that crossing and checks DebtTotal against the pre-update scale.
716 void
718 {
719 using namespace jtx;
720 using namespace loan;
721
722 testcase("LoanSet: Legacy broker DebtTotal rounds at pre-update Vault scale");
723
724 Account const issuer{"issuer"};
725 Account const lender{"lender"};
726 Account const borrower{"borrower"};
727
728 // 999999.9999 is just below 1,000,000; an IOU STAmount this close to
729 // a power of ten always canonicalizes to a 16-digit mantissa at
730 // exponent -10, so adding any positive InterestDue forces
731 // AssetsTotal's integer part to grow past 1,000,000 and its stored
732 // scale to drop.
733 BrokerParameters const brokerParams{
734 .vaultDeposit = Number{9'999'999'999LL, -4},
735 .debtMax = 0,
736 .coverRateMin = TenthBips32{0},
737 .managementFeeRate = TenthBips16{0},
738 .coverRateLiquidation = TenthBips32{0},
739 };
740 LoanParameters const loanParams{
741 .account = borrower,
742 .counter = lender,
743 .principalRequest = Number{1'000},
744 .interest = TenthBips32{percentageToTenthBips(10)},
745 .payTotal = std::uint32_t{1},
746 .payInterval = std::uint32_t{30 * 24 * 60 * 60},
747 };
748
749 Env env{*this, all_};
750
751 auto const assetsTotalBefore = brokerParams.vaultDeposit;
752 auto const scaleBefore = scale(assetsTotalBefore, Asset{issuer["IOU"]});
753 // scale() returns the STAmount exponent, which is negative for a
754 // fractional value; -10 means 10 digits after the decimal point.
755 BEAST_EXPECT(scaleBefore == -10);
756
757 auto loanResult =
758 createLoan(env, AssetType::IOU, brokerParams, loanParams, issuer, lender, borrower);
759 if (!BEAST_EXPECT(loanResult.has_value()) || !loanResult)
760 return;
761 auto const& [broker, loanKeylet, pseudoAcct] = *loanResult;
762
763 auto const vaultSle = env.le(broker.vaultKeylet());
764 auto const brokerSle = env.le(broker.brokerKeylet());
765 auto const loanSle = env.le(loanKeylet);
766 if (!BEAST_EXPECT(vaultSle && brokerSle && loanSle))
767 return;
768
769 Number const assetsTotalAfter = vaultSle->at(sfAssetsTotal);
770 auto const scaleAfter = scale(assetsTotalAfter, broker.asset.raw());
771 // The crossing actually happened: AssetsTotal's stored scale got
772 // coarser (its exponent moved toward zero, e.g. -10 -> -9), which is
773 // the precondition for this regression to be meaningful.
774 BEAST_EXPECT(assetsTotalAfter > Number{1'000'000});
775 BEAST_EXPECT(scaleAfter > scaleBefore);
776
777 // sfTotalValueOutstanding is stored at full precision (it is not
778 // rounded to the vault's asset scale), so it carries the exact
779 // interestDue the production code added to AssetsTotal -- unlike
780 // reading AssetsTotal back and subtracting, which would already have
781 // lost precision to the very rounding this test is checking.
782 Number const totalValueOutstanding = loanSle->at(sfTotalValueOutstanding);
783 Number const debtTotalDelta = totalValueOutstanding;
784 BEAST_EXPECT(debtTotalDelta > loanParams.principalRequest);
785
786 Number const expectedAtPreUpdateScale =
787 roundToAsset(broker.asset.raw(), debtTotalDelta, scaleBefore);
788 Number const wouldBeAtPostUpdateScale =
789 roundToAsset(broker.asset.raw(), debtTotalDelta, scaleAfter);
790
791 // The two roundings must actually disagree, or this test would pass
792 // even with the bug (reading the scale after the AssetsTotal update)
793 // reinstated.
794 BEAST_EXPECT(expectedAtPreUpdateScale != wouldBeAtPostUpdateScale);
795 BEAST_EXPECT(brokerSle->at(sfDebtTotal) == expectedAtPreUpdateScale);
796 }
797
798 // LoanSet in a closed-ended vault — phase gating and maturity bound.
799 void
801 {
802 testcase("LoanSet closed-ended: phase and maturity bound");
803 using namespace jtx;
804 using namespace loan;
805 using D = NetClock::duration;
806 using Tp = NetClock::time_point;
807
808 Account const issuer{"issuer"};
809 Account const lender{"lender"};
810 Account const borrower{"borrower"};
811
812 // Common loan schedule used by the phase-rejection cases below.
813 constexpr std::uint32_t kInterval = 3600u * 24u; // 1 day
814 constexpr std::uint32_t kTotal = 2u;
815
816 // featureLendingProtocolV1_1 is excluded from `all_` by convention (see the comment on
817 // `all_`), so callers must opt in. Closed-ended vaults are gated on this amendment; without
818 // it VaultCreate returns temDISABLED and every follow-on txn sees tecNO_ENTRY.
819 auto const withEnv = [&, this](auto&& body) {
820 Env env(*this, testableAmendments() | featureLendingProtocolV1_1);
821 env.fund(XRP(1'000'000'000), issuer, lender, borrower);
822 env.close();
823 PrettyAsset const asset{xrpIssue(), 1'000'000};
824 body(env, asset);
825 };
826
827 auto const setLoan = [&](Env& env, BrokerInfo const& broker, TER expected) {
828 env(set(lender, broker.brokerID, broker.asset(100).value()),
829 kCounterparty(borrower),
830 Sig(sfCounterpartySignature, borrower),
831 Fee(env.current()->fees().base * 5),
832 kPaymentTotal(kTotal),
833 kPaymentInterval(kInterval),
834 Ter(expected));
835 env.close();
836 };
837
838 // 1. Rejected during Subscription: the broker is created in Subscription (skipPhaseAdvance
839 // = true), then LoanSet is attempted before advancing past SubscriptionDate.
840 withEnv([&](Env& env, PrettyAsset const& asset) {
841 auto const broker = createVaultAndBroker(
842 env,
843 asset,
844 lender,
845 BrokerParameters{.vaultKind = VaultKind::ClosedEnded, .skipPhaseAdvance = true});
846 setLoan(env, broker, tecTOO_SOON);
847 });
848
849 // 2. Rejected during Redemption: broker is set up normally (which lands the vault in
850 // Investment), then advance the clock past RedemptionDate before attempting LoanSet.
851 withEnv([&](Env& env, PrettyAsset const& asset) {
852 auto const broker = createVaultAndBroker(
853 env, asset, lender, BrokerParameters{.vaultKind = VaultKind::ClosedEnded});
854 BEAST_EXPECT(broker.redemptionDate.has_value());
855 using D = NetClock::duration;
856 using Tp = NetClock::time_point;
857 env.close(Tp{D{*broker.redemptionDate + 1}});
858 setLoan(env, broker, tecEXPIRED);
859 });
860
861 // 3. Accepted during Investment when the schedule comfortably fits before RedemptionDate.
862 withEnv([&](Env& env, PrettyAsset const& asset) {
863 auto const broker = createVaultAndBroker(
864 env, asset, lender, BrokerParameters{.vaultKind = VaultKind::ClosedEnded});
865 setLoan(env, broker, tesSUCCESS);
866 });
867
868 // 4. Rejected during Investment when the loan's final payment would land fewer than
869 // kLoanRedemptionBuffer seconds before RedemptionDate. Use a tight redemptionOffset and a
870 // schedule whose final payment is well past that boundary.
871 withEnv([&](Env& env, PrettyAsset const& asset) {
872 constexpr std::uint32_t kRedemptionOffset = 3u * 24u * 3600u;
873 auto const broker = createVaultAndBroker(
874 env,
875 asset,
876 lender,
878 .vaultKind = VaultKind::ClosedEnded,
879 .redemptionOffset = kRedemptionOffset,
880 });
881 env(set(lender, broker.brokerID, broker.asset(100).value()),
882 kCounterparty(borrower),
883 Sig(sfCounterpartySignature, borrower),
884 Fee(env.current()->fees().base * 5),
885 kPaymentTotal(10u),
886 kPaymentInterval(kInterval),
888 env.close();
889 });
890
891 // 5. Boundary: a finalPayment exactly kLoanRedemptionBuffer seconds before
892 // RedemptionDate is accepted; one second later is rejected. Uses payTotal = 1 so
893 // finalPayment = startDate + interval.
894 withEnv([&](Env& env, PrettyAsset const& asset) {
895 auto const broker = createVaultAndBroker(
896 env, asset, lender, BrokerParameters{.vaultKind = VaultKind::ClosedEnded});
897 BEAST_EXPECT(broker.redemptionDate.has_value());
898
899 auto const startDate = env.now().time_since_epoch().count();
900 auto const acceptInterval = *broker.redemptionDate - kLoanRedemptionBuffer - startDate;
901 env(set(lender, broker.brokerID, broker.asset(100).value()),
902 kCounterparty(borrower),
903 Sig(sfCounterpartySignature, borrower),
904 Fee(env.current()->fees().base * 5),
905 kPaymentTotal(1u),
906 kPaymentInterval(acceptInterval),
907 Ter(tesSUCCESS));
908 env.close();
909
910 auto const rejectInterval = *broker.redemptionDate - (kLoanRedemptionBuffer - 1) -
911 env.now().time_since_epoch().count();
912 env(set(lender, broker.brokerID, broker.asset(100).value()),
913 kCounterparty(borrower),
914 Sig(sfCounterpartySignature, borrower),
915 Fee(env.current()->fees().base * 5),
916 kPaymentTotal(1u),
917 kPaymentInterval(rejectInterval),
919 env.close();
920 });
921
922 // 6. A vault whose Investment window is exactly kMinInvestmentPeriod can originate a
923 // minimum-interval, single-payment loan at the start of Investment, and rejects the same
924 // schedule once StartDate no longer leaves kLoanRedemptionBuffer before RedemptionDate.
925 // Do not pin an unrounded wall-clock instant: Env::close rounds to the close-time
926 // resolution. Read env.now() (the same clock LoanSet::preclaim uses) and assert the
927 // buffer relationship before each LoanSet.
928 withEnv([&](Env& env, PrettyAsset const& asset) {
929 auto const broker = createVaultAndBroker(
930 env,
931 asset,
932 lender,
934 .vaultKind = VaultKind::ClosedEnded,
935 .subscriptionOffset = 300u,
936 .redemptionOffset = kMinInvestmentPeriod,
937 .skipPhaseAdvance = true,
938 });
939 BEAST_EXPECT(broker.subscriptionDate.has_value());
940 BEAST_EXPECT(broker.redemptionDate.has_value());
941
942 auto const red = *broker.redemptionDate;
943 auto const startDate = [&] { return env.now().time_since_epoch().count(); };
944 auto const minLoan = [&](TER expected) {
945 env(set(lender, broker.brokerID, broker.asset(100).value()),
946 kCounterparty(borrower),
947 Sig(sfCounterpartySignature, borrower),
948 Fee(env.current()->fees().base * 5),
949 kPaymentTotal(1u),
950 kPaymentInterval(LoanSet::kMinPaymentInterval),
951 Ter(expected));
952 env.close();
953 };
954
955 // First Investment ledger: the minimum schedule still clears the buffer.
956 env.close(Tp{D{*broker.subscriptionDate + 1}});
957 BEAST_EXPECT(startDate() > *broker.subscriptionDate);
958 BEAST_EXPECT(startDate() + LoanSet::kMinPaymentInterval + kLoanRedemptionBuffer <= red);
959 minLoan(tesSUCCESS);
960
961 // Still Investment, but the minimum schedule no longer clears the buffer.
962 while (startDate() + LoanSet::kMinPaymentInterval + kLoanRedemptionBuffer <= red)
963 env.close();
964 BEAST_EXPECT(startDate() < red);
965 minLoan(tecNO_PERMISSION);
966 });
967 }
968
969 // LoanSet used to call canAddHolding unconditionally, so an existing
970 // borrower line still failed with terNO_RIPPLE after the issuer cleared
971 // DefaultRipple. After fixCleanup3_4_0, skip that gate when the holding
972 // already exists.
973 void
975 {
976 using namespace jtx;
977 using namespace loan;
978
979 auto const run = [this](FeatureBitset features, TER expected) {
980 testcase(
982 "LoanSet existing borrower line after issuer "
983 "clears asfDefaultRipple (") +
984 (features[fixCleanup3_4_0] ? "post" : "pre") + "-fixCleanup3_4_0)");
985
986 Env env(*this, features);
987 Account const issuer{"issuer"};
988 Account const lender{"lender"};
989 Account const borrower{"borrower"};
990
991 env.fund(XRP(10'000), issuer, lender, borrower);
992 env.close();
993 env(fset(issuer, asfDefaultRipple));
994 env.close();
995
996 PrettyAsset const usd{issuer["USD"]};
997 env(trust(lender, usd(10'000'000)));
998 env(trust(borrower, usd(10'000'000)));
999 env.close();
1000 env(pay(issuer, lender, usd(2'000'000)));
1001 env(pay(issuer, borrower, usd(1'000)));
1002 env.close();
1003 BEAST_EXPECT(env.le(keylet::trustLine(borrower.id(), usd.raw().get<Issue>())));
1004
1005 auto const broker = createVaultAndBroker(env, usd, lender);
1006
1007 env(fclear(issuer, asfDefaultRipple));
1008 env.close();
1009
1010 Number const destBefore = env.balance(borrower, usd.raw()).number();
1011 env(set(borrower, broker.brokerID, usd(100).value()),
1012 Sig(sfCounterpartySignature, lender),
1013 Fee(env.current()->fees().base * 2),
1014 Ter(expected));
1015 env.close();
1016
1017 Number const destAfter = env.balance(borrower, usd.raw()).number();
1018 if (isTesSuccess(expected))
1019 {
1020 BEAST_EXPECT(destAfter == destBefore + Number{100});
1021 }
1022 else
1023 {
1024 BEAST_EXPECT(destAfter == destBefore);
1025 }
1026 };
1027
1028 run(all_ - fixCleanup3_4_0, terNO_RIPPLE);
1030 }
1031
1032 void
1034 {
1035 using namespace jtx;
1036 using namespace loan;
1037
1038 testcase("FixedPrecision LoanSet");
1039
1040 FeatureBitset const features{
1041 all_ | featureLendingProtocolV1_1 | featureLendingProtocolV1_2,
1042 };
1043 Account const issuer{"issuer"};
1044 Account const lender{"lender"};
1045 Account const borrower{"borrower"};
1046 Env env{*this, features};
1047 env.fund(XRP(100'000), issuer, lender, borrower);
1048 env.close();
1049
1050 PrettyAsset const iou = issuer["IOU"];
1051 Number const trustLimit{10, 10};
1052 env(trust(lender, iou(trustLimit)));
1053 env(trust(borrower, iou(trustLimit)));
1054
1055 Number const openLimit{9, 9};
1056 env(pay(issuer, lender, iou(openLimit)));
1057
1058 Vault const vault{env};
1059 auto [createTx, vaultKeylet, subscriptionDate] =
1060 vault.createClosedEnded({.owner = lender, .asset = iou});
1061 std::uint8_t const vaultScale{6};
1062 createTx[sfScale] = vaultScale;
1063 env(createTx);
1064
1065 Number const principal{100};
1066 TenthBips32 const interestRate{100'000};
1067 constexpr std::uint32_t paymentTotal = 2;
1068 constexpr std::uint32_t paymentInterval = 24 * 60 * 60;
1069 // The loan's scale mirrors the vault's: 6 fractional digits, expressed
1070 // as a negative exponent.
1071 std::int32_t const loanScale{-6};
1072 auto const properties = computeLoanProperties(
1073 env.current()->rules(),
1074 iou.raw(),
1075 principal,
1076 interestRate,
1077 paymentInterval,
1078 paymentTotal,
1079 TenthBips16{0},
1080 loanScale);
1081 Number const interestDue = properties.loanState.interestDue;
1082 BEAST_EXPECT(interestDue > beast::kZero);
1083 BEAST_EXPECT(properties.loanScale == loanScale);
1084
1085 Number const deposit = openLimit - interestDue;
1086 env(vault.deposit({.depositor = lender, .id = vaultKeylet.key, .amount = iou(deposit)}));
1087 vault.closePastSubscription(subscriptionDate);
1088
1089 auto const brokerKeylet =
1090 keylet::loanBroker(lender.id(), SeqProxy::rawSequence(env.seq(lender)));
1091 env(loan_broker::set(lender, vaultKeylet.key));
1092 env.close();
1093
1094 auto const fee = Fee(env.current()->fees().base * 2);
1095 Number const offGrid{1, -7};
1096 auto const rejectedOffGrid = [&](auto const& field) {
1097 env(set(borrower, brokerKeylet.key, principal),
1098 field(offGrid),
1099 Sig(sfCounterpartySignature, lender),
1100 fee,
1102 };
1103
1104 env(set(borrower, brokerKeylet.key, offGrid),
1105 Sig(sfCounterpartySignature, lender),
1106 fee,
1108 rejectedOffGrid(kLoanOriginationFee);
1109 rejectedOffGrid(kLoanServiceFee);
1110 rejectedOffGrid(kLatePaymentFee);
1111 rejectedOffGrid(kClosePaymentFee);
1112
1113 auto const makeLoan = [&](TER expected) {
1114 env(set(borrower, brokerKeylet.key, principal),
1115 kInterestRate(interestRate),
1116 kPaymentTotal(paymentTotal),
1117 kPaymentInterval(paymentInterval),
1118 Sig(sfCounterpartySignature, lender),
1119 fee,
1120 Ter(expected));
1121 env.close();
1122 };
1123
1124 makeLoan(tesSUCCESS);
1125 auto const loanKeylet = keylet::loan(brokerKeylet.key, SeqProxy::rawSequence(1));
1126 {
1127 auto const loan = env.le(loanKeylet);
1128 BEAST_EXPECT(loan);
1129 if (loan)
1130 {
1131 BEAST_EXPECT(loan->at(sfLoanScale) == loanScale);
1132 BEAST_EXPECT(loan->at(sfPeriodicPayment) == properties.periodicPayment);
1133 }
1134 }
1135 {
1136 auto const vaultSle = env.le(vaultKeylet);
1137 BEAST_EXPECT(vaultSle);
1138 if (vaultSle)
1139 {
1140 BEAST_EXPECT(vaultSle->at(sfAssetsTotal) == deposit);
1141 BEAST_EXPECT(vaultSle->at(sfYieldUnrealized) == interestDue);
1142 }
1143 }
1145 *this, env, vaultKeylet, {brokerKeylet}, {loanKeylet}, "after LoanSet origination");
1146
1147 // The first LoanSet puts AssetsTotal + YieldUnrealized exactly at the
1148 // Open-zone ceiling. A second loan's InterestDue is therefore rejected.
1149 makeLoan(tecLIMIT_EXCEEDED);
1150 }
1151
1152 void
1154 {
1155 using namespace jtx;
1156 using namespace loan;
1157
1158 bool const withFix = features[fixCleanup3_5_0];
1159 testcase(
1160 std::string("LoanSet PrincipalRequested out of range for the asset (") +
1161 (withFix ? "post" : "pre") + "-fixCleanup3_5_0)");
1162
1163 Env env(*this, features);
1164 Account const lender{"lender"};
1165 Account const borrower{"borrower"};
1166 env.fund(XRP(10'000'000), lender, borrower);
1167 env.close();
1168
1169 PrettyAsset const xrp{xrpIssue(), 1'000'000};
1170 auto const broker = createVaultAndBroker(env, xrp, lender);
1171
1172 // Without the fix, the representability check in preclaim throws for
1173 // XRP above STAmount::kMaxNativeN.
1174 auto const ownerCount = env.ownerCount(borrower);
1175 Number const maxXrp{static_cast<std::int64_t>(STAmount::kMaxNativeN)};
1176 env(set(borrower, broker.brokerID, maxXrp + 1),
1177 Sig(sfCounterpartySignature, lender),
1178 Fee(env.current()->fees().base * 2),
1179 Ter(withFix ? TER{tecPRECISION_LOSS} : TER{tefEXCEPTION}));
1180 env.close();
1181 BEAST_EXPECT(env.ownerCount(borrower) == ownerCount);
1182 }
1183
1184public:
1185 void
1186 run() override
1187 {
1188 for (auto const& features : jtx::amendmentCombinations(
1189 {fixCleanup3_1_3, fixCleanup3_2_0, featureMPTokensV2}, all_))
1190 testLoanSet(features);
1191
1198
1200 testPrincipalRequestedOutOfRange(all_ - fixCleanup3_5_0);
1201 }
1202};
1203
1205
1206} // namespace xrpl::test
TestcaseT testcase
Memberspace for declaring test cases.
Definition suite.h:155
Represents a JSON value.
Definition json_value.h:121
constexpr TIss const & get() const
A currency issued by an account.
Definition Issue.h:18
static constexpr std::uint32_t kMinPaymentInterval
std::chrono::time_point< NetClock > time_point
Definition chrono.h:48
std::chrono::duration< rep, period > duration
Definition chrono.h:47
Number is a floating point type that can represent a wide range of values.
Definition Number.h:351
static constexpr std::uint64_t kMaxNativeN
Definition STAmount.h:72
static constexpr SeqProxy rawSequence(std::uint32_t v)
Factory function to return a sequence-based SeqProxy.
Definition SeqProxy.h:62
void testLegacyDebtTotalRoundsAtPreUpdateVaultScale()
void run() override
Runs the suite.
void testPrincipalRequestedOutOfRange(FeatureBitset features)
void testLoanSetOriginationFeeTwoMptCreates(FeatureBitset features)
void testLoanSetExistingLineAfterIssuerClearsDefaultRipple()
void testLoanSet(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())
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
AccountID id() const
Returns the Account ID.
A transaction testing environment.
Definition Env.h:161
bool close(NetClock::time_point closeTime, std::optional< std::chrono::milliseconds > consensusDelay=std::nullopt)
Close and advance the ledger.
Definition Env.cpp:133
SLE::const_pointer le(Account const &account) const
Return an account root.
Definition Env.cpp:311
std::uint32_t ownerCount(Account const &account) const
Return the number of objects owned by an account.
Definition Env.cpp:266
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
PrettyAmount balance(Account const &account) const
Returns the XRP balance on an account.
Definition Env.cpp:201
void trust(STAmount const &amount, Account const &account)
Establish trust lines.
Definition Env.cpp:354
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
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 a multisignature on a JTx.
Definition multisign.h:53
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 emplace_back(T... args)
constexpr Zero kZero
Definition Zero.h:30
Keylet vault(AccountID const &owner, SeqProxy const &seq) noexcept
Definition Indexes.cpp:565
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
Keylet trustLine(AccountID const &id0, AccountID const &id1, Currency const &currency) noexcept
The index of a trust line for a given currency.
Definition Indexes.cpp:287
Deposit preauthorize operations.
Definition deposit.h:16
json::Value set(AccountID const &account, UInt256 const &vaultId, uint32_t flags)
static NoneT const kNone
Definition tags.h:9
json::Value pay(AccountID const &account, AccountID const &to, AnyAmount amount)
Create a payment.
Definition pay.cpp:14
std::vector< FeatureBitset > amendmentCombinations(std::initializer_list< UInt256 > features, FeatureBitset seed)
Returns all 2^N permutations of a seed FeatureBitset with each subset of the given features excluded.
Definition Env.h:123
XrpT const XRP
Converts to XRP Issue or STAmount.
Definition amount.cpp:92
json::Value noop(Account const &account)
The null transaction.
Definition noop.h:14
std::uint32_t ownerCount(Env const &env, Account const &account)
json::Value fclear(Account const &account, std::uint32_t off)
Remove account flag.
Definition flags.h:110
FeatureBitset testableAmendments()
Definition Env.h:92
json::Value trust(Account const &account, STAmount const &amount, std::uint32_t flags)
Modify a trust line.
Definition trust.cpp:18
json::Value signers(Account const &account, std::uint32_t quorum, std::vector< Signer > const &v)
Definition multisign.cpp:31
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)
STTx createTx(bool disabling, LedgerIndex seq, PublicKey const &txKey)
Create ttUNL_MODIFY Tx.
void checkFixedPrecisionVaultAssetsDeployed(beast::unit_test::Suite &suite, jtx::Env &env, Keylet const &vaultKeylet, std::vector< Keylet > const &brokerKeylets, std::vector< Keylet > const &loanKeylets, std::string const &label={})
Use hash_* containers for keys that do not need a cryptographically secure hashing algorithm.
Definition algorithm.h:5
@ terNO_RIPPLE
Definition TER.h:226
bool set(T &target, std::string const &name, Section const &section)
Set a value from a configuration Section If the named value is not found or doesn't parse as a T,...
Issue const & xrpIssue()
Returns an asset specifier that represents XRP.
Definition Issue.h:108
constexpr TenthBips32 percentageToTenthBips(std::uint32_t percentage)
Definition Protocol.h:127
constexpr XRPAmount kDropsPerXrp
Number of drops per 1 XRP.
Definition XRPAmount.h:247
int scale(Number const &number, Asset const &asset)
Get the scale of a Number for a given asset.
Definition STAmount.h:819
@ tefEXCEPTION
Definition TER.h:166
TenthBips< std::uint32_t > TenthBips32
Definition Units.h:454
TenthBips< std::uint16_t > TenthBips16
Definition Units.h:453
LedgerSpecificFlags
constexpr Number abs(Number x) noexcept
Definition Number.h:880
int run(int argc, char *const *argv)
Definition Main.cpp:354
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
bool isTesSuccess(TER x) noexcept
Definition TER.h:686
TERSubset< CanCvtToTER > TER
Definition TER.h:657
TER requireAuth(ReadView const &view, MPTIssue const &mptIssue, AccountID const &account, AuthType authType=AuthType::Legacy, std::uint8_t depth=0)
Check if the account lacks required authorization for MPT.
@ tecTOO_SOON
Definition TER.h:329
@ tecEXPIRED
Definition TER.h:325
@ tecPRECISION_LOSS
Definition TER.h:374
@ tecLIMIT_EXCEEDED
Definition TER.h:372
@ tecNO_PERMISSION
Definition TER.h:316
LoanProperties computeLoanProperties(Rules const &rules, Asset const &asset, Number const &principalOutstanding, TenthBips32 interestRate, std::uint32_t paymentInterval, std::uint32_t paymentsRemaining, TenthBips32 managementFeeRate, std::int32_t minimumScale)
constexpr std::uint32_t kLoanRedemptionBuffer
Minimum gap between a closed-ended loan's final scheduled payment and the vault's RedemptionDate.
Definition Protocol.h:379
constexpr std::uint32_t kMinInvestmentPeriod
Bounds on the length of a closed-ended vault's Investment phase (RedemptionDate - SubscriptionDate).
Definition Protocol.h:391
@ tesSUCCESS
Definition TER.h:253
T reserve(T... args)
T size(T... args)
T time_since_epoch(T... args)