1#include <test/app/lending/LoanPayFixedPrecisionBase.h>
2#include <test/app/lending/LoanTestBase.h>
3#include <test/jtx/Account.h>
4#include <test/jtx/Env.h>
5#include <test/jtx/TestHelpers.h>
6#include <test/jtx/amount.h>
7#include <test/jtx/fee.h>
8#include <test/jtx/flags.h>
9#include <test/jtx/pay.h>
10#include <test/jtx/ter.h>
11#include <test/jtx/trust.h>
12#include <test/jtx/vault.h>
14#include <xrpl/basics/Number.h>
15#include <xrpl/basics/chrono.h>
16#include <xrpl/beast/unit_test/suite.h>
17#include <xrpl/beast/utility/Zero.h>
18#include <xrpl/ledger/helpers/LendingHelpers.h>
19#include <xrpl/ledger/helpers/VaultHelpers.h>
20#include <xrpl/protocol/Asset.h>
21#include <xrpl/protocol/Feature.h>
22#include <xrpl/protocol/Indexes.h>
23#include <xrpl/protocol/Keylet.h>
24#include <xrpl/protocol/Protocol.h>
25#include <xrpl/protocol/SField.h>
26#include <xrpl/protocol/STAmount.h>
27#include <xrpl/protocol/SeqProxy.h>
28#include <xrpl/protocol/TER.h>
29#include <xrpl/protocol/TxFlags.h>
30#include <xrpl/protocol/Units.h>
59 testcase(
"Lending: LoanPay reduces AssetsDeployed by exactly the principal paid");
62 auto const [issuer, owner, depositor, asset] =
setupIou(env);
64 Number const vaultDeposit{1'000};
65 Number const loanPrincipal{300};
69 auto const fixture =
setupLendingVault(env, owner, depositor, asset, vaultDeposit);
70 auto const loanKeylet =
openLoan(env, fixture, loanPrincipal, paymentTotal);
72 env(pay(depositor, loanKeylet.key, asset(payment).value()));
76 expectVault(env, fixture.vaultKeylet, {.assetsDeployed = loanPrincipal - payment});
81 env(pay(depositor, loanKeylet.key, asset(payment).value()));
84 sle = env.le(fixture.vaultKeylet);
85 if (!BEAST_EXPECT(sle))
89 BEAST_EXPECT(sle->at(sfAssetsAvailable) == vaultDeposit);
90 BEAST_EXPECT(sle->at(sfAssetsTotal) == vaultDeposit);
101 "Lending: FixedPrecision vault with interest -- AssetsDeployed tracks "
102 "PrincipalOutstanding "
107 auto const [issuer, owner, depositor, asset] =
108 setupIou(env, {.depositorTrust = 2'100, .ownerTrust = 2'000});
110 Number const vaultDeposit{2'000};
111 Number const loanPrincipal{1'000};
117 auto const fixture =
setupLendingVault(env, owner, depositor, asset, vaultDeposit);
127 auto const loanSle0 = env.le(loanKeylet);
128 if (!BEAST_EXPECT(loanSle0))
132 Number const periodicPayment = loanSle0->at(sfPeriodicPayment);
133 std::int32_t const loanScale = loanSle0->at(sfLoanScale);
136 auto const vaultSle0 = env.le(fixture.vaultKeylet);
137 if (!BEAST_EXPECT(vaultSle0))
141 Account const vaultAccount(
"vault", vaultSle0->at(sfAccount));
142 env.memoize(vaultAccount);
144 Number prevPrincipal = loanSle0->at(sfPrincipalOutstanding);
145 Number prevAssetsDeployed = vaultSle0->at(sfAssetsDeployed);
146 Number prevAvailable = vaultSle0->at(sfAssetsAvailable);
147 Number prevVaultBalance = env.balance(vaultAccount, asset).value();
148 BEAST_EXPECT(prevAssetsDeployed == prevPrincipal);
152 env(pay(depositor, loanKeylet.key, asset(periodicPaymentDue).value()));
155 auto const loanSle = env.le(loanKeylet);
156 auto const vaultSle = env.le(fixture.vaultKeylet);
157 if (!BEAST_EXPECT(loanSle) || !BEAST_EXPECT(vaultSle))
160 Number const principal = loanSle->at(sfPrincipalOutstanding);
161 Number const assetsDeployed = vaultSle->at(sfAssetsDeployed);
162 Number const available = vaultSle->at(sfAssetsAvailable);
163 Number const vaultBalance = env.balance(vaultAccount, asset).value();
166 BEAST_EXPECT(assetsDeployed == principal);
167 BEAST_EXPECT(prevAssetsDeployed - assetsDeployed == prevPrincipal - principal);
168 BEAST_EXPECT(vaultSle->at(sfAssetsTotal) ==
getAssetsTotal(vaultSle));
169 BEAST_EXPECT(available - prevAvailable == vaultBalance - prevVaultBalance);
171 env, fixture, {loanKeylet},
"interest payoff period " +
std::to_string(i));
173 prevPrincipal = principal;
174 prevAssetsDeployed = assetsDeployed;
175 prevAvailable = available;
176 prevVaultBalance = vaultBalance;
187 using namespace loan;
190 "Lending: LoanPay overpayment reduces AssetsDeployed by the full principal reduction");
193 auto const [issuer, owner, depositor, asset] =
setupIou(env);
195 Number const vaultDeposit{1'000};
196 Number const loanPrincipal{500};
198 Number const periodicPayment = loanPrincipal / paymentTotal;
200 Number const overpayAmount = periodicPayment * 3;
202 auto const fixture =
setupLendingVault(env, owner, depositor, asset, vaultDeposit);
204 auto const loanKeylet =
207 auto const loanSleBefore = env.le(loanKeylet);
208 if (!BEAST_EXPECT(loanSleBefore))
210 Number const principalBefore = loanSleBefore->at(sfPrincipalOutstanding);
212 auto vaultSle = env.le(fixture.vaultKeylet);
213 if (!BEAST_EXPECT(vaultSle))
215 Number const assetsDeployedBefore = vaultSle->at(sfAssetsDeployed);
216 BEAST_EXPECT(assetsDeployedBefore == principalBefore);
218 env(pay(depositor, loanKeylet.key, asset(overpayAmount).value(), tfLoanOverpayment));
221 auto const loanSleAfter = env.le(loanKeylet);
222 vaultSle = env.le(fixture.vaultKeylet);
223 if (!BEAST_EXPECT(loanSleAfter) || !BEAST_EXPECT(vaultSle))
225 Number const principalAfter = loanSleAfter->at(sfPrincipalOutstanding);
226 Number const assetsDeployedAfter = vaultSle->at(sfAssetsDeployed);
229 BEAST_EXPECT(principalBefore - principalAfter > periodicPayment);
230 BEAST_EXPECT(assetsDeployedAfter == principalAfter);
232 assetsDeployedBefore - assetsDeployedAfter == principalBefore - principalAfter);
233 BEAST_EXPECT(vaultSle->at(sfAssetsTotal) ==
getAssetsTotal(vaultSle));
241 using namespace loan;
244 "Lending: tfLoanFullPayment zeroes one Loan's contribution to AssetsDeployed, leaving "
245 "another loan's principal");
248 auto const [issuer, owner, depositor, asset] =
setupIou(env);
250 Number const vaultDeposit{1'000};
251 Number const principalA{300};
253 Number const principalB{200};
256 auto const fixture =
setupLendingVault(env, owner, depositor, asset, vaultDeposit);
257 auto const loanAKeylet =
openLoan(env, fixture, principalA, paymentTotalA);
258 auto const loanBKeylet =
openLoan(env, fixture, principalB, paymentTotalB);
260 auto vaultSle = env.le(fixture.vaultKeylet);
261 if (!BEAST_EXPECT(vaultSle))
263 BEAST_EXPECT(vaultSle->at(sfAssetsDeployed) == principalA + principalB);
264 checkVaultLoanSums(env, fixture, {loanAKeylet, loanBKeylet},
"early payoff, before payoff");
266 auto const loanASle = env.le(loanAKeylet);
267 if (!BEAST_EXPECT(loanASle))
269 Number const principalABefore = loanASle->at(sfPrincipalOutstanding);
271 env(pay(depositor, loanAKeylet.key, asset(principalABefore).value(), tfLoanFullPayment));
274 auto const loanASleAfter = env.le(loanAKeylet);
275 vaultSle = env.le(fixture.vaultKeylet);
276 if (!BEAST_EXPECT(loanASleAfter) || !BEAST_EXPECT(vaultSle))
278 BEAST_EXPECT(loanASleAfter->at(sfPrincipalOutstanding) ==
beast::kZero);
279 BEAST_EXPECT(loanASleAfter->at(sfPaymentRemaining) == 0);
280 BEAST_EXPECT(vaultSle->at(sfAssetsDeployed) == principalB);
281 BEAST_EXPECT(vaultSle->at(sfAssetsTotal) ==
getAssetsTotal(vaultSle));
282 checkVaultLoanSums(env, fixture, {loanAKeylet, loanBKeylet},
"early payoff, after payoff");
289 using namespace loan;
292 "Lending: MPT (integral asset) FixedPrecision vault -- AssetsDeployed tracks "
293 "PrincipalOutstanding through payoff");
297 auto const [issuer, owner, depositor, asset] =
298 setupMpt(env, {.maxAmt = 100'000, .withDepositor =
true, .holderFunds = 2'100});
300 Number const vaultDeposit{2'000};
301 Number const loanPrincipal{1'000};
307 auto const fixture =
setupLendingVault(env, owner, depositor, asset, vaultDeposit);
317 auto const loanSle0 = env.le(loanKeylet);
318 if (!BEAST_EXPECT(loanSle0))
322 Number const periodicPayment = loanSle0->at(sfPeriodicPayment);
323 std::int32_t const loanScale = loanSle0->at(sfLoanScale);
326 auto const vaultSle0 = env.le(fixture.vaultKeylet);
327 if (!BEAST_EXPECT(vaultSle0))
329 Account const vaultAccount(
"vault", vaultSle0->at(sfAccount));
330 env.memoize(vaultAccount);
332 Number prevPrincipal = loanSle0->at(sfPrincipalOutstanding);
333 Number prevAssetsDeployed = vaultSle0->at(sfAssetsDeployed);
334 Number prevAvailable = vaultSle0->at(sfAssetsAvailable);
335 Number prevVaultBalance = env.balance(vaultAccount, asset).value();
336 BEAST_EXPECT(prevAssetsDeployed == prevPrincipal);
340 env(pay(depositor, loanKeylet.key, asset(periodicPaymentDue).value()));
343 auto const loanSle = env.le(loanKeylet);
344 auto const vaultSle = env.le(fixture.vaultKeylet);
345 if (!BEAST_EXPECT(loanSle) || !BEAST_EXPECT(vaultSle))
348 Number const principal = loanSle->at(sfPrincipalOutstanding);
349 Number const assetsDeployed = vaultSle->at(sfAssetsDeployed);
350 Number const available = vaultSle->at(sfAssetsAvailable);
351 Number const vaultBalance = env.balance(vaultAccount, asset).value();
353 BEAST_EXPECT(assetsDeployed == principal);
354 BEAST_EXPECT(prevAssetsDeployed - assetsDeployed == prevPrincipal - principal);
355 BEAST_EXPECT(vaultSle->at(sfAssetsTotal) ==
getAssetsTotal(vaultSle));
356 BEAST_EXPECT(available - prevAvailable == vaultBalance - prevVaultBalance);
358 env, fixture, {loanKeylet},
"integral asset payoff period " +
std::to_string(i));
360 prevPrincipal = principal;
361 prevAssetsDeployed = assetsDeployed;
362 prevAvailable = available;
363 prevVaultBalance = vaultBalance;
375 testcase(
"Lending: paid late interest coarsens a FixedPrecision vault's live scale");
380 auto const coarsened =
coarsenVault(env, owner, depositor, asset);
382 auto const vaultSle = env.le(coarsened.fixture.vaultKeylet);
383 if (!BEAST_EXPECT(vaultSle))
393 using namespace loan;
395 testcase(
"Lending: on a coarsened vault, a payment's vault credit floors at the live unit");
403 Number const otherPrincipal{1234'0000000007LL, -10};
405 env, owner, depositor, asset, {.extraLoans = {
ExtraLoan{.principal = otherPrincipal}}});
407 auto const& otherLoanKeylet = coarsened.loanKeylets[1];
409 auto const vaultSleBefore = env.le(vaultKeylet);
410 if (!BEAST_EXPECT(vaultSleBefore))
414 auto const loanSleBefore = env.le(otherLoanKeylet);
415 if (!BEAST_EXPECT(loanSleBefore))
417 Number const principalBefore = loanSleBefore->at(sfPrincipalOutstanding);
422 env(pay(depositor, otherLoanKeylet.key, asset(otherPrincipal).value(), tfLoanLatePayment));
425 auto const vaultSleAfter = env.le(vaultKeylet);
426 auto const loanSleAfter = env.le(otherLoanKeylet);
427 if (!BEAST_EXPECT(vaultSleAfter) || !BEAST_EXPECT(loanSleAfter))
429 Number const principalAfter = loanSleAfter->at(sfPrincipalOutstanding);
431 Number const principalPaid = principalBefore - principalAfter;
434 after.available - before.available ==
after.vaultBalance - before.vaultBalance);
435 BEAST_EXPECT(before.assetsDeployed -
after.assetsDeployed == principalPaid);
438 Number const stored = vaultSleAfter->at(sfAssetsTotal);
440 BEAST_EXPECT(stored <= derived);
441 BEAST_EXPECT(derived - stored < liveUnit);
442 BEAST_EXPECT(
Number(vaultSleAfter->at(sfAssetsAvailable)) <= stored);
453 "Lending: the payment that coarsens a vault credits no more than principal plus "
466 Number const depositorBalanceBefore = env.balance(depositor, asset).value();
469 auto const coarsened =
coarsenVault(env, owner, depositor, asset, params);
470 auto const& vaultKeylet = coarsened.fixture.vaultKeylet;
472 auto const vaultSleAfter = env.le(vaultKeylet);
473 if (!BEAST_EXPECT(vaultSleAfter))
477 Number const depositorBalanceAfter = env.balance(depositor, asset).value();
479 (depositorBalanceBefore - depositorBalanceAfter) - params.
depositAmount;
482 env.memoize(vaultAccount);
483 Number const vaultBalanceAfter = env.balance(vaultAccount, asset).value();
490 BEAST_EXPECT(credit <= rawPaid);
491 BEAST_EXPECT(
Number(vaultSleAfter->at(sfAssetsAvailable)) == vaultBalanceAfter);
500 using namespace loan;
503 "Lending: sub-unit remainder payments on a coarsened vault (terminal closes with a "
504 "zero credit; non-terminal is rejected)");
508 auto const& [issuer, owner, depositor, asset] = accounts;
511 Account const dustBorrower{
"dustBorrower"};
512 Number const dustBorrowerTrustLimit{10};
513 Number const dustBorrowerFunds{1};
514 fundIouHolder(env, dustBorrower, accounts, dustBorrowerTrustLimit, dustBorrowerFunds);
516 Number const overpayPrincipal{1'000};
518 Number const dust{5, -10};
521 Number const nonTerminalPrincipal{9, -10};
531 .principal = overpayPrincipal,
532 .flags = tfLoanOverpayment,
539 .principal = nonTerminalPrincipal,
542 .borrower = dustBorrower,
547 auto const& loanKeylet = coarsened.loanKeylets[1];
548 auto const& nonTerminalLoanKeylet = coarsened.loanKeylets[2];
550 auto const vaultSle0 = env.le(vaultKeylet);
551 if (!BEAST_EXPECT(vaultSle0))
555 BEAST_EXPECT(dust < liveUnit);
558 depositor, loanKeylet.key, asset(overpayPrincipal - dust).value(), tfLoanOverpayment));
561 auto const loanSleMid = env.le(loanKeylet);
562 if (!BEAST_EXPECT(loanSleMid))
564 Number const principalMid = loanSleMid->at(sfPrincipalOutstanding);
565 std::uint32_t const paymentRemainingMid = loanSleMid->at(sfPaymentRemaining);
566 BEAST_EXPECT(paymentRemainingMid == 1);
567 BEAST_EXPECT(principalMid < liveUnit);
570 checkVaultLoanSums(env, coarsened,
"testCoarsenedVaultSubUnitRemainderPayments (mid)");
573 auto const brokerSleMid = env.le(coarsened.fixture.brokerKeylet);
574 if (!BEAST_EXPECT(brokerSleMid))
576 Number const brokerDebtMid = brokerSleMid->at(sfDebtTotal);
578 auto const brokerKeylet = coarsened.fixture.brokerKeylet;
583 env(pay(depositor, loanKeylet.key, asset(
Number{1}).value()), Ter(
tesSUCCESS));
586 auto const loanSleAfter = env.le(loanKeylet);
587 auto const brokerSleAfter = env.le(brokerKeylet);
588 if (!BEAST_EXPECT(loanSleAfter) || !BEAST_EXPECT(brokerSleAfter))
591 BEAST_EXPECT(loanSleAfter->at(sfPaymentRemaining) == 0);
592 BEAST_EXPECT(loanSleAfter->at(sfPrincipalOutstanding) ==
beast::kZero);
594 Number const brokerDebtAfter = brokerSleAfter->at(sfDebtTotal);
596 BEAST_EXPECT(mid.assetsDeployed -
after.assetsDeployed == principalMid);
597 BEAST_EXPECT(brokerDebtMid - brokerDebtAfter == principalMid);
599 BEAST_EXPECT(
after.available == mid.available);
600 BEAST_EXPECT(
after.vaultBalance == mid.vaultBalance);
602 checkVaultLoanSums(env, coarsened,
"testCoarsenedVaultSubUnitRemainderPayments (terminal)");
606 auto const nonTerminalLoanBefore = env.le(nonTerminalLoanKeylet);
607 if (!BEAST_EXPECT(nonTerminalLoanBefore))
609 BEAST_EXPECT(nonTerminalLoanBefore->at(sfPaymentRemaining) == 3);
610 Number const nonTerminalPrincipalBefore = nonTerminalLoanBefore->at(sfPrincipalOutstanding);
611 auto const vaultSleBeforeNT2 = env.le(vaultKeylet);
612 if (!BEAST_EXPECT(vaultSleBeforeNT2))
619 env(pay(dustBorrower, nonTerminalLoanKeylet.key, asset(nonTerminalPrincipal / 3).value()),
623 auto const nonTerminalLoanAfter = env.le(nonTerminalLoanKeylet);
624 auto const vaultSleAfterNT2 = env.le(vaultKeylet);
625 if (!BEAST_EXPECT(nonTerminalLoanAfter) || !BEAST_EXPECT(vaultSleAfterNT2))
627 BEAST_EXPECT(nonTerminalLoanAfter->at(sfPaymentRemaining) == 3);
629 Number(nonTerminalLoanAfter->at(sfPrincipalOutstanding)) == nonTerminalPrincipalBefore);
631 Number(vaultSleAfterNT2->at(sfAssetsAvailable)) ==
632 Number(vaultSleBeforeNT2->at(sfAssetsAvailable)));
635 env, coarsened,
"testCoarsenedVaultSubUnitRemainderPayments (non-terminal rejection)");
642 using namespace loan;
652 char const* name =
nullptr;
653 bool ownerIsBorrower =
false;
654 bool ownerIsIssuer =
false;
660 Number issuerLimitOnOwner{0};
663 bool borrowerPays =
true;
664 bool ownerReceives =
true;
666 Number const smallFee{1, -10};
668 Number const largeFunds{10'000'000};
671 .name =
"Lending: terminal close with a zero vault credit but a non-zero fee needs "
676 "Lending: terminal close with a zero vault credit and a fee the broker owner "
677 "pays to itself moves nothing",
678 .ownerIsBorrower =
true,
680 .borrowerPays =
false,
681 .ownerReceives =
false,
684 .name =
"Lending: terminal close with a zero vault credit and a fee that rounds "
685 "away on the broker owner's trust line is lost",
687 .ownerFunds = largeFunds,
688 .ownerReceives =
false,
691 .name =
"Lending: terminal close with a zero vault credit and a fee that rounds "
692 "away on the borrower's trust line is not debited",
694 .borrowerFunds = largeFunds,
695 .borrowerPays =
false,
698 .name =
"Lending: terminal close with a zero vault credit pays a small fee to an "
699 "owner whose trust line has a large issuer limit",
701 .issuerLimitOnOwner = largeFunds,
704 .name =
"Lending: terminal close with a zero vault credit pays the fee to an "
705 "issuer that owns the broker",
706 .ownerIsIssuer =
true,
709 .name =
"Lending: terminal close with a zero vault credit pays the fee to an "
710 "owner with a negative balance",
711 .issuerLimitOnOwner =
Number{1'000},
715 for (
auto const& row : rows)
721 auto const& [issuer, holderOwner, depositor, asset] = accounts;
722 Account const& owner = row.ownerIsIssuer ? issuer : holderOwner;
723 Account const dustBorrower{
"dustBorrower"};
725 Account const& borrower = row.ownerIsBorrower ? owner : dustBorrower;
727 Number const dustPrincipal{9, -10};
728 Number const fee = row.fee;
738 .principal = dustPrincipal,
741 .borrower = borrower,
747 auto const& feeLoanKeylet = coarsened.loanKeylets[1];
749 auto const vaultSleBefore = env.le(vaultKeylet);
750 if (!BEAST_EXPECT(vaultSleBefore))
754 for (
auto const& [holder, funds] :
760 env(trust(*holder, asset(funds +
Number{1'000})));
766 env(trust(issuer,
PrettyAsset{owner[
"USD"]}(row.issuerLimitOnOwner)));
773 BEAST_EXPECT(env.balance(owner, asset).value() == -row.ownerOwes);
777 Number const ownerBalanceBefore = env.balance(owner, asset).value();
778 Number const borrowerBalanceBefore = env.balance(borrower, asset).value();
780 auto const loanSleBefore = env.le(feeLoanKeylet);
781 if (!BEAST_EXPECT(loanSleBefore))
783 BEAST_EXPECT(loanSleBefore->at(sfPaymentRemaining) == 1);
785 env(pay(borrower, feeLoanKeylet.key, asset(dustPrincipal + fee).value()));
788 auto const loanSleAfter = env.le(feeLoanKeylet);
789 auto const vaultSleAfter = env.le(vaultKeylet);
790 if (!BEAST_EXPECT(loanSleAfter) || !BEAST_EXPECT(vaultSleAfter))
792 BEAST_EXPECT(loanSleAfter->at(sfPaymentRemaining) == 0);
793 BEAST_EXPECT(loanSleAfter->at(sfPrincipalOutstanding) ==
beast::kZero);
796 Number const ownerBalanceAfter = env.balance(owner, asset).value();
797 Number const borrowerBalanceAfter = env.balance(borrower, asset).value();
800 BEAST_EXPECT(
after.available == before.available);
801 BEAST_EXPECT(
after.vaultBalance == before.vaultBalance);
802 if (!row.ownerIsBorrower)
805 borrowerBalanceBefore - borrowerBalanceAfter ==
806 (row.borrowerPays ? fee :
Number{0}));
808 if (!row.ownerIsIssuer)
811 ownerBalanceAfter - ownerBalanceBefore ==
812 (row.ownerReceives ? fee :
Number{0}));
823 using namespace loan;
826 "Lending: terminal close with zero vault credit and a fee redirected to cover that "
827 "itself floors to zero still succeeds");
834 .depositorTrust = 30'000'000,
835 .ownerTrust = 1'000'000,
836 .depositorFunds = 10'000'000,
837 .ownerFunds = 900'000,
839 auto const& [issuer, owner, depositor, asset] = accounts;
840 Account const dustBorrower{
"dustBorrower"};
852 Number const dustPrincipal{9, -10};
853 Number const dustFee{1, -10};
854 Number const coverDeposit{899'999};
855 Number const bigFee{200'000};
865 .principal = dustPrincipal,
868 .borrower = dustBorrower,
869 .serviceFee = dustFee,
875 .serviceFee = bigFee,
878 .coverDeposit = coverDeposit,
881 auto const& brokerKeylet = coarsened.fixture.brokerKeylet;
882 auto const& feeLoanKeylet = coarsened.loanKeylets[1];
883 auto const& bigFeeLoanKeylet = coarsened.loanKeylets[2];
889 env(trust(issuer, asset(0), owner, tfSetFreeze | tfSetDeepFreeze));
892 env(pay(depositor, bigFeeLoanKeylet.key, asset(
Number{1} + bigFee).value()));
895 auto const vaultSleBefore = env.le(vaultKeylet);
896 auto const brokerSleBefore = env.le(brokerKeylet);
897 if (!BEAST_EXPECT(vaultSleBefore) || !BEAST_EXPECT(brokerSleBefore))
900 Number const coverAvailableBefore = brokerSleBefore->at(sfCoverAvailable);
901 BEAST_EXPECT(coverAvailableBefore == coverDeposit + bigFee);
902 BEAST_EXPECT(coverAvailableBefore >
Number(1, 6));
906 auto const loanSleBefore = env.le(feeLoanKeylet);
907 if (!BEAST_EXPECT(loanSleBefore))
909 BEAST_EXPECT(loanSleBefore->at(sfPaymentRemaining) == 1);
911 env(pay(dustBorrower, feeLoanKeylet.key, asset(dustPrincipal + dustFee).value()));
914 auto const loanSleAfter = env.le(feeLoanKeylet);
915 auto const brokerSleAfter = env.le(brokerKeylet);
916 if (!BEAST_EXPECT(loanSleAfter) || !BEAST_EXPECT(brokerSleAfter))
918 BEAST_EXPECT(loanSleAfter->at(sfPaymentRemaining) == 0);
919 BEAST_EXPECT(loanSleAfter->at(sfPrincipalOutstanding) ==
beast::kZero);
922 Number const coverAvailableAfter = brokerSleAfter->at(sfCoverAvailable);
925 BEAST_EXPECT(
after.available == before.available);
926 BEAST_EXPECT(
after.vaultBalance == before.vaultBalance);
927 BEAST_EXPECT(coverAvailableAfter == coverAvailableBefore);
929 checkVaultLoanSums(env, coarsened,
"testCoarsenedVaultTerminalCloseFeeToCoverFloorsToZero");
936 using namespace loan;
939 "Lending: terminal close with zero vault credit and a non-zero fee redirected to "
940 "cover moves CoverAvailable and the broker pseudo-account by the same amount");
944 auto const& [issuer, owner, depositor, asset] = accounts;
945 Account const dustBorrower{
"dustBorrower"};
948 Number const dustPrincipal{9, -10};
959 .principal = dustPrincipal,
962 .borrower = dustBorrower,
968 auto const& feeLoanKeylet = coarsened.loanKeylets[1];
975 env(trust(issuer, asset(0), owner, tfSetFreeze | tfSetDeepFreeze));
978 auto const brokerSleBefore = env.le(brokerKeylet);
979 if (!BEAST_EXPECT(brokerSleBefore))
981 Number const coverAvailableBefore = brokerSleBefore->at(sfCoverAvailable);
982 auto const brokerAccountId = brokerSleBefore->at(sfAccount);
983 Number const brokerPseudoBalanceBefore =
984 env.balance(
Account{
"brokerPseudo", brokerAccountId}, asset).value();
986 auto const loanSleBefore = env.le(feeLoanKeylet);
987 if (!BEAST_EXPECT(loanSleBefore))
989 BEAST_EXPECT(loanSleBefore->at(sfPaymentRemaining) == 1);
991 env(pay(dustBorrower, feeLoanKeylet.key, asset(dustPrincipal + fee).value()));
994 auto const loanSleAfter = env.le(feeLoanKeylet);
995 auto const brokerSleAfter = env.le(brokerKeylet);
996 if (!BEAST_EXPECT(loanSleAfter) || !BEAST_EXPECT(brokerSleAfter))
998 BEAST_EXPECT(loanSleAfter->at(sfPaymentRemaining) == 0);
999 BEAST_EXPECT(loanSleAfter->at(sfPrincipalOutstanding) ==
beast::kZero);
1001 Number const coverAvailableAfter = brokerSleAfter->at(sfCoverAvailable);
1002 Number const coverDelta = coverAvailableAfter - coverAvailableBefore;
1005 Number const brokerPseudoBalanceAfter =
1006 env.balance(
Account{
"brokerPseudo", brokerAccountId}, asset).value();
1007 BEAST_EXPECT(brokerPseudoBalanceAfter - brokerPseudoBalanceBefore == coverDelta);
1009 checkVaultLoanSums(env, coarsened,
"testCoarsenedVaultTerminalCloseFeeToCoverNonZero");
1016 using namespace loan;
1019 "Lending: on a vault where AssetsAvailable's grid is finer than AssetsTotal's, a "
1020 "payment keeps the digit AA can hold");
1028 Number const otherPrincipal{1234'0000000007LL, -10};
1034 {.extraLoans = {
ExtraLoan{.principal = otherPrincipal}}, .overdueDays = 200});
1036 auto const& otherLoanKeylet = coarsened.loanKeylets[1];
1038 auto const vaultSleBefore = env.le(vaultKeylet);
1039 if (!BEAST_EXPECT(vaultSleBefore))
1045 auto const loanSleBefore = env.le(otherLoanKeylet);
1046 if (!BEAST_EXPECT(loanSleBefore))
1048 Number const principalBefore = loanSleBefore->at(sfPrincipalOutstanding);
1050 env(pay(depositor, otherLoanKeylet.key, asset(otherPrincipal).value(), tfLoanLatePayment));
1053 auto const loanSleAfter = env.le(otherLoanKeylet);
1054 auto const vaultSleAfter = env.le(vaultKeylet);
1055 if (!BEAST_EXPECT(loanSleAfter) || !BEAST_EXPECT(vaultSleAfter))
1057 Number const principalPaid =
1058 principalBefore -
Number(loanSleAfter->at(sfPrincipalOutstanding));
1063 BEAST_EXPECT(
after.available - before.available == principalPaid);
1068 after.available - before.available ==
after.vaultBalance - before.vaultBalance);
1070 checkVaultLoanSums(env, coarsened,
"testCoarsenedVaultCreditKeepsAvailableGridDigit");
1081 using namespace loan;
1084 "Lending: a credit that crosses a power of ten keeps AssetsAvailable at 16 digits");
1093 Number const crossingPrincipal{10'000};
1103 .principal = crossingPrincipal,
1104 .flags = tfLoanOverpayment,
1111 auto const& crossingLoanKeylet = coarsened.loanKeylets[1];
1114 BEAST_EXPECT(before.available <= before.total);
1121 Number const crossingPayment = nextPowerOfTen - before.available + margin;
1123 auto const loanSleBefore = env.le(crossingLoanKeylet);
1124 if (!BEAST_EXPECT(loanSleBefore))
1128 BEAST_EXPECT(crossingPayment <=
Number(loanSleBefore->at(sfPrincipalOutstanding)));
1131 depositor, crossingLoanKeylet.key, asset(crossingPayment).value(), tfLoanOverpayment));
1136 BEAST_EXPECT(availableAfter >= nextPowerOfTen);
1148 using namespace loan_broker;
1150 testcase(
"FixedPrecision LoanBroker cover: minCoverBroker loan payment");
1152 FeatureBitset const v12{
all_ | featureLendingProtocolV1_1 | featureLendingProtocolV1_2};
1153 Account const issuer{
"issuer"};
1155 Account const borrower{
"borrower"};
1156 Env env{*
this, v12};
1157 env.fund(XRP(100'000), issuer, alice, borrower);
1159 env(fset(issuer, asfAllowTrustLineClawback));
1163 Number const trustLimit{10, 10};
1164 Number const aliceFunds{10, 9};
1165 Number const borrowerFunds{10, 2};
1166 env(trust(alice, iou(trustLimit)));
1167 env(trust(borrower, iou(trustLimit)));
1168 env(pay(issuer, alice, iou(aliceFunds)));
1169 env(pay(issuer, borrower, iou(borrowerFunds)));
1172 [[maybe_unused]]
auto [createTx, vaultKeylet, subscriptionDate] =
1173 vault.createClosedEnded({.owner = alice, .asset = iou});
1175 createTx[sfScale] = vaultScale;
1177 Number const vaultDeposit{100};
1179 {.depositor = alice, .id = vaultKeylet.key, .amount = iou(vaultDeposit)}));
1180 vault.closePastSubscription(subscriptionDate);
1182 auto const minCoverBroker =
1184 Number const debtMaximum{100};
1187 env(
set(alice, vaultKeylet.key),
1188 kDebtMaximum(debtMaximum),
1191 Number const coverDepositAmount{1, -1};
1192 env(coverDeposit(alice, minCoverBroker.key, iou(coverDepositAmount)));
1193 Number const loanPrincipal{1};
1194 env(loan::set(borrower, minCoverBroker.key, loanPrincipal),
1195 Sig(sfCounterpartySignature, alice),
1196 Fee(env.current()->fees().base * 2));
1198 auto const broker = env.le(minCoverBroker);
1199 BEAST_EXPECT(broker);
1201 BEAST_EXPECT((broker->at(sfDebtTotal) == loanPrincipal));
1209 "after minCoverBroker loan origination");
1212 env(loan::pay(borrower, loanKeylet.key, iou(loanPrincipal).value()));
1214 *
this, env, vaultKeylet, {}, {loanKeylet},
"after minCoverBroker loan payment");
1225 using namespace loan;
1228 "Lending: paying a FixedPrecision loan off in full allows VaultDelete once the "
1229 "loan and broker are removed");
1232 auto const [issuer, owner, depositor, asset] =
setupIou(env);
1234 Number const vaultDeposit{1'000};
1236 Number const principal = vaultDeposit;
1238 auto const fixture =
setupLendingVault(env, owner, depositor, asset, vaultDeposit);
1239 auto const loanKeylet =
openLoan(env, fixture, principal, paymentTotal);
1244 auto const loanSle0 = env.le(loanKeylet);
1245 if (!BEAST_EXPECT(loanSle0))
1247 Number const periodicPayment = loanSle0->at(sfPeriodicPayment);
1248 std::int32_t const loanScale = loanSle0->at(sfLoanScale);
1250 env(pay(depositor, loanKeylet.key, asset(payoff).value()));
1255 auto const loanAfterPayoff = env.le(loanKeylet);
1256 if (!BEAST_EXPECT(loanAfterPayoff))
1259 BEAST_EXPECT(loanAfterPayoff->at(sfPaymentRemaining) == 0);
1261 auto const brokerSle = env.le(fixture.brokerKeylet);
1262 if (BEAST_EXPECT(brokerSle))
1267 env(vault.del({.owner = owner, .id = fixture.vaultKeylet.key}), Ter(
tecHAS_OBLIGATIONS));
1272 env(loan::del(depositor, loanKeylet.key));
1274 env(loan_broker::del(owner, fixture.brokerKeylet.key));
1280 auto const vaultSleFull = env.le(fixture.vaultKeylet);
1281 if (!BEAST_EXPECT(vaultSleFull))
1283 Number const remaining = vaultSleFull->at(sfAssetsAvailable);
1284 env(fixture.vault.withdraw(
1285 {.depositor = depositor, .id = fixture.vaultKeylet.key, .amount = asset(remaining)}));
1288 auto const vaultSleEmpty = env.le(fixture.vaultKeylet);
1289 if (!BEAST_EXPECT(vaultSleEmpty))
1293 env(vault.del({.owner = owner, .id = fixture.vaultKeylet.key}), Ter(
tesSUCCESS));
1295 BEAST_EXPECT(!env.le(fixture.vaultKeylet));
1308 using namespace loan;
1310 testcase(
"LoanSet rejects origination on an already-coarsened FixedPrecision vault");
1313 auto const [issuer, owner, depositor, asset] =
1314 setupIou(env, {.depositorTrust = 30'000'000, .depositorFunds = 10'000'000});
1316 Number const depositAmount{899'999};
1320 auto const fixture =
1328 Number const loanPrincipal{700'000};
1330 auto const coarseningLoanKeylet =
1332 env(
set(depositor, fixture.brokerKeylet.key, loanPrincipal),
1335 kGracePeriod(gracePeriod),
1336 kPaymentInterval(paymentInterval),
1337 kPaymentTotal(paymentTotal),
1338 Sig(sfCounterpartySignature, owner),
1339 Fee(env.current()->fees().base * 2));
1342 auto const loanSle = env.le(coarseningLoanKeylet);
1343 if (!BEAST_EXPECT(loanSle))
1345 std::uint32_t const dueDate = loanSle->at(sfNextPaymentDueDate);
1347 int const overdueDays = 800;
1354 Number const latePaymentAmount = loanPrincipal * 10;
1357 coarseningLoanKeylet.key,
1358 asset(latePaymentAmount).value(),
1359 tfLoanLatePayment));
1362 auto const vaultSle = env.le(fixture.vaultKeylet);
1363 if (!BEAST_EXPECT(vaultSle))
1370 Number const minimalPrincipal{1};
1372 env(
set(depositor, fixture.brokerKeylet.key, minimalPrincipal),
1374 kGracePeriod(gracePeriod),
1375 kPaymentInterval(paymentInterval),
1376 kPaymentTotal(singlePaymentTotal),
1377 Sig(sfCounterpartySignature, owner),
1378 Fee(env.current()->fees().base * 2),
1382 checkVaultLoanSums(env, fixture, {coarseningLoanKeylet},
"already-coarsened rejection");
1399 using namespace loan;
1403 char const* name =
nullptr;
1407 bool ownerIsBorrower =
false;
1410 Number borrowerTarget{0};
1415 Number const splitFee{15, -10};
1416 Number const borrowerTarget{1'000'000'000'000'003LL, -9};
1417 Number const ownerTarget{1'000'000'000'000'004LL, -9};
1418 Row
const rows[] = {
1420 .name =
"Lending: a terminal fee that rounds differently on the borrower's and "
1421 "the owner's trust lines",
1422 .principal =
Number{9, -10},
1425 .ownerTarget = ownerTarget,
1426 .borrowerTarget = borrowerTarget,
1427 .ownerChange =
Number{2, -9},
1430 .name =
"Lending: a non-terminal fee that rounds differently on the borrower's "
1431 "and the owner's trust lines",
1432 .principal =
Number{2, -9},
1435 .ownerTarget = ownerTarget,
1436 .borrowerTarget = borrowerTarget,
1437 .ownerChange =
Number{2, -9},
1442 .name =
"Lending: a vault credit that rounds away on an owner-borrower's trust "
1443 "line with a self-paid fee",
1444 .principal =
Number{2, -9},
1447 .ownerIsBorrower =
true,
1448 .ownerTarget =
Number{20'000'000},
1449 .ownerChange =
Number{0},
1452 for (
auto const& row : rows)
1458 auto const& [issuer, owner, depositor, asset] = accounts;
1459 Account const dustBorrower{
"dustBorrower"};
1461 Account const& borrower = row.ownerIsBorrower ? owner : dustBorrower;
1462 Number const fee = row.fee;
1473 .principal = row.principal,
1474 .paymentTotal = row.paymentTotal,
1476 .borrower = borrower,
1481 auto const& loanKeylet = coarsened.
loanKeylets[1];
1483 for (
auto const& [holder, target] :
1488 env(trust(*holder, asset(target * 2)));
1490 Number const current = env.balance(*holder, asset).value();
1493 BEAST_EXPECT(env.balance(*holder, asset).value() == target);
1496 auto const loanBefore = env.le(loanKeylet);
1497 if (!BEAST_EXPECT(loanBefore))
1499 Number const periodic = loanBefore->at(sfPeriodicPayment);
1500 std::uint32_t const remainingBefore = loanBefore->at(sfPaymentRemaining);
1501 Number const ownerBefore = env.balance(owner, asset).value();
1503 env(pay(borrower, loanKeylet.key, asset(periodic + fee).value()));
1506 auto const loanAfter = env.le(loanKeylet);
1507 if (!BEAST_EXPECT(loanAfter))
1509 BEAST_EXPECT(loanAfter->at(sfPaymentRemaining) == remainingBefore - 1);
1510 BEAST_EXPECT(env.balance(owner, asset).value() - ownerBefore == row.ownerChange);
1521 using namespace loan;
1524 "Lending: a CashBasis fee that rounds differently on the borrower's and the owner's "
1527 Env env(*
this,
features() - featureLendingProtocolV1_2);
1529 auto const& [issuer, owner, depositor, asset] = accounts;
1530 Account const borrower{
"dustBorrower"};
1537 auto const fixture =
1539 auto const brokerSle = env.le(fixture.brokerKeylet);
1540 if (!BEAST_EXPECT(brokerSle))
1542 std::uint32_t const loanSequence = brokerSle->at(sfLoanSequence);
1543 auto const loanKeylet =
1545 auto const growKeylet =
1548 Number const fee{15, -10};
1549 env(
set(borrower, fixture.brokerKeylet.key,
Number{1}),
1551 kPaymentInterval(year),
1553 kLoanServiceFee(fee),
1554 Sig(sfCounterpartySignature, owner),
1555 Fee(env.current()->fees().base * 2));
1557 env(
set(depositor, fixture.brokerKeylet.key,
Number{10'000}),
1559 kPaymentInterval(year),
1561 Sig(sfCounterpartySignature, owner),
1562 Fee(env.current()->fees().base * 2));
1564 auto const growLoan = env.le(growKeylet);
1565 if (!BEAST_EXPECT(growLoan && env.le(loanKeylet)))
1567 env(pay(depositor, growKeylet.key, asset(
Number(growLoan->at(sfPeriodicPayment))).value()));
1570 for (
auto const& [holder, target] : {
1575 env(trust(*holder, asset(
Number{3'000'000})));
1577 Number const current = env.balance(*holder, asset).value();
1580 BEAST_EXPECT(env.balance(*holder, asset).value() == target);
1582 auto const vaultSle = env.le(fixture.vaultKeylet);
1583 if (!BEAST_EXPECT(vaultSle))
1586 Number const ownerBefore = env.balance(owner, asset).value();
1588 env(pay(borrower, loanKeylet.key, asset(
Number{1} + fee).value()));
1591 auto const loanAfter = env.le(loanKeylet);
1592 if (!BEAST_EXPECT(loanAfter))
1594 BEAST_EXPECT(loanAfter->at(sfPaymentRemaining) == 0);
1595 BEAST_EXPECT(env.balance(owner, asset).value() - ownerBefore ==
Number(2, -9));
TestcaseT testcase
Memberspace for declaring test cases.
static LendingFixture setupLendingVault(test::jtx::Env &env, test::jtx::Account const &owner, test::jtx::Account const &depositor, PrettyAsset const &asset, Number const &depositAmount, std::chrono::seconds investmentWindow=std::chrono::seconds{1 '000 '000}, std::optional< std::uint8_t > scale=std::nullopt, TenthBips32 coverRateMinimum=TenthBips32(0), TenthBips32 coverRateLiquidation=TenthBips32(0), TenthBips16 managementFeeRate=TenthBips16(0))
static void fundIouHolder(test::jtx::Env &env, test::jtx::Account const &holder, AssetAccounts const &accounts, Number const &trustLimit, Number const &funds)
static Keylet openLoan(test::jtx::Env &env, LendingFixture const &fixture, Number const &principal, std::uint32_t paymentTotal, TenthBips32 interestRate=TenthBips32(0), std::uint32_t flags=0, std::uint32_t paymentInterval=120, std::uint32_t gracePeriod=60)
CoarsenedVault coarsenVault(test::jtx::Env &env, test::jtx::Account const &owner, test::jtx::Account const &depositor, PrettyAsset const &asset)
static AssetAccounts setupCoarsenIou(test::jtx::Env &env, bool clawback=false)
void checkVaultLoanSums(test::jtx::Env &env, CoarsenedVault const &coarsened, std::string const &label={})
static constexpr std::uint32_t kLongPaymentInterval
void testLateInterestCoarsensVault()
void testLendingAssetsDeployedEarlyFullPayoff()
void testCoarseningPaymentCreditNeverExceedsPaid()
static Number const kDustBorrowerTrustLimit
void testLendingAssetsDeployedIntegralAsset()
void testCoarsenedVaultSubUnitRemainderPayments()
void testLendingAssetsDeployedInterestPayoff()
void testOriginationRejectedOnAlreadyCoarsenedVault()
void testLendingAssetsDeployedOverpayment()
void testLendingAssetsDeployedPayments()
void testCoarsenedVaultCreditCrossesPowerOfTen()
void testVaultDeleteAllowedAfterLoanPayoff()
void testFeeLegRoundsUnequally()
static Number const kDustBorrowerFunds
void testCoarsenedVaultTerminalCloseFeeToCoverFloorsToZero()
void testCoarsenedVaultTerminalCloseWithFee()
void testCoarsenedVaultCreditFlooring()
void testFeeLegRoundsUnequallyCashBasis()
void run() override
Runs the suite.
void testMinCoverBrokerLoanPayment()
void testCoarsenedVaultCreditKeepsAvailableGridDigit()
void testCoarsenedVaultTerminalCloseFeeToCoverNonZero()
std::chrono::time_point< NetClock > time_point
std::chrono::duration< rep, period > duration
Number is a floating point type that can represent a wide range of values.
static constexpr SeqProxy rawSequence(std::uint32_t v)
Factory function to return a sequence-based SeqProxy.
static Number smallestPowerOfTenAbove(Number const &x)
static FeatureBitset features()
static AssetAccounts setupIou(test::jtx::Env &env, IouParams const ¶ms)
VaultSnapshot snapshotVault(test::jtx::Env &env, Keylet const &vaultKeylet, PrettyAsset const &asset)
SLE::const_pointer expectVault(test::jtx::Env const &env, Keylet const &vaultKeylet, VaultExpect const &expected)
static AssetAccounts setupMpt(test::jtx::Env &env, MptParams const ¶ms)
Number expectAvailableAtSixteenDigits(test::jtx::Env const &env, Keylet const &vaultKeylet, PrettyAsset const &asset)
test::jtx::PrettyAsset PrettyAsset
Immutable cryptographic account descriptor.
Keylet loanBroker(AccountID const &owner, SeqProxy const &seq) noexcept
Keylet loan(UInt256 const &loanBrokerID, SeqProxy const &loanSeq) noexcept
constexpr TenthBips32 kMaxLateInterestRate
The maximum premium added to the interest rate for late payments on a loan in 1/10 bips.
json::Value pay(AccountID const &account, AccountID const &to, AnyAmount amount)
Create a payment.
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.
bool set(T &target, std::string const &name, Section const §ion)
Set a value from a configuration Section If the named value is not found or doesn't parse as a T,...
constexpr TenthBips32 percentageToTenthBips(std::uint32_t percentage)
int scale(Number const &number, Asset const &asset)
Get the scale of a Number for a given asset.
int getVaultScale(SLE::ConstRef vault)
Return the Vault's current live exponent.
TenthBips< std::uint32_t > TenthBips32
bool after(NetClock::time_point now, std::uint32_t mark)
Has the specified time passed?
int getVaultBaseScale(SLE::ConstRef vault)
Return the Vault's base exponent.
void roundToAsset(A const &asset, Number &value)
Round an arbitrary precision Number IN PLACE to the precision of a given Asset.
Number roundPeriodicPayment(Asset const &asset, Number const &periodicPayment, std::int32_t scale)
Ensure the periodic payment is always rounded consistently.
Number getAssetsTotal(SLE::ConstRef vault)
Return the Vault's current assets total.
VaultVersion getVaultVersion(SLE::ConstRef vault)
Resolves a Vault's LEVersion.
BEAST_DEFINE_TESTSUITE(AccountTxPaging, app, xrpl)
std::vector< Keylet > loanKeylets