1#include <test/app/lending/LoanTestBase.h>
2#include <test/jtx/Account.h>
3#include <test/jtx/Env.h>
4#include <test/jtx/TestHelpers.h>
5#include <test/jtx/amount.h>
6#include <test/jtx/fee.h>
7#include <test/jtx/flags.h>
8#include <test/jtx/jtx_json.h>
9#include <test/jtx/mpt.h>
10#include <test/jtx/pay.h>
11#include <test/jtx/ter.h>
12#include <test/jtx/trust.h>
13#include <test/jtx/txflags.h>
14#include <test/jtx/vault.h>
16#include <xrpl/basics/Number.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/Asset.h>
22#include <xrpl/protocol/Feature.h>
23#include <xrpl/protocol/Indexes.h>
24#include <xrpl/protocol/Issue.h>
25#include <xrpl/protocol/Keylet.h>
26#include <xrpl/protocol/Protocol.h>
27#include <xrpl/protocol/SField.h>
28#include <xrpl/protocol/STAmount.h>
29#include <xrpl/protocol/SeqProxy.h>
30#include <xrpl/protocol/TER.h>
31#include <xrpl/protocol/TxFlags.h>
32#include <xrpl/protocol/Units.h>
53 using namespace std::chrono_literals;
54 Env env{*
this, features};
59 Account const borrower{
"borrower"};
62 env.
fund(
XRP(1'000'000'00), issuer, lender, borrower, victim);
66 auto const asset = issuer[
"USD"];
67 env(
trust(lender, asset(100000)));
68 env(
trust(borrower, asset(100000)));
69 env(
trust(victim, asset(100000)));
70 env(
pay(issuer, lender, asset(50000)));
71 env(
pay(issuer, borrower, asset(50000)));
72 env(
pay(issuer, victim, asset(50000)));
76 .vaultDeposit = 10000,
86 if (!BEAST_EXPECT(brokerSle))
90 BEAST_EXPECT(brokerSle->at(sfOwnerCount) == 0);
94 auto const loanSequence = brokerSle->at(sfLoanSequence);
100 auto const& vaultKeylet = broker.vaultKeylet();
103 auto const vaultSle = env.
le(vaultKeylet);
104 Number const assetsTotal = vaultSle->at(sfAssetsTotal);
105 Number const assetsAvail = vaultSle->at(sfAssetsAvailable);
109 log <<
" AssetsAvailable: " << assetsAvail <<
std::endl;
110 log <<
" Difference: " << (assetsTotal - assetsAvail) <<
std::endl;
113 BEAST_EXPECT(assetsAvail == assetsTotal);
114 BEAST_EXPECT(assetsAvail == broker.asset(brokerParams.
vaultDeposit).number());
117 Keylet const& loanKeylet = *loanKeyletOpt;
122 .principalRequest =
Number{100},
125 .payInterval = 86400 * 6,
126 .gracePd = 86400 * 5,
129 env(loanParams(env, broker));
136 auto const vaultSle = env.
le(vaultKeylet);
137 Number const assetsTotal = vaultSle->at(sfAssetsTotal);
138 Number const assetsAvail = vaultSle->at(sfAssetsAvailable);
142 log <<
" AssetsAvailable: " << assetsAvail <<
std::endl;
143 log <<
" Difference: " << (assetsTotal - assetsAvail) <<
std::endl;
145 auto const loanSle = env.
le(loanKeylet);
146 if (!BEAST_EXPECT(loanSle))
151 log <<
" ValueOutstanding: " << state.valueOutstanding <<
std::endl;
152 log <<
" PrincipalOutstanding: " << state.principalOutstanding <<
std::endl;
153 log <<
" InterestOutstanding: " << state.interestOutstanding() <<
std::endl;
154 log <<
" InterestDue: " << state.interestDue <<
std::endl;
155 log <<
" FeeDue: " << state.managementFeeDue <<
std::endl;
159 BEAST_EXPECT(assetsAvail < assetsTotal);
165 broker.asset(brokerParams.
vaultDeposit + state.interestDue).number());
174 auto const vaultSle2 = env.
le(vaultKeylet);
175 Number const assetsTotal2 = vaultSle2->at(sfAssetsTotal);
176 Number const assetsAvail2 = vaultSle2->at(sfAssetsAvailable);
180 log <<
" AssetsAvailable: " << assetsAvail2 <<
std::endl;
181 log <<
" Difference: " << (assetsTotal2 - assetsAvail2) <<
std::endl;
184 BEAST_EXPECT(assetsAvail2 == assetsTotal2);
191 testcase(
"Minimum cover rounding allows undercoverage (XRP)");
196 Env env{*
this, features};
198 Account const lender{
"lender"};
199 Account const borrower{
"borrower"};
201 env.
fund(
XRP(200'000), lender, borrower);
205 Vault const vault{env};
206 auto [vaultCreate, vaultKeylet] = vault.create({.owner = lender, .asset =
xrpIssue()});
209 BEAST_EXPECT(env.
le(vaultKeylet));
215 .vaultDeposit = 1'000,
224 env(
loan::set(borrower, brokerInfo.brokerID, xrpAsset(804).value()),
226 Sig(sfCounterpartySignature, lender),
233 BEAST_EXPECT(brokerSle))
236 BEAST_EXPECT(brokerSle->at(sfDebtTotal) ==
Number(804));
241 env(coverWithdraw(lender, brokerInfo.brokerID, xrpAsset(2).value()),
248 env(coverWithdraw(lender, brokerInfo.brokerID, xrpAsset(1).value()));
254 BEAST_EXPECT(brokerSle))
257 BEAST_EXPECT(brokerSle->at(sfCoverAvailable) == xrpAsset(81).value());
258 BEAST_EXPECT(brokerSle->at(sfDebtTotal) ==
Number(804));
262 log <<
"Theoretical min cover: " << theoreticalMin <<
std::endl;
263 BEAST_EXPECT(
Number(804, -1) == theoreticalMin);
270 testcase(
"Rounding manipulation does not permit yield theft");
272 using namespace loan;
276 Account const issuer{
"issuer"};
277 Account const lender{
"lender"};
278 Account const borrower{
"borrower"};
280 env.
fund(
XRP(1000), issuer, lender, borrower);
285 env(
trust(lender, iou(100'000'000)));
286 env(
trust(borrower, iou(100'000'000)));
287 env(
pay(issuer, lender, iou(100'000'000)));
288 env(
pay(issuer, borrower, iou(100'000'000)));
297 .vaultDeposit = 5'000'000,
298 .debtMax =
Number{100'000'000},
299 .coverDeposit = 500'000,
301 auto const [currentSeq, vaultKeylet] = [&] {
303 if (!BEAST_EXPECT(brokerSle))
305 auto const currentSeq = brokerSle->at(sfLoanSequence);
306 auto const vaultKeylet =
keylet::vault(brokerSle->at(sfVaultID));
311 Number const principal = 1'000'000;
316 auto const loanSetFee =
Fee(env.
current()->fees().base * 2);
317 env(
set(borrower, brokerInfo.brokerID, iou(principal).value(), flags),
318 Sig(sfCounterpartySignature, lender),
327 auto const borrowerBalance = [&] {
return env.
balance(borrower, iou); };
328 auto const borrowerScale =
static_cast<STAmount const&
>(borrowerBalance()).exponent();
330 auto const loanKeylet =
333 auto const loanSle = env.
le(loanKeylet);
334 if (!BEAST_EXPECT(loanSle))
337 return STAmount{iou, loanSle->at(sfPeriodicPayment)};
339 if (!maybePeriodicPayment)
341 auto const periodicPayment = *maybePeriodicPayment;
342 auto const roundedPayment =
347 STAmount const attackPayment = periodicPayment + paymentBuffer;
350 auto const vault = env.
le(vaultKeylet);
351 if (!BEAST_EXPECT(vault))
353 return vault->at(sfAssetsTotal);
355 if (!maybeInitialVaultAssets)
357 auto const initialVaultAssets = *maybeInitialVaultAssets;
360 int yieldTheftCount = 0;
361 auto previousAssetsTotal = initialVaultAssets;
363 for (
int i = 0; i < 100; ++i)
365 auto const balanceBefore = borrowerBalance();
366 env(
pay(borrower, loanKeylet.key, attackPayment, flags));
368 auto const borrowerDelta = balanceBefore - borrowerBalance();
369 BEAST_EXPECT(borrowerDelta.signum() == roundedPayment.signum());
371 auto const loanSle = env.
le(loanKeylet);
372 if (!BEAST_EXPECT(loanSle))
374 auto const updatedPayment =
STAmount{iou, loanSle->at(sfPeriodicPayment)};
379 (updatedPayment == periodicPayment) ||
380 (flags == tfLoanOverpayment && i >= 2 && updatedPayment < periodicPayment));
382 auto const currentVaultSle = env.
le(vaultKeylet);
383 if (!BEAST_EXPECT(currentVaultSle))
386 auto const currentAssetsTotal = currentVaultSle->at(sfAssetsTotal);
387 auto const delta = currentAssetsTotal - previousAssetsTotal;
390 (delta ==
beast::kZero && borrowerDelta <= roundedPayment) ||
391 (delta >
beast::kZero && borrowerDelta > roundedPayment));
395 if (delta ==
beast::kZero && borrowerDelta > roundedPayment)
400 previousAssetsTotal = currentAssetsTotal;
403 BEAST_EXPECTS(yieldTheftCount == 0,
std::to_string(yieldTheftCount));
427 if (!features[fixCleanup3_2_0])
430 testcase(
"edge: integer MPT principal stuck mid-loan completes via final");
433 Env env(*
this, features);
435 Account const issuer{
"issuer"};
436 Account const lender{
"lender"};
437 Account const borrower{
"borrower"};
439 env.
fund(
XRP(100'000), issuer, lender, borrower);
443 mptt.
create({.maxAmt = 100'000, .flags = tfMPTCanTransfer});
449 env(
pay(issuer, lender, asset(10'000)));
450 env(
pay(issuer, borrower, asset(10'000)));
456 .vaultDeposit =
Number{5'000},
467 Sig(sfCounterpartySignature, lender),
474 auto const borrowerStart = env.
balance(borrower, asset).
value();
487 for (
int i = 0; i < 3; ++i)
492 auto const sle = env.
le(loanKeylet);
493 if (!BEAST_EXPECT(sle))
495 BEAST_EXPECT(sle->at(sfPrincipalOutstanding) == expectedPO[i]);
496 BEAST_EXPECT(sle->at(sfTotalValueOutstanding) == expectedTVO[i]);
497 BEAST_EXPECT(sle->at(sfPaymentRemaining) == expectedRemaining[i]);
498 if (expectedRemaining[i] == 0)
499 BEAST_EXPECT(sle->at(~sfNextPaymentDueDate).value_or(0) == 0);
504 auto const borrowerEnd = env.
balance(borrower, asset).
value();
505 BEAST_EXPECT(borrowerStart - borrowerEnd == asset(3).value());
512 auto testLoanCoverMinimumRoundingExploit = [&,
this](
Number const& principalRequest) {
513 testcase <<
"LoanBrokerCoverClawback drains cover via rounding"
514 <<
" principalRequested=" <<
to_string(principalRequest);
517 using namespace loan;
520 Env env(*
this, features);
522 Account const issuer{
"issuer"};
523 Account const lender{
"lender"};
524 Account const borrower{
"borrower"};
526 env.fund(
XRP(1'000'000'000), issuer, lender, borrower);
529 env(
fset(issuer, asfAllowTrustLineClawback));
532 PrettyAsset
const asset = issuer[iouCurrency];
533 env(
trust(lender, asset(2'000'0000)));
534 env(
trust(borrower, asset(2'000'0000)));
537 env(
pay(issuer, lender, asset(2'000'0000)));
543 auto const loanSetFee = Fee(env.current()->fees().base * 2);
545 set(borrower, broker.brokerID, principalRequest),
546 Sig(sfCounterpartySignature, lender),
555 BEAST_EXPECT(brokerBefore);
559 Number
const debtOutstanding = brokerBefore->at(sfDebtTotal);
560 Number
const coverAvailableBefore = brokerBefore->at(sfCoverAvailable);
562 BEAST_EXPECT(debtOutstanding > Number{});
563 BEAST_EXPECT(coverAvailableBefore > Number{});
566 <<
" cover_available=" <<
to_string(coverAvailableBefore);
568 env(
coverClawback(issuer, 0), loanBrokerID(broker.brokerID));
572 BEAST_EXPECT(brokerAfter);
576 Number
const debtAfter = brokerAfter->at(sfDebtTotal);
578 BEAST_EXPECT(debtAfter == debtOutstanding);
580 Number
const coverAvailableAfter = brokerAfter->at(sfCoverAvailable);
584 BEAST_EXPECT(coverAvailableAfter != Number{});
588 testLoanCoverMinimumRoundingExploit(Number{1, -30});
589 testLoanCoverMinimumRoundingExploit(Number{1, -20});
590 testLoanCoverMinimumRoundingExploit(Number{1, -10});
591 testLoanCoverMinimumRoundingExploit(Number{1, 1});
629 testcase(
"bug: doOverpayment asserts 'principal change agrees'");
632 using namespace loan;
650 Number principalOutstanding;
651 Number expectedNewPrincipal;
652 Number managementFeeChange;
657 Env env(*
this, features);
659 Account const issuer{
"issuer"};
660 Account const lender{
"vaultOwner"};
661 Account const borrower{
"borrower"};
671 .vaultDeposit = 900'000,
673 .managementFeeRate = p.managementFeeRate,
674 .vaultScale = p.vaultScale,
677 auto const brokerSle = env.
le(broker.brokerKeylet());
678 BEAST_EXPECT(brokerSle);
679 auto const loanSequence = brokerSle ? brokerSle->at(sfLoanSequence) : 0;
680 auto const loanKeylet =
683 env(
set(borrower, broker.brokerID,
Number{p.principal}, tfLoanOverpayment),
684 Sig(sfCounterpartySignature, lender),
685 kInterestRate(p.interestRate),
686 kPaymentTotal(p.paymentTotal),
687 kPaymentInterval(p.paymentInterval),
688 kGracePeriod(p.paymentInterval),
689 kOverpaymentFee(p.overpaymentFeeRate),
690 kOverpaymentInterestRate(p.overpaymentInterestRate),
699 auto const periodicRate =
loanPeriodicRate(s.interestRate, s.paymentInterval);
705 s.principalOutstanding,
706 s.managementFeeOutstanding,
710 p.managementFeeRate);
724 p.overpaymentInterestRate,
725 p.overpaymentFeeRate,
726 p.managementFeeRate);
727 Number const expectedNewPrincipal = s.principalOutstanding -
728 onePeriod.trackedPrincipalDelta - overpaymentComponents.trackedPrincipalDelta;
730 Number const managementFeeBefore = s.managementFeeOutstanding;
732 STAmount const payAmount{asset, onePeriod.trackedValueDelta + p.overpayment};
733 env(
pay(borrower, loanKeylet.key, payAmount),
738 auto const loanSle = env.
le(loanKeylet);
739 BEAST_EXPECT(loanSle);
742 .principalOutstanding = loanSle ?
Number{loanSle->at(sfPrincipalOutstanding)} : 0,
743 .expectedNewPrincipal = expectedNewPrincipal,
744 .managementFeeChange =
745 (loanSle ?
Number{loanSle->at(sfManagementFeeOutstanding)} :
Number{0}) -
754 Params
const principalCase{
758 .paymentInterval = 60,
760 .overpayment =
Number{49999998, -9},
774 fixed.principalOutstanding ==
fixed.expectedNewPrincipal,
775 "fixed principal " +
to_string(
fixed.principalOutstanding) +
" != expected " +
782 Result const legacy = runScenario(
all_ - fixCleanup3_2_0, principalCase);
784 legacy.principalOutstanding == legacy.expectedNewPrincipal,
785 "legacy principal " +
to_string(legacy.principalOutstanding) +
" != expected " +
793 Params
const feeCase{
797 .paymentInterval = 30u * 24 * 60 * 60,
799 .overpayment =
Number{214367363, -10},
802 .vaultScale = std::nullopt,
805 Result const feeFixed = runScenario(
all_, feeCase);
806 Result const feeLegacy = runScenario(
all_ - fixCleanup3_2_0, feeCase);
811 feeFixed.principalOutstanding == feeFixed.expectedNewPrincipal,
812 "fee-case fixed principal " +
to_string(feeFixed.principalOutstanding) +
813 " != expected " +
to_string(feeFixed.expectedNewPrincipal));
815 feeLegacy.principalOutstanding == feeLegacy.expectedNewPrincipal + feeLegacy.unit,
816 "fee-case legacy principal " +
to_string(feeLegacy.principalOutstanding) +
817 " != expected " +
to_string(feeLegacy.expectedNewPrincipal + feeLegacy.unit));
831 BEAST_EXPECT(feeFixed.managementFeeChange == feeLegacy.managementFeeChange);
833 (feeFixed.managementFeeChange ==
Number{-8219709543, -10}),
834 "fee-case mgmt fee change " +
to_string(feeFixed.managementFeeChange));
847 testcase(
"bug: computeOverpaymentComponents isRounded assertion");
850 using namespace loan;
853 Account const issuer{
"issuer"};
854 Account const lender{
"vaultOwner"};
855 Account const borrower{
"borrower"};
864 .vaultDeposit = 100'000,
870 auto const sleBroker = env.
le(broker.brokerKeylet());
871 if (!BEAST_EXPECT(sleBroker))
873 auto const loanSequence = sleBroker->at(sfLoanSequence);
876 using namespace loan;
877 env(
set(borrower, broker.brokerID,
Number{1000}, tfLoanOverpayment),
878 Sig(sfCounterpartySignature, lender),
881 kPaymentInterval(60),
909 testcase(
"bug: VaultWithdraw fixed shares round down to zero assets");
912 using namespace loan;
914 bool const fixed = features[fixCleanup3_4_0];
916 Env env(*
this, features);
918 Account const lender{
"lender"};
919 Account const depositorB{
"depositorB"};
920 Account const borrower{
"borrower"};
922 env.
fund(
XRP(10'000'000), lender, depositorB, borrower);
932 {.vaultDeposit = 1'000'000, .debtMax = 3'000'000, .coverDeposit = 1'000'000});
936 .depositor = depositorB,
937 .id = broker.vaultKeylet().key,
938 .amount = xrpAsset(3'000'000),
942 auto const brokerSle = env.
le(broker.brokerKeylet());
943 if (!BEAST_EXPECT(brokerSle))
945 auto const loanKeylet =
948 env(
set(borrower, broker.brokerID,
Number{2'000'000}),
949 Sig(sfCounterpartySignature, lender),
951 kPaymentInterval(600),
958 env(manage(lender, loanKeylet.key, tfLoanImpair),
Ter(
tesSUCCESS));
961 auto const vaultSle = env.
le(broker.vaultKeylet());
962 if (!BEAST_EXPECT(vaultSle))
964 BEAST_EXPECT(vaultSle->at(sfLossUnrealized) >
beast::kZero);
968 auto const shareAsset = vaultSle->at(sfShareMPTID);
971 env(v.withdraw({.depositor = lender, .id = broker.vaultKeylet().key, .amount = oneShare}),
979 Account const issuer{
"issuer"};
980 Account const iouLender{
"iouLender"};
981 Account const iouDepositorB{
"iouDepositorB"};
982 Account const iouBorrower{
"iouBorrower"};
984 env.
fund(
XRP(10'000'000), issuer, iouLender, iouDepositorB, iouBorrower);
988 env(
trust(iouLender, iouAsset(10'000'000)));
989 env(
trust(iouDepositorB, iouAsset(10'000'000)));
990 env(
trust(iouBorrower, iouAsset(10'000'000)));
992 env(
pay(issuer, iouLender, iouAsset(9'000'000)));
993 env(
pay(issuer, iouDepositorB, iouAsset(1)));
1002 .vaultDeposit = 3'999'999,
1003 .debtMax = 4'000'000,
1004 .coverDeposit = 4'000'000,
1009 .depositor = iouDepositorB,
1010 .id = iouBroker.vaultKeylet().key,
1011 .amount = iouAsset(1),
1015 auto const iouBrokerSle = env.le(iouBroker.brokerKeylet());
1016 if (!BEAST_EXPECT(iouBrokerSle))
1022 env(
set(iouBorrower, iouBroker.brokerID,
Number{4'000'000}),
1023 Sig(sfCounterpartySignature, iouLender),
1025 kPaymentInterval(600),
1026 Fee(env.current()->fees().base * 2),
1031 env(manage(iouLender, iouLoanKeylet.key, tfLoanImpair),
Ter(
tesSUCCESS));
1034 auto const iouVaultSle = env.le(iouBroker.vaultKeylet());
1035 if (!BEAST_EXPECT(iouVaultSle))
1037 BEAST_EXPECT(iouVaultSle->at(sfLossUnrealized) == iouVaultSle->at(sfAssetsTotal));
1039 auto const iouShareAsset = iouVaultSle->at(sfShareMPTID);
1042 auto const iouLenderBalanceBefore = env.balance(iouLender, iouAsset);
1043 auto const iouVaultAvailableBefore = iouVaultSle->at(sfAssetsAvailable);
1049 return sle ? sle->at(sfMPTAmount) : 0;
1051 auto const iouLenderSharesBefore = lenderShares();
1053 if (!BEAST_EXPECT(iouIssuanceBefore))
1055 auto const iouSharesOutstandingBefore = iouIssuanceBefore->at(sfOutstandingAmount);
1057 .depositor = iouLender,
1058 .id = iouBroker.vaultKeylet().key,
1059 .amount = oneIouShare,
1068 BEAST_EXPECT(env.balance(iouLender, iouAsset) == iouLenderBalanceBefore);
1069 BEAST_EXPECT(lenderShares() == iouLenderSharesBefore - 1);
1071 if (BEAST_EXPECT(iouIssuanceAfter))
1074 iouIssuanceAfter->at(sfOutstandingAmount) ==
1075 iouSharesOutstandingBefore - 1);
1077 auto const iouVaultAfter = env.le(iouBroker.vaultKeylet());
1078 if (BEAST_EXPECT(iouVaultAfter))
1080 BEAST_EXPECT(iouVaultAfter->at(sfAssetsAvailable) == iouVaultAvailableBefore);
1096 testcase(
"bug: VaultWithdraw dust debit vs AssetsTotal only");
1098 using namespace jtx;
1099 using namespace loan;
1101 bool const fixed = features[fixCleanup3_4_0];
1103 Env env(*
this, features);
1105 Account const issuer{
"issuer"};
1106 Account const lender{
"lender"};
1107 Account const borrower{
"borrower"};
1109 env.
fund(
XRP(10'000'000), issuer, lender, borrower);
1113 env(
trust(lender, iouAsset(100'000'000)));
1114 env(
trust(borrower, iouAsset(100'000'000)));
1115 env(
pay(issuer, lender, iouAsset(20'000'000)));
1124 .vaultDeposit = 10'000'000,
1125 .debtMax = 10'000'000,
1126 .coverDeposit = 1'000'000,
1132 env(
set(borrower, broker.brokerID,
Number{9'999'900}),
1133 Sig(sfCounterpartySignature, lender),
1135 kPaymentInterval(600),
1140 auto const vaultSle = env.
le(broker.vaultKeylet());
1141 if (!BEAST_EXPECT(vaultSle))
1143 BEAST_EXPECT(vaultSle->at(sfAssetsTotal) ==
Number{10'000'000});
1144 BEAST_EXPECT(vaultSle->at(sfAssetsAvailable) ==
Number{100});
1150 auto const shareAsset = vaultSle->at(sfShareMPTID);
1154 env(v.
withdraw({.depositor = lender, .id = broker.vaultKeylet().key, .amount = oneShare}),
1168 testcase(
"bug: LoanPay asserts 'interest due delta' on near-zero rate");
1170 using namespace jtx;
1171 using namespace std::chrono_literals;
1174 Account const issuer{
"issuer"};
1175 Account const lender{
"lender"};
1176 Account const borrower{
"borrower"};
1178 env.
fund(
XRP(1'000'000), issuer, lender, borrower);
1180 env(
fset(issuer, asfDefaultRipple));
1184 env(
trust(lender, iouAsset(1'000'000'000)));
1185 env(
trust(borrower, iouAsset(1'000'000'000)));
1186 env(
pay(issuer, lender, iouAsset(5'000'000)));
1187 env(
pay(issuer, borrower, iouAsset(5'000'000)));
1191 .vaultDeposit = 1'000'000,
1192 .debtMax = 1'000'000,
1201 using namespace loan;
1203 auto const loanSetFee =
Fee(env.
current()->fees().base * 2);
1204 Number const principalRequest{100};
1206 auto createJson = env.
json(
1211 createJson[
"InterestRate"] = 1;
1212 createJson[
"PaymentTotal"] = 3;
1213 createJson[
"PaymentInterval"] = 600;
1217 createJson = env.
json(createJson,
Sig(sfCounterpartySignature, lender));
1233 for (
auto const flags : {0u, tfLoanOverpayment})
1255 testLoanCoverMinimumRoundingExploit(features);
1265 {fixCleanup3_1_3, fixCleanup3_2_0, featureMPTokensV2},
all_))
LogOs< char > log
Logging output stream.
TestcaseT testcase
Memberspace for declaring test cases.
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.
void testYieldTheftRounding(std::uint32_t flags)
void testBugInterestDueDeltaCrash()
void testDustManipulation(FeatureBitset features)
void testBugOverpayUnroundedAmount()
void testRoundingAllowsUndercoverage(FeatureBitset features)
void runAmendmentSensitive(FeatureBitset features)
void runAmendmentIndependent()
void testIntegerScalePrincipalSticks(FeatureBitset features)
void testBugVaultWithdrawDustVsAssetsTotal(FeatureBitset features)
void testBugVaultWithdrawFixedSharesRoundsToZero(FeatureBitset features)
void run() override
Runs the suite.
void testBugOverpaymentPrincipalChange()
Shared base for the Loan*_test family under src/test/app/lending/.
void advancePastDueDate(jtx::Env &env, Keylet const &loanKeylet)
BrokerInfo createVaultAndBroker(jtx::Env &env, jtx::PrettyAsset const &asset, jtx::Account const &lender, BrokerParameters const ¶ms=BrokerParameters::defaults())
LoanState getCurrentState(jtx::Env const &env, BrokerInfo const &broker, Keylet const &loanKeylet)
Get the state without checking anything.
Keylet nextLoanKeylet(jtx::Env const &env, BrokerInfo const &broker)
static jtx::PrettyAsset createFundedRippleIouAsset(jtx::Env &env, jtx::Account const &issuer, jtx::Account const &lender, jtx::Account const &borrower, Number const &lenderPay=1 '000 '000, Number const &borrowerPay=1 '000 '000)
std::string const iouCurrency_
Immutable cryptographic account descriptor.
AccountID id() const
Returns the Account ID.
A transaction testing environment.
bool close(NetClock::time_point closeTime, std::optional< std::chrono::milliseconds > consensusDelay=std::nullopt)
Close and advance the ledger.
TER ter() const
Return the TER for the last JTx.
json::Value json(JsonValue &&jv, FN const &... fN)
Create JSON from parameters.
SLE::const_pointer le(Account const &account) const
Return an account root.
void fund(bool setDefaultRipple, STAmount const &amount, Account const &account)
PrettyAmount balance(Account const &account) const
Returns the XRP balance on an account.
std::shared_ptr< OpenView const > current() const
Returns the current ledger.
Test helper for creating, mutating, and asserting MPT and confidential MPT ledger state.
MPTID const & issuanceID() const
void create(MPTCreate const &arg=MPTCreate{}, std::source_location const &loc=std::source_location::current())
void authorize(MPTAuthorize const &arg=MPTAuthorize{}, std::source_location const &loc=std::source_location::current())
Set the regular signature on a JTx.
Set the expected result code for a JTx The test will fail if the code doesn't match.
@ Object
object value (collection of name/value pairs).
ExtendedPaymentComponents computeOverpaymentComponents(Rules const &rules, Asset const &asset, int32_t const loanScale, Number const &overpayment, TenthBips32 const overpaymentInterestRate, TenthBips32 const overpaymentFeeRate, TenthBips16 const managementFeeRate)
PaymentComponents computePaymentComponents(Rules const &rules, Asset const &asset, std::int32_t scale, Number const &totalValueOutstanding, Number const &principalOutstanding, Number const &managementFeeOutstanding, Number const &periodicPayment, Number const &periodicRate, std::uint32_t paymentRemaining, TenthBips16 managementFeeRate)
Keylet computation functions.
Keylet unchecked(UInt256 const &key) noexcept
Any ledger entry.
Keylet vault(AccountID const &owner, SeqProxy const &seq) noexcept
Keylet mptoken(MPTID const &issuanceID, AccountID const &holder) noexcept
Keylet loanBroker(AccountID const &owner, SeqProxy const &seq) noexcept
Keylet loan(UInt256 const &loanBrokerID, SeqProxy const &loanSeq) noexcept
Keylet mptokenIssuance(MPTID const &issuanceID) noexcept
json::Value coverClawback(AccountID const &account, std::uint32_t flags)
json::Value manage(AccountID const &account, UInt256 const &loanID, std::uint32_t flags)
json::Value set(AccountID const &account, UInt256 const &loanBrokerID, Number principalRequested, std::uint32_t flags)
auto const kPaymentInterval
json::Value pay(AccountID const &account, UInt256 const &loanID, STAmount const &amount, std::uint32_t flags)
json::Value pay(AccountID const &account, AccountID const &to, AnyAmount amount)
Create a payment.
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.
XrpT const XRP
Converts to XRP Issue or STAmount.
json::Value trust(Account const &account, STAmount const &amount, std::uint32_t flags)
Modify a trust line.
json::Value fset(Account const &account, std::uint32_t on, std::uint32_t off=0)
Add and/or remove flag.
static MPTInit const kMptInitNoFund
BEAST_DEFINE_TESTSUITE(AMMClawback, app, xrpl)
STTx createTx(bool disabling, LedgerIndex seq, PublicKey const &txKey)
Create ttUNL_MODIFY Tx.
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.
Number loanPeriodicRate(TenthBips32 interestRate, std::uint32_t paymentInterval)
constexpr T tenthBipsOfValue(T value, TenthBips< TBips > bips)
TenthBips< std::uint32_t > TenthBips32
static FunctionType fixed(Keylet const &keylet)
TenthBips< std::uint16_t > TenthBips16
boost::outcome_v2::result< T, std::error_code > Result
std::string to_string(BaseUInt< Bits, Tag > const &a)
STAmount roundToScale(STAmount const &value, std::int32_t scale, Number::RoundingMode rounding=Number::getround())
Round an arbitrary precision Amount to the precision of an STAmount that has a given exponent.
LoanState constructLoanState(Number const &totalValueOutstanding, Number const &principalOutstanding, Number const &managementFeeOutstanding)
A pair of SHAMap key and LedgerEntryType.
STAmount const & value() const
Asset const & raw() const
static json::Value withdraw(WithdrawArgs const &args)