1#include <test/app/lending/LoanManageFixedPrecisionBase.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/mpt.h>
8#include <test/jtx/pay.h>
9#include <test/jtx/ter.h>
10#include <test/jtx/trust.h>
11#include <test/jtx/vault.h>
13#include <xrpl/basics/Number.h>
14#include <xrpl/basics/chrono.h>
15#include <xrpl/beast/unit_test/suite.h>
16#include <xrpl/beast/utility/Zero.h>
17#include <xrpl/ledger/helpers/LendingHelpers.h>
18#include <xrpl/ledger/helpers/VaultHelpers.h>
19#include <xrpl/protocol/Asset.h>
20#include <xrpl/protocol/Indexes.h>
21#include <xrpl/protocol/Issue.h>
22#include <xrpl/protocol/Keylet.h>
23#include <xrpl/protocol/LedgerFormats.h>
24#include <xrpl/protocol/MPTIssue.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>
54 testcase(
"Lending: defaulting a Loan reduces AssetsDeployed by its outstanding principal");
57 auto const [issuer, owner, depositor, asset] =
setupIou(env);
64 expectVault(env, fixture.vaultKeylet, {.assetsDeployed = Number{0}});
76 testcase(
"Lending: default removes only the defaulted Loan's scheduled interest");
79 auto const [issuer, owner, depositor, asset] =
setupIou(env);
85 auto const scheduledInterest = [&](
Keylet const& k) {
86 auto const loanSle = env.le(k);
87 if (!BEAST_EXPECT(loanSle))
89 return Number(loanSle->at(sfTotalValueOutstanding)) -
90 Number(loanSle->at(sfPrincipalOutstanding)) -
91 Number(loanSle->at(sfManagementFeeOutstanding));
93 auto const yield = [&] {
94 auto const vaultSle = env.le(fixture.vaultKeylet);
95 if (!BEAST_EXPECT(vaultSle))
97 return Number(vaultSle->at(sfYieldUnrealized));
100 Number const defaultedInterest = scheduledInterest(defaulted);
101 Number const keptInterest = scheduledInterest(kept);
104 BEAST_EXPECT(yield() == defaultedInterest + keptInterest);
108 BEAST_EXPECT(yield() == keptInterest);
109 BEAST_EXPECT(scheduledInterest(kept) == keptInterest);
110 expectVault(env, fixture.vaultKeylet, {.assetsDeployed = Number{200}});
111 checkVaultLoanSums(env, fixture, {defaulted, kept},
"default with interest");
118 using namespace loan;
119 using namespace loan_broker;
121 testcase(
"Lending: default with partial First-Loss Capital cover");
124 auto const [issuer, owner, depositor, asset] =
setupIou(env, {.ownerFunds = 40});
139 env(coverDeposit(owner, fixture.brokerKeylet.key, asset(30).value()));
144 auto const brokerSleBefore = env.le(fixture.brokerKeylet);
145 if (!BEAST_EXPECT(brokerSleBefore))
147 Number const coverBefore = brokerSleBefore->at(sfCoverAvailable);
148 BEAST_EXPECT(coverBefore ==
Number{30});
150 auto const loanSle = env.le(loanKeylet);
151 if (!BEAST_EXPECT(loanSle))
155 auto const before =
snapshotVault(env, fixture.vaultKeylet, asset);
156 Number const principalBefore = loanSle->at(sfPrincipalOutstanding);
157 BEAST_EXPECT(before.assetsDeployed == principalBefore);
158 checkVaultLoanSums(env, fixture, {loanKeylet},
"partial cover default, before default");
160 env(manage(owner, loanKeylet.key, tfLoanDefault));
164 auto const brokerSleAfter = env.le(fixture.brokerKeylet);
165 if (!BEAST_EXPECT(brokerSleAfter))
168 Number const coverAfter = brokerSleAfter->at(sfCoverAvailable);
169 Number const coverMoved = coverBefore - coverAfter;
170 BEAST_EXPECT(coverMoved ==
Number{15});
171 BEAST_EXPECT(coverAfter ==
Number{15});
174 BEAST_EXPECT(before.assetsDeployed -
after.assetsDeployed == principalBefore);
176 BEAST_EXPECT(
after.available - before.available == coverMoved);
177 BEAST_EXPECT(before.total -
after.total == principalBefore - coverMoved);
179 checkVaultLoanSums(env, fixture, {loanKeylet},
"partial cover default, after default");
186 using namespace loan;
189 "Lending: defaulting an impaired Loan reverses LossUnrealized and drops "
193 auto const [issuer, owner, depositor, asset] =
setupIou(env);
201 auto const vaultSle = env.le(fixture.vaultKeylet);
202 if (!BEAST_EXPECT(vaultSle))
204 Number const lossUnrealizedAtImpair = vaultSle->at(sfLossUnrealized);
205 BEAST_EXPECT(lossUnrealizedAtImpair ==
Number{300});
206 Number const assetsDeployedBeforeDefault = vaultSle->at(sfAssetsDeployed);
207 BEAST_EXPECT(assetsDeployedBeforeDefault ==
Number{300});
208 checkVaultLoanSums(env, fixture, {loanKeylet},
"default of impaired loan, after impair");
212 auto const vaultSleAfter = env.le(fixture.vaultKeylet);
213 if (!BEAST_EXPECT(vaultSleAfter))
217 BEAST_EXPECT(vaultSleAfter->at(sfLossUnrealized) ==
beast::kZero);
218 BEAST_EXPECT(vaultSleAfter->at(sfAssetsDeployed) ==
beast::kZero);
220 assetsDeployedBeforeDefault - vaultSleAfter->at(sfAssetsDeployed) ==
Number{300});
221 BEAST_EXPECT(vaultSleAfter->at(sfAssetsTotal) ==
getAssetsTotal(vaultSleAfter));
222 checkVaultLoanSums(env, fixture, {loanKeylet},
"default of impaired loan, after default");
233 Number const& depositAmount,
238 using namespace loan;
240 auto const fixture =
setupLendingVault(env, owner, depositor, asset, depositAmount);
241 auto const loanKeylet =
openLoan(env, fixture, principal, 3);
243 auto const expectLossAndAssetsDeployed = [&](
Number const& loss,
244 Number const& assetsDeployed) {
245 auto const vaultSle = env.
le(fixture.vaultKeylet);
246 if (!BEAST_EXPECT(vaultSle))
248 BEAST_EXPECT(
Number(vaultSle->at(sfLossUnrealized)) == loss);
249 BEAST_EXPECT(
Number(vaultSle->at(sfAssetsDeployed)) == assetsDeployed);
253 expectLossAndAssetsDeployed(principal, principal);
257 env(manage(owner, loanKeylet.key, tfLoanUnimpair));
259 expectLossAndAssetsDeployed(0, principal);
262 env(manage(owner, loanKeylet.key, tfLoanImpair));
267 expectLossAndAssetsDeployed(0, 0);
277 testcase(
"Lending: FP XRP vault -- impair, unimpair, impair, default");
280 Account const depositor{
"depositor"};
284 env.fund(XRP(1'000'000), owner, depositor);
288 env, owner, depositor, asset,
Number{1'000},
Number{300},
"XRP");
292 testcase(
"Lending: FP MPT vault -- impair, unimpair, impair, default");
295 auto const [issuer, owner, depositor, asset] =
296 setupMpt(env, {.maxAmt = 100'000, .withDepositor =
true, .holderFunds = 1'000});
299 env, owner, depositor, asset,
Number{1'000},
Number{300},
"MPT");
307 using namespace loan;
308 using namespace loan_broker;
310 testcase(
"Lending: default with partial First-Loss Capital cover on a coarsened vault");
313 auto const [issuer, owner, depositor, asset] =
setupIou(
316 .depositorTrust = 30'000'000,
317 .ownerTrust = 1'000'000,
318 .depositorFunds = 10'000'000,
319 .ownerFunds = 200'000,
325 Number const defaultLoanPrincipal{50'000};
335 .principal = defaultLoanPrincipal,
336 .paymentInterval = 1000 * 24 * 60 * 60,
341 .coverDeposit =
Number{150'000},
343 auto const& vaultKeylet = coarsened.fixture.vaultKeylet;
344 auto const& brokerKeylet = coarsened.fixture.brokerKeylet;
345 auto const& loanKeylet = coarsened.loanKeylets[1];
348 auto const brokerSleBefore = env.le(brokerKeylet);
349 auto const loanSleBefore = env.le(loanKeylet);
350 if (!BEAST_EXPECT(brokerSleBefore) || !BEAST_EXPECT(loanSleBefore))
352 Number const coverBefore = brokerSleBefore->at(sfCoverAvailable);
353 BEAST_EXPECT(coverBefore ==
Number{150'000});
354 Number const principalBefore = loanSleBefore->at(sfPrincipalOutstanding);
355 BEAST_EXPECT(principalBefore == defaultLoanPrincipal);
360 env(manage(owner, loanKeylet.key, tfLoanDefault));
364 auto const brokerSleAfter = env.le(brokerKeylet);
365 if (!BEAST_EXPECT(brokerSleAfter))
368 Number const coverMoved = coverBefore -
Number(brokerSleAfter->at(sfCoverAvailable));
373 BEAST_EXPECT(coverMoved < defaultLoanPrincipal);
374 BEAST_EXPECT(coverMoved <= coverBefore);
379 auto const vaultSle = env.le(vaultKeylet);
380 if (!BEAST_EXPECT(vaultSle))
384 BEAST_EXPECT(coverMoved <= rateAmount);
385 BEAST_EXPECT(rateAmount - coverMoved < liveUnit);
389 Account const brokerPseudo{
"brokerPseudo", brokerSleAfter->at(sfAccount)};
391 Number(env.balance(brokerPseudo, asset).value()) ==
392 Number(brokerSleAfter->at(sfCoverAvailable)));
397 BEAST_EXPECT(before.assetsDeployed -
after.assetsDeployed == principalBefore);
398 BEAST_EXPECT(
after.available - before.available == coverMoved);
407 using namespace loan;
410 "Lending: repeated zero-cover defaults and an impair on a coarsened vault, then "
411 "final withdrawal stays refused");
418 Number const defaultAPrincipal{40'0000000003LL, -10};
419 Number const defaultBPrincipal{35'0000000007LL, -10};
420 Number const remainingPrincipal{30'000};
427 .loanPrincipal =
Number{300'000},
430 ExtraLoan{.principal = defaultAPrincipal},
431 ExtraLoan{.principal = defaultBPrincipal},
432 ExtraLoan{.principal = remainingPrincipal},
435 auto const& vaultKeylet = coarsened.fixture.vaultKeylet;
436 auto const& coarseningLoanKeylet = coarsened.loanKeylets[0];
437 auto const& defaultALoanKeylet = coarsened.loanKeylets[1];
438 auto const& defaultBLoanKeylet = coarsened.loanKeylets[2];
439 auto const& remainingLoanKeylet = coarsened.loanKeylets[3];
441 auto const vaultSle0 = env.le(vaultKeylet);
442 if (!BEAST_EXPECT(vaultSle0))
446 env, coarsened,
"testCoarsenedVaultMultipleDefaultsAndImpair (after coarsening)");
450 env(manage(owner, defaultALoanKeylet.key, tfLoanImpair));
452 env(manage(owner, defaultALoanKeylet.key, tfLoanDefault));
455 env, coarsened,
"testCoarsenedVaultMultipleDefaultsAndImpair (after defaultA)");
457 env(manage(owner, defaultBLoanKeylet.key, tfLoanDefault));
460 env, coarsened,
"testCoarsenedVaultMultipleDefaultsAndImpair (after defaultB)");
463 env(manage(owner, coarseningLoanKeylet.key, tfLoanDefault));
466 env, coarsened,
"testCoarsenedVaultMultipleDefaultsAndImpair (after third default)");
468 auto const vaultSleAfterDefaults = env.le(vaultKeylet);
469 if (!BEAST_EXPECT(vaultSleAfterDefaults))
472 Number(vaultSleAfterDefaults->at(sfAssetsDeployed)) ==
Number(remainingPrincipal));
474 env(manage(owner, remainingLoanKeylet.key, tfLoanImpair));
477 env, coarsened,
"testCoarsenedVaultMultipleDefaultsAndImpair (after impair)");
479 auto const vaultSleImpaired = env.le(vaultKeylet);
480 if (!BEAST_EXPECT(vaultSleImpaired))
490 env(coarsened.fixture.vault.withdraw(
491 {.depositor = depositor, .id = vaultKeylet.key, .amount = asset(assetsTotal)}),
495 auto const vaultSleFinal = env.le(vaultKeylet);
496 if (!BEAST_EXPECT(vaultSleFinal))
499 checkVaultLoanSums(env, coarsened,
"testCoarsenedVaultMultipleDefaultsAndImpair (final)");
523 using namespace loan;
525 Number const overpayPrincipal{1'000};
526 Number const dust{1, -10};
536 .principal = overpayPrincipal,
537 .flags = tfLoanOverpayment,
539 .paymentInterval = 1000 * 24 * 60 * 60,
543 auto const& vaultKeylet = coarsened.fixture.vaultKeylet;
544 auto const& coarseningLoanKeylet = coarsened.loanKeylets[0];
545 auto const& dustLoanKeylet = coarsened.loanKeylets[1];
551 asset(overpayPrincipal - dust).value(),
555 auto const dustLoanSle = env.
le(dustLoanKeylet);
556 if (BEAST_EXPECT(dustLoanSle))
558 BEAST_EXPECT(
Number(dustLoanSle->at(sfPrincipalOutstanding)) == dust);
559 BEAST_EXPECT(dustLoanSle->at(sfPaymentRemaining) == 1);
563 env(manage(owner, coarseningLoanKeylet.key, tfLoanDefault));
567 auto const vaultSle = env.
le(vaultKeylet);
568 if (!BEAST_EXPECT(vaultSle))
571 .coarsened = std::move(coarsened),
572 .assetsDeployed =
Number{0},
576 Number const assetsDeployed = vaultSle->at(sfAssetsDeployed);
577 Number const available = vaultSle->at(sfAssetsAvailable);
578 BEAST_EXPECT(assetsDeployed == dust);
584 BEAST_EXPECT(roundedTotal == availableAmount);
587 .coarsened = std::move(coarsened),
588 .assetsDeployed = assetsDeployed,
589 .available = available,
601 using namespace loan;
604 "Lending: full-value VaultWithdraw stays refused on a coarsened vault even when "
605 "AssetsDeployed is smaller than half the live unit");
615 "testCoarsenedVaultSmallAssetsDeployedFinalWithdrawalRejected");
616 auto const& coarsened = state.coarsened;
617 auto const& vaultKeylet = coarsened.fixture.vaultKeylet;
624 auto const vaultSle = env.le(vaultKeylet);
625 if (!BEAST_EXPECT(vaultSle))
627 auto const shareMPTID = vaultSle->at(sfShareMPTID);
629 if (!BEAST_EXPECT(issuanceBefore))
632 MPTIssue{shareMPTID},
Number(issuanceBefore->getFieldU64(sfOutstandingAmount))};
634 env(coarsened.fixture.vault.withdraw(
635 {.depositor = depositor, .id = vaultKeylet.key, .amount = allShares}),
640 BEAST_EXPECT(
after.assetsDeployed == state.assetsDeployed);
641 BEAST_EXPECT(
after.available == state.available);
643 env, coarsened,
"testCoarsenedVaultSmallAssetsDeployedFinalWithdrawalRejected (final)");
653 using namespace loan;
656 "Lending: full-value VaultClawback stays refused on a coarsened vault even when "
657 "AssetsDeployed is smaller than half the live unit");
660 auto const [issuer, owner, depositor, asset] =
setupCoarsenIou(env,
true);
667 "testCoarsenedVaultSmallAssetsDeployedFullClawbackRejected");
668 auto const& coarsened = state.coarsened;
669 auto const& vaultKeylet = coarsened.fixture.vaultKeylet;
671 env(coarsened.fixture.vault.clawback(
672 {.issuer = issuer, .id = vaultKeylet.key, .holder = depositor}),
677 BEAST_EXPECT(
after.assetsDeployed == state.assetsDeployed);
678 BEAST_EXPECT(
after.available == state.available);
680 env, coarsened,
"testCoarsenedVaultSmallAssetsDeployedFullClawbackRejected (final)");
687 using namespace loan;
688 using namespace loan_broker;
691 "Lending: a default's cover credit that crosses a power of ten keeps "
692 "AssetsAvailable at 16 digits");
695 auto const [issuer, owner, depositor, asset] =
setupIou(
698 .depositorTrust = 30'000'000,
699 .ownerTrust = 1'000'000,
700 .depositorFunds = 10'000'000,
701 .ownerFunds = 200'000,
707 Number const defaultLoanPrincipal{50'000};
717 .principal = defaultLoanPrincipal,
718 .paymentInterval = 1000 * 24 * 60 * 60,
723 .coverDeposit =
Number{150'000},
729 auto const& vaultKeylet = coarsened.fixture.vaultKeylet;
730 auto const& defaultLoanKeylet = coarsened.loanKeylets[1];
733 auto const loanSleBefore = env.le(defaultLoanKeylet);
734 if (!BEAST_EXPECT(loanSleBefore))
736 Number const principalBefore = loanSleBefore->at(sfPrincipalOutstanding);
739 auto const brokerSle0 = env.le(coarsened.fixture.brokerKeylet);
740 if (!BEAST_EXPECT(brokerSle0))
742 Number const cumulativeDebtTotal = brokerSle0->at(sfDebtTotal);
743 Number const coverAvailableBefore = brokerSle0->at(sfCoverAvailable);
748 Number const rawCoverUncapped = [&] {
750 Number const minimumCover =
755 Number const rawCoverCapped =
std::min(rawCoverUncapped, coverAvailableBefore);
760 Number const margin{1'000};
761 Number const powerOfTen{100'000};
762 Number const shrinkTarget = powerOfTen - rawCoverCapped + margin;
764 BEAST_EXPECT(shrinkTarget < powerOfTen);
773 env(coarsened.fixture.vault.withdraw(
774 {.depositor = depositor, .id = vaultKeylet.key, .amount = asset(step)}));
779 BEAST_EXPECT(before.available < powerOfTen);
786 auto const vaultSleBeforeDefault = env.le(vaultKeylet);
787 auto const brokerSleBeforeDefault = env.le(coarsened.fixture.brokerKeylet);
788 if (!BEAST_EXPECT(vaultSleBeforeDefault) || !BEAST_EXPECT(brokerSleBeforeDefault))
790 STAmount const brokerRoundedCover = [&] {
793 vaultSleBeforeDefault,
794 brokerSleBeforeDefault,
805 BEAST_EXPECT(
Number(expectedCoverAmount) <= rawCoverCapped);
807 env(manage(owner, defaultLoanKeylet.key, tfLoanDefault));
811 Number const coverMoved =
after.available - before.available;
816 BEAST_EXPECT(before.assetsDeployed -
after.assetsDeployed == principalBefore);
817 BEAST_EXPECT(coverMoved ==
Number(expectedCoverAmount));
818 BEAST_EXPECT(coverMoved <= rawCoverCapped);
821 checkVaultLoanSums(env, coarsened,
"testCoarsenedVaultDefaultCoverCrossesPowerOfTenUpward");
838 using namespace loan;
839 using namespace loan_broker;
841 testcase(
"Lending: default cover rounds on a coarsened CoverAvailable grid");
844 auto const [issuer, owner, depositor, asset] =
setupIou(
847 .depositorTrust = 100'000'000'000,
848 .ownerTrust = 1'000'000,
849 .depositorFunds = 30'000'000'000,
850 .ownerFunds = 10'000,
863 env(coverDeposit(owner, fixture.brokerKeylet.key, asset(1'000)));
868 Number const serviceFee{20'000'000'000};
869 auto const brokerSle0 = env.le(fixture.brokerKeylet);
870 if (!BEAST_EXPECT(brokerSle0))
874 env(
set(depositor, fixture.brokerKeylet.key,
Number{1'000}),
875 kLoanServiceFee(serviceFee),
877 kPaymentInterval(120),
879 Sig(sfCounterpartySignature, owner),
880 Fee(env.current()->fees().base * 2));
882 Number const principalB{1234567891, -6};
883 auto const loanBKeylet =
openLoan(env, fixture, principalB, 1);
886 env(trust(issuer, owner[
"USD"](0), tfSetFreeze | tfSetDeepFreeze));
889 auto const loanASle = env.le(loanAKeylet);
890 if (!BEAST_EXPECT(loanASle))
892 Number const paymentA =
Number(loanASle->at(sfPeriodicPayment)) + serviceFee;
893 env(pay(depositor, loanAKeylet.key, asset(paymentA).value()));
896 auto const brokerSleBefore = env.le(fixture.brokerKeylet);
897 auto const vaultSleBefore = env.le(fixture.vaultKeylet);
898 if (!BEAST_EXPECT(brokerSleBefore) || !BEAST_EXPECT(vaultSleBefore))
900 Number const coverBefore = brokerSleBefore->at(sfCoverAvailable);
903 BEAST_EXPECT(coverBefore >
Number(1, 10));
904 BEAST_EXPECT(
Number(vaultSleBefore->at(sfAssetsAvailable)) <
Number(1, 10));
907 auto const before =
snapshotVault(env, fixture.vaultKeylet, asset);
909 env(manage(owner, loanBKeylet.key, tfLoanDefault), Ter(
tesSUCCESS));
913 auto const brokerSleAfter = env.le(fixture.brokerKeylet);
914 if (!BEAST_EXPECT(brokerSleAfter))
916 Number const coverAfter = brokerSleAfter->at(sfCoverAvailable);
920 Number const expectedCover{61728394, -6};
921 BEAST_EXPECT(
after.available - before.available == expectedCover);
924 BEAST_EXPECT(coverBefore - coverAfter != expectedCover);
925 BEAST_EXPECT(
abs((coverBefore - coverAfter) - expectedCover) <=
Number(5, -6));
927 Account const brokerPseudo{
"brokerPseudo", brokerSleAfter->at(sfAccount)};
928 BEAST_EXPECT(
Number(env.balance(brokerPseudo, asset).value()) == coverAfter);
931 env, fixture, {loanBKeylet},
"testDefaultCoverRoundsOnCoarsenedBrokerGrid");
947 MPTTester mpt{env, a.
issuer, kMptInitNoFund};
948 mpt.create({.maxAmt = maxAmt, .flags = tfMPTCanTransfer | tfMPTCanClawback});
949 a.
asset = mpt.issuanceID();
950 mpt.authorize({.account = a.
owner});
966 using namespace loan;
968 testcase(
"sole-holder VaultClawback below one share's value is tecPRECISION_LOSS");
971 auto const [issuer, owner, depositor, asset] =
setupClawbackMpt(env, 1'000'000, 900'000);
985 auto const vaultSle0 = env.le(fixture.vaultKeylet);
986 if (!BEAST_EXPECT(vaultSle0))
990 BEAST_EXPECT(grownTotal >= 512);
992 auto const shareMPTID = vaultSle0->at(sfShareMPTID);
994 if (!BEAST_EXPECT(issuance0))
996 BEAST_EXPECT(issuance0->getFieldU64(sfOutstandingAmount) == 2);
1004 auto const loanKeylet =
1008 auto const vaultSle1 = env.le(fixture.vaultKeylet);
1009 if (!BEAST_EXPECT(vaultSle1))
1012 BEAST_EXPECT(available == grownTotal - principal);
1013 BEAST_EXPECT(
toU64(vaultSle1, sfAssetsDeployed) == principal);
1014 BEAST_EXPECT(
toU64(vaultSle1, sfLossUnrealized) == principal);
1020 if (!BEAST_EXPECT(requested > 0))
1022 BEAST_EXPECT(2 * requested < grownTotal);
1024 env(fixture.vault.clawback({
1026 .id = fixture.vaultKeylet.key,
1027 .holder = depositor,
1028 .amount = asset(requested).value(),
1033 auto const vaultSleAfter = env.le(fixture.vaultKeylet);
1035 if (!BEAST_EXPECT(vaultSleAfter) || !BEAST_EXPECT(issuanceAfter))
1037 BEAST_EXPECT(
toU64(vaultSleAfter, sfAssetsAvailable) == available);
1038 BEAST_EXPECT(issuanceAfter->getFieldU64(sfOutstandingAmount) == 2);
1041 env, fixture, {loanKeylet},
"testSoleHolderClawbackBelowOneShareIsPrecisionLoss");
1051 using namespace loan;
1053 testcase(
"sole-holder VaultClawback above AssetsAvailable is clamped to whole shares");
1056 auto const [issuer, owner, depositor, asset] =
setupClawbackMpt(env, 1'000'000, 900'000);
1062 auto const vaultSle0 = env.le(fixture.vaultKeylet);
1063 if (!BEAST_EXPECT(vaultSle0))
1067 auto const loanKeylet =
1071 auto const shareMPTID = vaultSle0->at(sfShareMPTID);
1072 auto const vaultSle1 = env.le(fixture.vaultKeylet);
1073 if (!BEAST_EXPECT(vaultSle1))
1076 BEAST_EXPECT(available == grownTotal - principal);
1079 env(fixture.vault.clawback({
1081 .id = fixture.vaultKeylet.key,
1082 .holder = depositor,
1083 .amount = asset(grownTotal).value(),
1088 auto const vaultSleAfter = env.le(fixture.vaultKeylet);
1090 if (!BEAST_EXPECT(vaultSleAfter) || !BEAST_EXPECT(issuanceAfter))
1093 BEAST_EXPECT(issuanceAfter->getFieldU64(sfOutstandingAmount) == 1);
1094 BEAST_EXPECT(
toU64(vaultSleAfter, sfAssetsAvailable) == available - (grownTotal / 2));
1095 BEAST_EXPECT(
toU64(vaultSleAfter, sfAssetsDeployed) == principal);
1097 checkVaultLoanSums(env, fixture, {loanKeylet},
"testSoleHolderClawbackClampsToWholeShares");
1110 using namespace loan;
1113 "sole-holder full VaultClawback on a liquid/illiquid split still "
1114 "clamps to AssetsAvailable instead of tecHAS_OBLIGATIONS");
1117 auto const [issuer, owner, depositor, asset] =
setupClawbackMpt(env, 1'000'000, 900'000);
1123 auto const vaultSle0 = env.le(fixture.vaultKeylet);
1124 if (!BEAST_EXPECT(vaultSle0))
1128 auto const loanKeylet =
1132 auto const shareMPTID = vaultSle0->at(sfShareMPTID);
1134 if (!BEAST_EXPECT(issuanceBefore))
1136 BEAST_EXPECT(issuanceBefore->getFieldU64(sfOutstandingAmount) == 2);
1138 env(fixture.vault.clawback(
1139 {.issuer = issuer, .id = fixture.vaultKeylet.key, .holder = depositor}),
1143 auto const vaultSleAfter = env.le(fixture.vaultKeylet);
1145 if (!BEAST_EXPECT(vaultSleAfter) || !BEAST_EXPECT(issuanceAfter))
1147 BEAST_EXPECT(
toU64(vaultSleAfter, sfAssetsAvailable) == 0);
1148 BEAST_EXPECT(
toU64(vaultSleAfter, sfAssetsDeployed) == principal);
1151 std::uint64_t const sharesAfter = issuanceAfter->getFieldU64(sfOutstandingAmount);
1154 BEAST_EXPECT(sharesAfter == 1);
1160 "testSoleHolderFullClawbackClampsWithLiquidAndIlliquidSplit");
1167 using namespace loan;
1168 using namespace loan_broker;
1172 "Lending: a default's cover just under one ulp on an all-nines "
1173 "AssetsAvailable is forgiven, not credited negative");
1178 auto const [issuer, owner, depositor, asset] =
setupIou(
1182 .depositorTrust = 30'000'000,
1183 .ownerTrust = 1'000,
1184 .depositorFunds = 10'000'000,
1210 auto const& vaultKeylet = fixture.vaultKeylet;
1211 auto const& brokerKeylet = fixture.brokerKeylet;
1213 env(coverDeposit(owner, brokerKeylet.key, asset(100).value()));
1217 Number const target{9'999'999'999'999'999LL, -10};
1223 Number const loanAPrincipal{700'000};
1225 env(
set(depositor, brokerKeylet.key, loanAPrincipal),
1227 kLateInterestRate(kMaxLateInterestRate),
1228 kGracePeriod(gracePeriod),
1229 kPaymentInterval(120),
1231 Sig(sfCounterpartySignature, owner),
1232 Fee(env.current()->fees().base * 2));
1238 Number const loanBPrincipal{100};
1240 env(
set(depositor, brokerKeylet.key, loanBPrincipal, tfLoanOverpayment),
1242 kGracePeriod(gracePeriod),
1243 kPaymentInterval(thousandDays),
1245 Sig(sfCounterpartySignature, owner),
1246 Fee(env.current()->fees().base * 2));
1249 auto const loanASle = env.le(loanAKeylet);
1250 if (!BEAST_EXPECT(loanASle))
1252 std::uint32_t const loanADueDate = loanASle->at(sfNextPaymentDueDate);
1256 env(pay(depositor, loanAKeylet.key, asset(loanAPrincipal * 10).value(), tfLoanLatePayment));
1262 Number const clawbackTarget = target -
Number{99'003, -3};
1263 env(fixture.vault.clawback({
1265 .id = vaultKeylet.key,
1266 .holder = depositor,
1267 .amount = asset(availableAfterLoanA - clawbackTarget).value(),
1277 asset(target - availableAfterClawback).value(),
1278 tfLoanOverpayment));
1281 auto const brokerBefore = env.le(brokerKeylet);
1282 if (!BEAST_EXPECT(brokerBefore))
1284 Number const debtTotal = brokerBefore->at(sfDebtTotal);
1285 BEAST_EXPECT(debtTotal >=
Number(995, -3) && debtTotal <
Number{1});
1287 BEAST_EXPECT(before.available == target);
1288 Account const brokerAccount{
"broker", brokerBefore->at(sfAccount)};
1289 Number const coverBefore = brokerBefore->at(sfCoverAvailable);
1290 Number const brokerBalanceBefore = env.balance(brokerAccount, asset).value();
1296 env(manage(owner, loanBKeylet.key, tfLoanDefault), Ter(
tesSUCCESS));
1299 auto const loanBAfter = env.le(loanBKeylet);
1300 if (!BEAST_EXPECT(loanBAfter))
1302 BEAST_EXPECT(loanBAfter->isFlag(lsfLoanDefault));
1304 BEAST_EXPECT(
after.available == before.available);
1305 BEAST_EXPECT(
after.vaultBalance == before.vaultBalance);
1306 auto const brokerAfter = env.le(brokerKeylet);
1307 if (!BEAST_EXPECT(brokerAfter))
1309 BEAST_EXPECT(brokerAfter->at(sfCoverAvailable) == coverBefore);
1310 BEAST_EXPECT(env.balance(brokerAccount, asset).value() == brokerBalanceBefore);
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 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)
void defaultAfterGrace(test::jtx::Env &env, test::jtx::Account const &owner, Keylet const &loanKeylet)
void closePastGrace(test::jtx::Env &env, Keylet const &loanKeylet)
void impairWhenLate(test::jtx::Env &env, test::jtx::Account const &owner, Keylet const &loanKeylet)
void testCoarsenedVaultDefaultCoverCrossesPowerOfTenUpward()
void checkImpairUnimpairDefault(test::jtx::Env &env, test::jtx::Account const &owner, test::jtx::Account const &depositor, PrettyAsset const &asset, Number const &depositAmount, Number const &principal, std::string const &label)
void testCoarsenedVaultDefaultWithPartialCover()
void testLendingAssetsDeployedDefault()
void testCoarsenedVaultSmallAssetsDeployedFullClawbackRejected()
void run() override
Runs the suite.
void testDefaultRemovesOnlyThatLoansScheduledInterest()
void testLendingDefaultOfImpairedLoan()
void testLendingImpairUnimpairDefault()
void testSoleHolderClawbackBelowOneShareIsPrecisionLoss()
void testCoarsenedVaultSmallAssetsDeployedFinalWithdrawalRejected()
static AssetAccounts setupClawbackMpt(test::jtx::Env &env, std::uint64_t maxAmt, std::uint64_t holderFunds)
SmallAssetsDeployedState setupSmallAssetsDeployedVault(test::jtx::Env &env, test::jtx::Account const &owner, test::jtx::Account const &depositor, PrettyAsset const &asset, std::string const &label)
void testLendingDefaultWithPartialCover()
void testCoarsenedVaultMultipleDefaultsAndImpair()
void testSoleHolderClawbackClampsToWholeShares()
void testDefaultCoverRoundsOnCoarsenedBrokerGrid()
void testSoleHolderFullClawbackClampsWithLiquidAndIlliquidSplit()
void testDefaultCoverUnderOneUnitOnAllNinesAvailable()
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 expectCoarsened(test::jtx::Env const &env, CoarsenedVault const &coarsened)
static std::uint64_t toU64(SLE::ConstRef vault, TypedField< T > const &field)
void compoundVaultBySoleHolderLoanCycles(test::jtx::Env &env, LendingFixture const &fixture, test::jtx::Account const &depositor, PrettyAsset const &asset, int cycles)
void checkVaultLoanSums(test::jtx::Env &env, CoarsenedVault const &coarsened, std::string const &label={})
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 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.
A transaction testing environment.
bool close(NetClock::time_point closeTime, std::optional< std::chrono::milliseconds > consensusDelay=std::nullopt)
Close and advance the ledger.
SLE::const_pointer le(Account const &account) const
Return an account root.
void fund(bool setDefaultRipple, STAmount const &amount, Account const &account)
Keylet loan(UInt256 const &loanBrokerID, SeqProxy const &loanSeq) noexcept
Keylet mptokenIssuance(MPTID const &issuanceID) noexcept
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,...
Issue const & xrpIssue()
Returns an asset specifier that represents XRP.
STAmount debitToPosteriorBrokerCoverScale(SLE::ConstRef vault, SLE::ConstRef broker, STAmount const &amount, Number::RoundingMode roundingMode)
Round a cover debit (cover withdraw, cover clawback, the broker-side decrease of a default's cover cr...
constexpr TenthBips32 percentageToTenthBips(std::uint32_t percentage)
constexpr T tenthBipsOfValue(T value, TenthBips< TBips > bips)
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.
constexpr Number abs(Number x) noexcept
Number getAssetsTotal(SLE::ConstRef vault)
Return the Vault's current assets total.
STAmount creditToPosteriorAvailableScale(SLE::ConstRef vault, Number const &raw, Number::RoundingMode roundingMode)
Round a FixedPrecision cash inflow (LoanPay's credit, LoanManage's default cover credit) into AssetsA...
BEAST_DEFINE_TESTSUITE(AccountTxPaging, app, xrpl)
A pair of SHAMap key and LedgerEntryType.
test::jtx::Account issuer
test::jtx::Account depositor
test::jtx::PrettyAsset asset
Asset const & raw() const