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/noop.h>
10#include <test/jtx/pay.h>
11#include <test/jtx/ter.h>
12#include <test/jtx/trust.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/Journal.h>
18#include <xrpl/beast/utility/Zero.h>
19#include <xrpl/core/ServiceRegistry.h>
20#include <xrpl/json/json_value.h>
21#include <xrpl/ledger/OpenView.h>
22#include <xrpl/ledger/helpers/LendingHelpers.h>
23#include <xrpl/ledger/helpers/VaultHelpers.h>
24#include <xrpl/protocol/AccountID.h>
25#include <xrpl/protocol/Feature.h>
26#include <xrpl/protocol/Indexes.h>
27#include <xrpl/protocol/Issue.h>
28#include <xrpl/protocol/Keylet.h>
29#include <xrpl/protocol/LedgerFormats.h>
30#include <xrpl/protocol/Protocol.h>
31#include <xrpl/protocol/SField.h>
32#include <xrpl/protocol/STAmount.h>
33#include <xrpl/protocol/SeqProxy.h>
34#include <xrpl/protocol/TER.h>
35#include <xrpl/protocol/TxFlags.h>
36#include <xrpl/protocol/Units.h>
37#include <xrpl/tx/transactors/lending/LoanSet.h>
67 Number const& lenderAmount,
68 Number const& borrowerAmount)
85 return all_ | featureLendingProtocolV1_1 | featureLendingProtocolV1_2;
89 static BrokerParameters
107 template <
class Principal,
class... Extra>
114 Principal&& principal,
119 using namespace loan;
123 Sig(sfCounterpartySignature, lender),
144 env.
close(growthState.startDate + Duration{366 * 24 * 60 * 60});
152 return loan->at(sfTotalValueOutstanding) -
loan->at(sfPrincipalOutstanding) -
153 loan->at(sfManagementFeeOutstanding);
161 vault->at(sfAssetsTotal) - vault->at(sfAssetsAvailable) ==
162 loan->at(sfPrincipalOutstanding));
167 testLoanPayLateFullPaymentBypassesPenalties(
FeatureBitset features)
169 testcase(
"LoanPay full payment skips late penalties");
171 using namespace loan;
172 using namespace std::chrono_literals;
174 Env env(*
this, features);
176 Account const issuer{
"issuer"};
177 Account const lender{
"lender"};
178 Account const borrower{
"borrower"};
180 env.fund(
XRP(1'000'000), issuer, lender, borrower);
183 PrettyAsset
const asset = issuer[iouCurrency];
184 env(
trust(lender, asset(100'000'000)));
185 env(
trust(borrower, asset(100'000'000)));
186 env(
pay(issuer, lender, asset(50'000'000)));
187 env(
pay(issuer, borrower, asset(5'000'000)));
192 auto const loanSetFee = Fee(env.current()->fees().base * 2);
195 if (BEAST_EXPECT(brokerPreLoan); !brokerPreLoan.has_value())
198 auto const loanSequence = brokerPreLoan->at(sfLoanSequence);
201 Number
const principal = asset(1'000).value();
202 Number
const serviceFee = asset(2).value();
203 Number
const lateFee = asset(5).value();
204 Number
const closeFee = asset(4).value();
206 env(
set(borrower, broker.brokerID, principal),
207 Sig(sfCounterpartySignature, lender),
221 if (!BEAST_EXPECT(state1.paymentRemaining > 1))
226 auto const overdueClose = Tp{D{state1.nextPaymentDate + state1.paymentInterval}};
227 env.close(overdueClose);
230 auto const loanSle = env.le(loanKeylet);
231 if (!BEAST_EXPECT(brokerSle && loanSle))
236 TenthBips16 const managementFeeRate{brokerSle->at(sfManagementFeeRate)};
237 TenthBips32 const interestRateValue{loanSle->at(sfInterestRate)};
238 TenthBips32 const lateInterestRateValue{loanSle->at(sfLateInterestRate)};
239 TenthBips32 const closeInterestRateValue{loanSle->at(sfCloseInterestRate)};
241 Number
const closePaymentFeeRounded =
242 roundToAsset(broker.asset, loanSle->at(sfClosePaymentFee), state.loanScale);
243 Number
const latePaymentFeeRounded =
244 roundToAsset(broker.asset, loanSle->at(sfLatePaymentFee), state.loanScale);
247 state.totalValue, state.principalOutstanding, state.managementFeeOutstanding);
248 Number
const totalInterestOutstanding = roundedLoanState.interestDue;
250 auto const periodicRate =
loanPeriodicRate(interestRateValue, state.paymentInterval);
252 env.current()->rules(),
253 state.periodicPayment,
255 state.paymentRemaining,
258 auto const parentCloseTime = env.current()->parentCloseTime();
259 auto const startDateSeconds =
260 static_cast<std::uint32_t
>(state.startDate.time_since_epoch().
count());
263 rawLoanState.principalOutstanding,
266 state.paymentInterval,
267 state.previousPaymentDate,
269 closeInterestRateValue);
271 Number
const roundedFullInterestAmount =
272 roundToAsset(broker.asset, fullPaymentInterest, state.loanScale);
274 broker.asset, roundedFullInterestAmount, managementFeeRate, state.loanScale);
275 Number
const roundedFullInterest = roundedFullInterestAmount - roundedFullManagementFee;
277 Number
const trackedValueDelta =
278 state.principalOutstanding + totalInterestOutstanding + state.managementFeeOutstanding;
279 Number
const untrackedManagementFee =
280 closePaymentFeeRounded + roundedFullManagementFee - state.managementFeeOutstanding;
281 Number
const untrackedInterest = roundedFullInterest - totalInterestOutstanding;
283 Number
const baseFullDue = trackedValueDelta + untrackedInterest + untrackedManagementFee;
284 BEAST_EXPECT(baseFullDue ==
roundToAsset(broker.asset, baseFullDue, state.loanScale));
286 auto const overdueSeconds =
287 parentCloseTime.time_since_epoch().count() - state.nextPaymentDate;
288 if (!BEAST_EXPECT(overdueSeconds > 0))
291 Number
const overdueRate =
loanPeriodicRate(lateInterestRateValue, overdueSeconds);
292 Number
const lateInterestRaw = state.principalOutstanding * overdueRate;
293 Number
const lateInterestRounded =
294 roundToAsset(broker.asset, lateInterestRaw, state.loanScale);
296 broker.asset, lateInterestRounded, managementFeeRate, state.loanScale);
297 Number
const penaltyDue =
298 lateInterestRounded + lateManagementFeeRounded + latePaymentFeeRounded;
299 BEAST_EXPECT(penaltyDue > Number{});
301 auto const balanceBefore = env.balance(borrower, broker.asset).number();
303 STAmount
const paymentAmount{broker.asset.raw(), baseFullDue};
304 env(
pay(borrower, loanKeylet.key, paymentAmount, tfLoanFullPayment));
307 if (
auto const meta = env.meta(); BEAST_EXPECT(meta))
308 BEAST_EXPECT(meta->at(sfTransactionResult) ==
tesSUCCESS);
310 auto const balanceAfter = env.balance(borrower, broker.asset).number();
311 Number
const actualPaid = balanceBefore - balanceAfter;
312 BEAST_EXPECT(actualPaid == baseFullDue);
314 Number
const expectedWithPenalty = baseFullDue + penaltyDue;
315 BEAST_EXPECT(expectedWithPenalty > actualPaid);
316 BEAST_EXPECT(expectedWithPenalty - actualPaid == penaltyDue);
323 testcase(
"testOverpaymentManagementFee");
326 using namespace loan;
328 Env env{*
this, features};
330 Account const lender{
"lender"}, borrower{
"borrower"};
332 env.
fund(
XRP(10'000'000), lender, borrower);
342 .vaultDeposit = asset(100'000).value(),
346 auto const loanSetFee =
Fee(env.
current()->fees().base * 2);
348 auto const brokerSle = env.
le(result.brokerKeylet());
349 if (!BEAST_EXPECT(brokerSle))
354 borrower, result.brokerKeylet().key, asset(10'000).value(), tfLoanOverpayment),
355 Sig(sfCounterpartySignature, lender),
362 auto const expectedOverpaymentManagementFee =
Number{33333, 0};
363 auto const loanBrokerBalanceBefore = env.
balance(lender);
365 auto const loanPayFee =
Fee(env.
current()->fees().base * 2);
366 env(
pay(borrower, loanKeylet.key, asset(5'000).value(), tfLoanOverpayment), loanPayFee);
370 env.
balance(lender) - loanBrokerBalanceBefore == expectedOverpaymentManagementFee,
371 "overpayment management fee mismatch; expected:" +
372 to_string(expectedOverpaymentManagementFee) +
379 bool const feeCapped = features[fixCleanup3_1_3];
382 testcase <<
"DoS LoanPay: fee calculation " << (feeCapped ?
"capped" :
"uncapped");
385 using namespace std::chrono_literals;
387 Env env(*
this, features);
389 Account const issuer{
"issuer"};
390 Account const lender{
"lender"};
391 Account const borrower{
"borrower"};
393 env.
fund(
XRP(1'000'000), issuer, lender, borrower);
396 BEAST_EXPECT(feeCapped == env.
current()->rules().enabled(fixCleanup3_1_3));
399 env(
trust(lender, iouAsset(100'000'000)));
400 env(
trust(borrower, iouAsset(100'000'000)));
401 env(
pay(issuer, lender, iouAsset(10'000'000)));
402 env(
pay(issuer, borrower, iouAsset(1'000)));
407 using namespace loan;
409 auto const loanSetFee =
Fee(env.
current()->fees().base * 2);
410 Number const principalRequest{3959'37, -2};
411 auto const baseFee = env.
current()->fees().base;
413 auto const createJson = env.
json(
425 kPaymentInterval(60),
426 kPaymentTotal(3239184));
433 env(createJson,
Sig(sfCounterpartySignature, lender));
436 auto const roundedPayment = [&] {
438 BEAST_EXPECT(stateBefore.paymentRemaining == 3239184);
439 BEAST_EXPECT(stateBefore.paymentRemaining > kLoanMaximumPaymentsPerTransaction);
443 stateBefore.periodicPayment,
444 stateBefore.loanScale,
449 [&](
int const payFactor,
int const feeFactor,
TER const expectedTer =
tesSUCCESS) {
451 BEAST_EXPECT(stateBefore.paymentRemaining <= 3239184);
452 BEAST_EXPECT(stateBefore.paymentRemaining > kLoanMaximumPaymentsPerTransaction);
454 Number const amount = roundedPayment * payFactor;
455 auto const loanPayTx =
457 XRPAmount const payFee{baseFee * feeFactor};
458 env(loanPayTx,
Ter(expectedTer),
Fee(payFee));
461 ?
std::min(kLoanMaximumPaymentsPerTransaction, payFactor)
466 stateAfter.paymentRemaining == stateBefore.paymentRemaining - expectedChange);
470 kLoanMaximumPaymentsPerTransaction / kLoanPaymentsPerFeeIncrement;
476 test(1819878, 363976);
478 test(1819878, kMaxFeeIncrements, failWithoutFix);
481 test(kLoanMaximumPaymentsPerTransaction, kMaxFeeIncrements);
483 test(kLoanMaximumPaymentsPerTransaction, kMaxFeeIncrements + 10);
487 test(kLoanPaymentsPerFeeIncrement * 2, 2);
492 kLoanMaximumPaymentsPerTransaction - 10,
493 ((kLoanMaximumPaymentsPerTransaction - 10) / kLoanPaymentsPerFeeIncrement) - 1,
496 kLoanMaximumPaymentsPerTransaction - 10,
497 ((kLoanMaximumPaymentsPerTransaction - 10) / kLoanPaymentsPerFeeIncrement));
500 kLoanMaximumPaymentsPerTransaction - 10,
501 ((kLoanMaximumPaymentsPerTransaction - 10) / kLoanPaymentsPerFeeIncrement) + 3);
503 for (
int under = 1; under < kLoanPaymentsPerFeeIncrement; ++under)
505 test(kLoanMaximumPaymentsPerTransaction - under, kMaxFeeIncrements - 1,
telINSUF_FEE_P);
506 test(kLoanMaximumPaymentsPerTransaction - under, kMaxFeeIncrements);
510 kLoanMaximumPaymentsPerTransaction - kLoanPaymentsPerFeeIncrement,
511 kMaxFeeIncrements - 1);
513 test(kLoanMaximumPaymentsPerTransaction - kLoanPaymentsPerFeeIncrement, kMaxFeeIncrements);
532 testcase(
"LoanSet near-zero interest rate covers principal");
535 using namespace loan;
537 Number const principalRequested{1000};
542 bool created =
false;
551 Env env(*
this, features);
553 Account const issuer{
"issuer"};
554 Account const lender{
"vaultOwner"};
555 Account const borrower{
"borrower"};
563 {.vaultDeposit = 100'000, .debtMax = 0, .managementFeeRate =
TenthBips16{0}});
565 auto const brokerSle = env.
le(broker.brokerKeylet());
566 BEAST_EXPECT(brokerSle);
567 auto const loanSequence = brokerSle ? brokerSle->at(sfLoanSequence) : 0;
568 auto const loanKeylet =
571 env(
set(borrower, broker.brokerID, principalRequested),
572 Sig(sfCounterpartySignature, lender),
575 kPaymentInterval(400),
582 if (
auto const loanSle = env.
le(loanKeylet))
585 r.loanScale = loanSle->at(sfLoanScale);
586 r.principal = loanSle->at(sfPrincipalOutstanding);
587 r.totalValue = loanSle->at(sfTotalValueOutstanding);
588 r.managementFee = loanSle->at(sfManagementFeeOutstanding);
589 r.periodicPayment = loanSle->at(sfPeriodicPayment);
602 BEAST_EXPECT(!legacy.created);
607 BEAST_EXPECT(
fixed.created);
608 BEAST_EXPECT(
fixed.loanScale == -10);
609 BEAST_EXPECT(
fixed.principal == principalRequested);
610 BEAST_EXPECT((
fixed.totalValue ==
Number{10000000001903, -10}));
616 BEAST_EXPECT((
fixed.periodicPayment ==
Number{5000000000951293762, -16}));
617 BEAST_EXPECT((
fixed.periodicPayment * 2 ==
Number{1000000000190258752, -15}));
618 BEAST_EXPECT(
fixed.periodicPayment * 2 > principalRequested);
625 testcase <<
"Prevent nextPaymentDueDate overflow";
628 using namespace std::chrono_literals;
630 Env env{*
this, features};
632 Account const issuer{
"issuer"};
633 Account const lender{
"lender"};
634 Account const borrower{
"borrower"};
642 using namespace loan;
644 auto const loanSetFee =
Fee(env.
current()->fees().base * 2);
646 using TimeType =
decltype(sfNextPaymentDueDate)::type::value_type;
649 static_assert(kMaxTime == 4'294'967'295);
651 auto const baseJson = [&] {
652 auto createJson = env.
json(
660 kLoanOriginationFee(218),
668 auto const baseFee = env.
current()->fees().base;
670 auto parentCloseTime = [&] {
671 return env.
current()->parentCloseTime().time_since_epoch().count();
673 auto const maxLoanTime = [&] {
674 auto const startDate = parentCloseTime();
676 BEAST_EXPECT(startDate >= 50);
678 return kMaxTime - startDate;
683 auto const interval = maxLoanTime() + 1;
684 auto const total = 1;
685 auto const createJson =
686 env.
json(baseJson, kPaymentInterval(interval), kPaymentTotal(total));
694 auto const interval = 60;
695 auto const total = maxLoanTime() + 1;
696 auto const createJson =
697 env.
json(baseJson, kPaymentInterval(interval), kPaymentTotal(total));
705 auto const interval = maxLoanTime() + 1;
706 auto const total = 1;
707 auto const grace = interval;
708 auto const createJson = env.
json(
709 baseJson, kPaymentInterval(interval), kPaymentTotal(total), kGracePeriod(grace));
717 auto const interval = 1'000'000'000;
718 auto const total = 10;
719 auto const createJson =
720 env.
json(baseJson, kPaymentInterval(interval), kPaymentTotal(total));
728 auto const interval = 60;
729 auto const total = 1'000'000'000;
730 auto const createJson =
731 env.
json(baseJson, kPaymentInterval(interval), kPaymentTotal(total));
739 auto const total = 60;
740 auto const interval = (maxLoanTime() - total) / total;
741 auto const grace = interval;
742 auto const createJson = env.
json(
743 baseJson, kPaymentInterval(interval), kPaymentTotal(total), kGracePeriod(grace));
752 auto const grace = 100;
753 auto const interval = maxLoanTime() - grace;
754 auto const total = 1;
755 auto const createJson = env.
json(
756 baseJson, kPaymentInterval(interval), kPaymentTotal(total), kGracePeriod(grace));
762 auto const meta = env.
meta();
763 if (BEAST_EXPECT(meta))
765 BEAST_EXPECT(meta->at(sfTransactionResult) ==
tecKILLED);
769 auto const loanSle = env.
le(
keylet);
771 BEAST_EXPECT(!loanSle);
777 auto const closeStartDate = ((parentCloseTime() / 10) + 1) * 10;
778 auto const grace = 5'000;
779 auto const interval = kMaxTime - closeStartDate - grace;
780 auto const total = 1;
781 auto const createJson = env.
json(
782 baseJson, kPaymentInterval(interval), kPaymentTotal(total), kGracePeriod(grace));
788 auto const meta = env.
meta();
789 if (BEAST_EXPECT(meta))
791 BEAST_EXPECT(meta->at(sfTransactionResult) ==
tesSUCCESS);
796 BEAST_EXPECT(afterState.nextPaymentDate == kMaxTime - grace);
797 BEAST_EXPECT(afterState.previousPaymentDate == 0);
798 BEAST_EXPECT(afterState.paymentRemaining == 1);
803 env(
pay(issuer, borrower, iouAsset(
Number{1'055'524'81, -2})));
806 auto const closeStartDate = ((parentCloseTime() / 10) + 1) * 10;
807 auto const grace = 5'000;
808 auto const maxLoanTime = kMaxTime - closeStartDate - grace;
809 auto const total = [&] {
810 if (maxLoanTime % 5 == 0)
812 if (maxLoanTime % 3 == 0)
814 if (maxLoanTime % 2 == 0)
818 if (!BEAST_EXPECT(total != 0))
822 if (!BEAST_EXPECT(brokerState))
825 auto const loanSequence = brokerState->at(sfLoanSequence);
828 auto const interval = maxLoanTime / total;
829 auto const createJson = env.
json(
830 baseJson, kPaymentInterval(interval), kPaymentTotal(total), kGracePeriod(grace));
837 BEAST_EXPECT(beforeState.nextPaymentDate == closeStartDate + interval);
838 BEAST_EXPECT(beforeState.previousPaymentDate == 0);
839 BEAST_EXPECT(beforeState.paymentRemaining == total);
840 BEAST_EXPECT(beforeState.periodicPayment > 0);
845 Number const payment = beforeState.periodicPayment * (total - 1);
846 XRPAmount const payFee{baseFee * ((total - 1) / kLoanPaymentsPerFeeIncrement + 1)};
849 auto const loanPayTx =
857 BEAST_EXPECT(afterState.paymentRemaining == 1);
858 BEAST_EXPECT(afterState.nextPaymentDate == kMaxTime - grace);
859 BEAST_EXPECT(afterState.previousPaymentDate == kMaxTime - grace - interval);
892 Account const issuer{
"issuer"};
893 Account const lender{
"lender"};
894 Account const borrower{
"borrower"};
897 bool const pseudoExempt = features[fixCleanup3_4_0];
902 auto const payeeLabel = [payee] ->
char const* {
908 return "vault authorized by the issuer";
910 return "loan broker";
915 testcase <<
"LoanPay crediting an unauthorized " << payeeLabel <<
": pseudo-account "
916 << (pseudoExempt ?
"exempt" :
"not exempt");
918 Env env{*
this, features};
920 env.
fund(
XRP(1'000'000), issuer, lender, borrower);
923 env(
fset(issuer, asfRequireAuth));
927 env(
trust(lender, asset(100'000'000)));
928 env(
trust(borrower, asset(100'000'000)));
933 env(
trust(issuer, asset(0), lender, tfSetfAuth));
934 env(
trust(issuer, asset(0), borrower, tfSetfAuth));
937 env(
pay(issuer, lender, asset(10'000'000)));
938 env(
pay(issuer, borrower, asset(10'000)));
945 auto const vaultSle = env.le(broker.
vaultKeylet());
947 if (!BEAST_EXPECT(vaultSle && brokerSle))
950 Account const vaultPseudo{
"vault pseudo-account", vaultSle->at(sfAccount)};
951 Account const brokerPseudo{
"broker pseudo-account", brokerSle->at(sfAccount)};
953 auto const lineIsAuthorized = [&](
Account const& holder) ->
bool {
955 if (!BEAST_EXPECT(line))
957 return line->isFlag(holder.id() > issuer.
id() ? lsfLowAuth : lsfHighAuth);
960 BEAST_EXPECT(!lineIsAuthorized(vaultPseudo));
961 BEAST_EXPECT(!lineIsAuthorized(brokerPseudo));
965 env(
trust(issuer, asset(0), vaultPseudo, tfSetfAuth));
967 BEAST_EXPECT(lineIsAuthorized(vaultPseudo));
970 using namespace loan;
974 Number const serviceFee = asset(2).value();
976 env(
set(borrower, broker.
brokerID, asset(1'000).value()),
977 Sig(sfCounterpartySignature, lender),
978 kLoanServiceFee(serviceFee),
981 kPaymentInterval(600),
982 Fee(env.current()->fees().base * 2));
986 BEAST_EXPECT(env.le(loanKeylet));
992 env(
trust(issuer, asset(0), lender, tfSetFreeze | tfSetDeepFreeze));
1000 broker.
asset, state.periodicPayment + serviceFee, state.loanScale)};
1005 auto const assetsAvailable = [&] ->
Number {
1007 if (!BEAST_EXPECT(sle))
1009 return sle->at(sfAssetsAvailable);
1012 auto const borrowerBefore = env.balance(borrower, asset).number();
1013 auto const vaultBefore = env.balance(vaultPseudo, asset).number();
1014 auto const brokerBefore = env.balance(brokerPseudo, asset).number();
1015 auto const assetsAvailableBefore = assetsAvailable();
1017 env(
pay(borrower, loanKeylet.key, payment),
1023 BEAST_EXPECT(env.balance(borrower, asset).number() < borrowerBefore);
1024 BEAST_EXPECT(env.balance(vaultPseudo, asset).number() > vaultBefore);
1025 BEAST_EXPECT(assetsAvailable() > assetsAvailableBefore);
1029 (env.balance(brokerPseudo, asset).number() > brokerBefore) ==
1035 BEAST_EXPECT(!lineIsAuthorized(vaultPseudo));
1037 BEAST_EXPECT(!lineIsAuthorized(brokerPseudo));
1042 BEAST_EXPECT(env.balance(borrower, asset).number() == borrowerBefore);
1043 BEAST_EXPECT(env.balance(vaultPseudo, asset).number() == vaultBefore);
1044 BEAST_EXPECT(env.balance(brokerPseudo, asset).number() == brokerBefore);
1045 BEAST_EXPECT(assetsAvailable() == assetsAvailableBefore);
1049 for (
auto const& features : {
all_,
all_ - fixCleanup3_4_0})
1067 testcase(
"LoanPay funds conserved: broker fee payee below reserve");
1069 using namespace jtx;
1071 Env env(*
this, features);
1073 Account const issuer{
"issuer"};
1074 Account const lender{
"lender"};
1075 Account const borrower{
"borrower"};
1081 Number const serviceFeeValue{2};
1083 .account = borrower,
1085 .principalRequest = 1000,
1086 .serviceFee = serviceFeeValue,
1089 .payInterval = 3600,
1092 auto const loanOpt =
1094 if (BEAST_EXPECT(loanOpt); !loanOpt.has_value())
1096 auto const& [broker, loanKeylet, brokerPseudo] = *loanOpt;
1098 auto const vaultPseudo = [&] {
1100 if (!BEAST_EXPECT(vaultSle))
1102 return vaultSle->at(sfAccount);
1109 if (!BEAST_EXPECT(sle))
1111 return sle->getFieldAmount(sfBalance);
1113 auto const lenderReserve = [&] {
1123 env(
pay(lender, issuer, rawBalance(lender.
id()) - lenderReserve() - baseFee));
1126 BEAST_EXPECT(env.
balance(lender) < lenderReserve());
1131 STAmount const roundedPeriodicPayment{
1137 auto const borrowerBefore = rawBalance(borrower.
id());
1138 auto const vaultBefore = rawBalance(vaultPseudo);
1139 auto const lenderBefore = rawBalance(lender.
id());
1144 env(
loan::pay(borrower, loanKeylet.key, totalDue));
1147 auto const borrowerAfter = rawBalance(borrower.
id());
1148 auto const vaultAfter = rawBalance(vaultPseudo);
1149 auto const lenderAfter = rawBalance(lender.
id());
1153 BEAST_EXPECT(lenderAfter > lenderBefore);
1154 BEAST_EXPECT(lenderAfter < lenderReserve());
1158 borrowerBefore - baseFee + vaultBefore + lenderBefore ==
1159 borrowerAfter + vaultAfter + lenderAfter);
1176 using namespace jtx;
1178 auto const sle = view.
read(loanKeylet);
1182 (*replacement)[sfNextPaymentDueDate] = dueDate;
1198 testcase(
"LoanPay at exact due date succeeds with fixCleanup3_4_0");
1200 using namespace jtx;
1201 using namespace loan;
1204 BEAST_EXPECT(env.
enabled(fixCleanup3_4_0));
1206 Account const lender{
"lender"};
1207 Account const borrower{
"borrower"};
1209 env.
fund(
XRP(10'000'000), lender, borrower);
1216 if (!BEAST_EXPECT(brokerSle))
1218 auto const loanKeylet =
1225 env(
set(borrower, broker.brokerID, asset(1'000).value()),
1226 Sig(sfCounterpartySignature, lender),
1228 kPaymentInterval(600),
1230 kLatePaymentFee(asset(50).value()),
1235 BEAST_EXPECT(stateBefore.paymentRemaining == 12);
1237 STAmount const roundedPeriodicPayment{
1243 env.
current()->parentCloseTime().time_since_epoch().count();
1247 auto const borrowerBefore = env.
balance(borrower, asset).
number();
1261 auto const borrowerAfter = env.
balance(borrower, asset).
number();
1267 Number const charged = borrowerBefore - borrowerAfter -
Number{payFee};
1268 BEAST_EXPECT(charged >
Number{});
1269 BEAST_EXPECT(charged <=
Number{roundedPeriodicPayment});
1272 BEAST_EXPECT(stateAfter.paymentRemaining == stateBefore.paymentRemaining - 1);
1273 BEAST_EXPECT(stateAfter.nextPaymentDate == exactDueDate + stateBefore.paymentInterval);
1285 testcase(
"LoanPay at exact due date fails without fixCleanup3_4_0");
1287 using namespace jtx;
1288 using namespace loan;
1290 Env env(*
this,
all_ - fixCleanup3_4_0);
1291 BEAST_EXPECT(!env.
enabled(fixCleanup3_4_0));
1293 Account const lender{
"lender"};
1294 Account const borrower{
"borrower"};
1296 env.
fund(
XRP(10'000'000), lender, borrower);
1303 if (!BEAST_EXPECT(brokerSle))
1305 auto const loanKeylet =
1308 env(
set(borrower, broker.brokerID, asset(1'000).value()),
1309 Sig(sfCounterpartySignature, lender),
1311 kPaymentInterval(600),
1316 BEAST_EXPECT(stateBefore.paymentRemaining == 12);
1318 STAmount const roundedPeriodicPayment{
1324 env.
current()->parentCloseTime().time_since_epoch().count();
1336 env(
pay(borrower, loanKeylet.key, roundedPeriodicPayment),
Ter(
tecEXPIRED));
1339 BEAST_EXPECT(stateAfter.paymentRemaining == stateBefore.paymentRemaining);
1340 BEAST_EXPECT(stateAfter.nextPaymentDate == exactDueDate);
1351 testcase(
"LoanPay(tfLoanLatePayment) at exact due date rejected with fixCleanup3_4_0");
1353 using namespace jtx;
1354 using namespace loan;
1357 BEAST_EXPECT(env.
enabled(fixCleanup3_4_0));
1359 Account const lender{
"lender"};
1360 Account const borrower{
"borrower"};
1362 env.
fund(
XRP(10'000'000), lender, borrower);
1369 if (!BEAST_EXPECT(brokerSle))
1371 auto const loanKeylet =
1374 env(
set(borrower, broker.brokerID, asset(1'000).value()),
1375 Sig(sfCounterpartySignature, lender),
1377 kPaymentInterval(600),
1379 kLatePaymentFee(asset(50).value()),
1384 BEAST_EXPECT(stateBefore.paymentRemaining == 12);
1396 env.
current()->parentCloseTime().time_since_epoch().count();
1407 env(
pay(borrower, loanKeylet.key, generousAmount, tfLoanLatePayment),
Ter(
tecTOO_SOON));
1410 BEAST_EXPECT(stateAfter.paymentRemaining == stateBefore.paymentRemaining);
1411 BEAST_EXPECT(stateAfter.nextPaymentDate == exactDueDate);
1422 testcase(
"LoanPay catch-up fee at exact due date with fixCleanup3_4_0");
1424 using namespace jtx;
1425 using namespace loan;
1429 BEAST_EXPECT(env.
enabled(fixCleanup3_4_0));
1431 Account const lender{
"lender"};
1432 Account const borrower{
"borrower"};
1434 env.
fund(
XRP(10'000'000), lender, borrower);
1441 if (!BEAST_EXPECT(brokerSle))
1443 auto const loanKeylet =
1446 env(
set(borrower, broker.brokerID, asset(10'000).value()),
1447 Sig(sfCounterpartySignature, lender),
1449 kPaymentInterval(600),
1454 BEAST_EXPECT(stateBefore.paymentRemaining == 50);
1455 BEAST_EXPECT(stateBefore.paymentRemaining > kLoanPaymentsPerFeeIncrement);
1457 auto const loanSle = env.
le(loanKeylet);
1458 if (!BEAST_EXPECT(loanSle))
1460 Number const regularPayment =
1462 loanSle->at(sfLoanServiceFee);
1463 int const payCount = kLoanPaymentsPerFeeIncrement * 4;
1464 STAmount const catchUp{asset, regularPayment * payCount};
1466 XRPAmount const escalatedFee{baseFee * (payCount / kLoanPaymentsPerFeeIncrement)};
1469 env.
current()->parentCloseTime().time_since_epoch().count();
1482 BEAST_EXPECT(stateAfter.paymentRemaining == stateBefore.paymentRemaining - payCount);
1491 testcase(
"LoanPay catch-up fee at exact due date without fixCleanup3_4_0");
1493 using namespace jtx;
1494 using namespace loan;
1497 Env env(*
this,
all_ - fixCleanup3_4_0);
1498 BEAST_EXPECT(!env.
enabled(fixCleanup3_4_0));
1500 Account const lender{
"lender"};
1501 Account const borrower{
"borrower"};
1503 env.
fund(
XRP(10'000'000), lender, borrower);
1510 if (!BEAST_EXPECT(brokerSle))
1512 auto const loanKeylet =
1515 env(
set(borrower, broker.brokerID, asset(10'000).value()),
1516 Sig(sfCounterpartySignature, lender),
1518 kPaymentInterval(600),
1523 BEAST_EXPECT(stateBefore.paymentRemaining == 50);
1525 auto const loanSle = env.
le(loanKeylet);
1526 if (!BEAST_EXPECT(loanSle))
1528 Number const regularPayment =
1530 loanSle->at(sfLoanServiceFee);
1531 int const payCount = kLoanPaymentsPerFeeIncrement * 4;
1532 STAmount const catchUp{asset, regularPayment * payCount};
1536 env.
current()->parentCloseTime().time_since_epoch().count();
1542 BEAST_EXPECT(stateAfter.paymentRemaining == stateBefore.paymentRemaining);
1543 BEAST_EXPECT(stateAfter.nextPaymentDate == exactDueDate);
1553 using namespace jtx;
1554 using namespace loan;
1559 "LoanPay broker-owner borrower existing line after "
1560 "issuer clears asfDefaultRipple (") +
1561 (features[fixCleanup3_4_0] ?
"post" :
"pre") +
"-fixCleanup3_4_0)");
1563 Env env(*
this, features);
1564 Account const issuer{
"issuer"};
1567 env.
fund(
XRP(10'000), issuer, alice);
1569 env(
fset(issuer, asfDefaultRipple));
1573 env(
trust(alice, usd(10'000'000)));
1575 env(
pay(issuer, alice, usd(2'000'000)));
1580 if (!BEAST_EXPECT(brokerSle))
1582 auto const loanKeylet =
1585 Number const serviceFee = usd(2).value();
1586 env(
set(alice, broker.brokerID, usd(1'000).value()),
1587 Sig(sfCounterpartySignature, alice),
1588 kLoanServiceFee(serviceFee),
1592 env(
fclear(issuer, asfDefaultRipple));
1601 env(
pay(alice, loanKeylet.key, payment),
Ter(expected));
1612 testcase(
"FixedPrecision scheduled LoanPay accounting");
1614 using namespace jtx;
1615 using namespace loan;
1617 Number const trustLimit{10'000'000};
1618 Number const lenderAmount{2'000'000};
1619 Number const borrowerAmount{100};
1622 auto& [env, issuer, lender, borrower, asset] = f;
1626 brokerParams.managementFeeRate = managementFeeRate;
1628 Number const principal{1'000};
1635 asset(principal).value(),
1636 {.paymentTotal = 3, .paymentInterval = 24 * 60 * 60},
1643 auto const vaultBefore = env.le(broker.vaultKeylet());
1644 auto const brokerBefore = env.le(broker.brokerKeylet());
1645 auto const loanBefore = env.le(loanKeylet);
1646 if (!BEAST_EXPECT(vaultBefore && brokerBefore && loanBefore))
1649 Number const assetsAvailableBefore = vaultBefore->at(sfAssetsAvailable);
1650 Number const assetsTotalBefore = vaultBefore->at(sfAssetsTotal);
1651 Number const yieldBefore = vaultBefore->at(sfYieldUnrealized);
1652 Number const debtBefore = brokerBefore->at(sfDebtTotal);
1653 Number const principalBefore = loanBefore->at(sfPrincipalOutstanding);
1654 Number const managementFeeBefore = loanBefore->at(sfManagementFeeOutstanding);
1656 Number const lenderBalanceBefore = env.balance(lender, asset).number();
1659 env(
pay(borrower, loanKeylet.key, payment));
1662 auto const vaultAfter = env.le(broker.vaultKeylet());
1663 auto const brokerAfter = env.le(broker.brokerKeylet());
1664 auto const loanAfter = env.le(loanKeylet);
1665 if (!BEAST_EXPECT(vaultAfter && brokerAfter && loanAfter))
1668 *
this, env, broker.vaultKeylet(), {}, {loanKeylet},
"after scheduled payment");
1670 Number const principalPaid = principalBefore - loanAfter->at(sfPrincipalOutstanding);
1671 Number const credit = vaultAfter->at(sfAssetsAvailable) - assetsAvailableBefore;
1672 Number const managementFeeAfter = loanAfter->at(sfManagementFeeOutstanding);
1674 Number const interestPaid = scheduledInterestBefore - scheduledInterestAfter;
1675 Number const expectedAssetsTotal = [&] {
1677 return Number{
STAmount{asset, assetsTotalBefore + interestPaid}};
1679 Number const interestActual = expectedAssetsTotal - assetsTotalBefore;
1681 BEAST_EXPECT(brokerAfter->at(sfDebtTotal) == debtBefore - principalPaid);
1683 vaultAfter->at(sfAssetsTotal) == expectedAssetsTotal,
1684 "AssetsTotal expected " +
to_string(expectedAssetsTotal) +
", got " +
1685 to_string(vaultAfter->at(sfAssetsTotal)));
1686 BEAST_EXPECT(expectedAssetsTotal == assetsTotalBefore + interestPaid);
1687 BEAST_EXPECT(credit == principalPaid + interestActual);
1689 env.balance(lender, asset).number() - lenderBalanceBefore ==
1690 managementFeeBefore - managementFeeAfter);
1692 vaultAfter->at(sfYieldUnrealized) ==
1693 yieldBefore + scheduledInterestAfter - scheduledInterestBefore);
1695 vaultAfter->at(sfAssetsTotal) + vaultAfter->at(sfYieldUnrealized) ==
1696 assetsTotalBefore + yieldBefore,
1697 "capacity before " +
to_string(assetsTotalBefore + yieldBefore) +
", after " +
1698 to_string(vaultAfter->at(sfAssetsTotal) + vaultAfter->at(sfYieldUnrealized)));
1701 BEAST_EXPECT(vaultAfter->at(sfYieldUnrealized) >
beast::kZero);
1703 Number const fullPaymentMaximum = env.balance(borrower, asset).number();
1704 env(
pay(borrower, loanKeylet.key, asset(fullPaymentMaximum), tfLoanFullPayment));
1707 auto const vaultAfterFull = env.le(broker.vaultKeylet());
1708 auto const loanAfterFull = env.le(loanKeylet);
1709 if (!BEAST_EXPECT(vaultAfterFull && loanAfterFull))
1712 *
this, env, broker.vaultKeylet(), {}, {loanKeylet},
"after full payment");
1713 BEAST_EXPECT(loanAfterFull->at(sfPaymentRemaining) == 0);
1714 BEAST_EXPECT(loanAfterFull->at(sfTotalValueOutstanding) ==
beast::kZero);
1715 BEAST_EXPECT(loanAfterFull->at(sfPrincipalOutstanding) ==
beast::kZero);
1716 BEAST_EXPECT(loanAfterFull->at(sfManagementFeeOutstanding) ==
beast::kZero);
1717 BEAST_EXPECT(vaultAfterFull->at(sfYieldUnrealized) ==
beast::kZero);
1723 testcase(
"FixedPrecision redirected fee rounds at posterior cover scale");
1725 using namespace jtx;
1726 using namespace loan;
1728 Number const trustLimit{2, 10};
1729 Number const lenderAmount{1, 10};
1730 Number const borrowerAmount{2, 9};
1733 auto& [env, issuer, lender, borrower, asset] = f;
1736 brokerParams.coverDeposit = 0;
1742 Number const coverDepositAmount{9, 9};
1746 Number const loanPrincipal{1'000};
1747 auto const makeLoan = [&](
Number const& serviceFee) {
1753 asset(loanPrincipal).value(),
1754 {.paymentTotal = 2, .paymentInterval = 24 * 60 * 60},
1755 kLoanServiceFee(serviceFee));
1757 auto const payOnce = [&](
Keylet const& loanKeylet,
Number const& serviceFee) {
1762 env(
pay(borrower, loanKeylet.
key, payment));
1766 Number const coarseningFee{1, 9};
1767 auto const firstLoan = makeLoan(coarseningFee);
1768 Number const roundedFeeRaw{17, -6};
1769 auto const roundedFeeLoan = makeLoan(roundedFeeRaw);
1770 Number const dustFee{1, -6};
1771 auto const secondLoan = makeLoan(dustFee);
1772 auto const checkSums = [&](
char const* label) {
1776 broker.vaultKeylet(),
1778 {firstLoan, roundedFeeLoan, secondLoan},
1785 env(
trust(issuer, asset(0), lender, tfSetFreeze | tfSetDeepFreeze));
1788 payOnce(firstLoan, coarseningFee);
1789 checkSums(
"after firstLoan payment");
1790 auto const brokerCoarsened = env.le(broker.brokerKeylet());
1791 if (!BEAST_EXPECT(brokerCoarsened))
1793 Number const coverBeforeDust = brokerCoarsened->at(sfCoverAvailable);
1794 Number const expectedCoverAfterFirstPayment{1, 10};
1795 BEAST_EXPECT(coverBeforeDust == expectedCoverAfterFirstPayment);
1797 payOnce(roundedFeeLoan, roundedFeeRaw);
1798 checkSums(
"after roundedFeeLoan payment");
1799 auto const brokerAfterRoundedFee = env.le(broker.brokerKeylet());
1800 if (!BEAST_EXPECT(brokerAfterRoundedFee))
1802 Number const roundedFee = brokerAfterRoundedFee->at(sfCoverAvailable) - coverBeforeDust;
1804 BEAST_EXPECT(roundedFee < roundedFeeRaw);
1806 auto const vaultBeforeDust = env.le(broker.vaultKeylet());
1807 if (!BEAST_EXPECT(vaultBeforeDust))
1809 Number const availableBeforeDust = vaultBeforeDust->at(sfAssetsAvailable);
1810 Number const borrowerBeforeDust = env.balance(borrower, asset).number();
1812 payOnce(secondLoan, dustFee);
1814 auto const brokerAfterDust = env.le(broker.brokerKeylet());
1815 auto const vaultAfterDust = env.le(broker.vaultKeylet());
1816 if (!BEAST_EXPECT(brokerAfterDust && vaultAfterDust))
1818 checkSums(
"after secondLoan (dust) payment");
1820 brokerAfterDust->at(sfCoverAvailable) == brokerAfterRoundedFee->at(sfCoverAvailable));
1821 Number const vaultCredit = vaultAfterDust->at(sfAssetsAvailable) - availableBeforeDust;
1822 BEAST_EXPECT(borrowerBeforeDust - env.balance(borrower, asset).number() == vaultCredit);
1828 using namespace jtx;
1829 using namespace loan;
1836 char const* name =
nullptr;
1839 Row
const rows[] = {
1841 .name =
"Legacy redirected fee is rounded into CoverAvailable",
1842 .features =
all_ - featureLendingProtocolV1_1 - featureLendingProtocolV1_2,
1845 .name =
"CashBasis redirected fee is rounded into CoverAvailable",
1846 .features = (
all_ | featureLendingProtocolV1_1) - featureLendingProtocolV1_2,
1849 for (
auto const& row : rows)
1853 Number const trustLimit{1, 11};
1854 Number const lenderAmount{5, 10};
1855 Number const borrowerAmount{2, 9};
1856 FixedPrecisionIOU f{*
this, row.features, trustLimit, lenderAmount, borrowerAmount};
1857 auto& [env, issuer, lender, borrower, asset] = f;
1864 Number const coverDepositAmount{1'234'567'890'123'456, -5};
1868 Number const serviceFee{1, -6};
1874 asset(
Number{1'000}).value(),
1875 {.paymentTotal = 2, .paymentInterval = 24 * 60 * 60},
1876 kLoanServiceFee(serviceFee));
1880 env(
trust(issuer, asset(0), lender, tfSetFreeze | tfSetDeepFreeze));
1883 auto const brokerBefore = env.le(broker.brokerKeylet());
1884 if (!BEAST_EXPECT(brokerBefore))
1886 Number const coverBefore = brokerBefore->at(sfCoverAvailable);
1887 BEAST_EXPECT(coverBefore == coverDepositAmount);
1893 env(
pay(borrower, loanKeylet.key, payment));
1896 auto const brokerAfter = env.le(broker.brokerKeylet());
1897 if (!BEAST_EXPECT(brokerAfter))
1899 Number const coverAfter = brokerAfter->at(sfCoverAvailable);
1901 BEAST_EXPECT(coverAfter == coverBefore);
1908 testcase(
"FixedPrecision coarsened LoanPay transfers principal in full");
1910 using namespace jtx;
1911 using namespace loan;
1913 Number const trustLimit{3, 10};
1914 Number const lenderAmount{11, 9};
1915 Number const borrowerAmount{15, 9};
1918 auto& [env, issuer, lender, borrower, asset] = f;
1921 Number const vaultDeposit{9, 9};
1922 Number const debtMax{9, 9};
1923 brokerParams.vaultDeposit = vaultDeposit;
1924 brokerParams.debtMax = debtMax;
1925 brokerParams.coverDeposit = 1'000'000'000;
1928 LoanShape const shape{.paymentTotal = 2, .paymentInterval = 2 * 365 * 24 * 60 * 60};
1929 Number const firstLoanPrincipal{7, 9};
1930 auto const firstLoan =
1931 originateLoan(env, broker, borrower, lender, firstLoanPrincipal, shape);
1932 Number const growthLoanPrincipal{1, 9};
1938 growthLoanPrincipal,
1942 auto const vaultBeforeGrowth = env.le(broker.vaultKeylet());
1943 if (!BEAST_EXPECT(vaultBeforeGrowth))
1945 Number const assetsAvailableBeforeGrowth = vaultBeforeGrowth->at(sfAssetsAvailable);
1946 Number const assetsTotalBeforeGrowth = vaultBeforeGrowth->at(sfAssetsTotal);
1947 Number const yieldBeforeGrowth = vaultBeforeGrowth->at(sfYieldUnrealized);
1949 Number const payoffMaximum{1, 10};
1952 auto const coarsenedVault = env.le(broker.vaultKeylet());
1953 if (!BEAST_EXPECT(coarsenedVault))
1958 broker.vaultKeylet(),
1960 {firstLoan, growthLoan},
1961 "after growth payment coarsens vault");
1967 to_string(coarsenedVault->at(sfAssetsTotal)));
1969 coarsenedVault->at(sfAssetsTotal) > assetsTotalBeforeGrowth,
1970 "AssetsTotal before " +
to_string(assetsTotalBeforeGrowth) +
", after " +
1971 to_string(coarsenedVault->at(sfAssetsTotal)));
1972 BEAST_EXPECT(coarsenedVault->at(sfYieldUnrealized) == yieldBeforeGrowth);
1973 Number const vaultCredit =
1974 coarsenedVault->at(sfAssetsAvailable) - assetsAvailableBeforeGrowth;
1975 BEAST_EXPECT(
isRounded(asset, vaultCredit, coarsenedScale));
1976 BEAST_EXPECT(
isRounded(asset, coarsenedVault->at(sfAssetsTotal), coarsenedScale));
1982 testcase(
"FixedPrecision coarsened LoanPay single-loan terminal remainder");
1984 using namespace jtx;
1985 using namespace loan;
1987 Number const trustLimit{3, 10};
1988 Number const lenderAmount{11, 9};
1989 Number const borrowerAmount{5, 9};
1992 auto& [env, issuer, lender, borrower, asset] = f;
1995 Number const vaultDeposit{9, 9};
1996 Number const debtMax{2, 9};
1997 brokerParams.vaultDeposit = vaultDeposit;
1998 brokerParams.debtMax = debtMax;
1999 brokerParams.coverDeposit = 200'000'000;
2002 LoanShape const shape{.paymentTotal = 2, .paymentInterval = 2 * 365 * 24 * 60 * 60};
2003 Number const terminalLoanPrincipal{1'000'000};
2004 auto const terminalLoan =
2005 originateLoan(env, broker, borrower, lender, terminalLoanPrincipal, shape);
2006 Number const growthLoanPrincipal{1, 9};
2012 growthLoanPrincipal,
2016 Number const payoffMaximum{4, 9};
2019 auto const vaultBefore = env.le(broker.vaultKeylet());
2020 auto const brokerBefore = env.le(broker.brokerKeylet());
2021 auto const loanBefore = env.le(terminalLoan);
2022 if (!BEAST_EXPECT(vaultBefore && brokerBefore && loanBefore))
2025 Number const remaining = loanBefore->at(sfPrincipalOutstanding);
2027 BEAST_EXPECT(remaining >= minFirstPrincipal);
2029 vaultBefore->at(sfAssetsTotal) - vaultBefore->at(sfAssetsAvailable) == remaining);
2031 Number const assetsAvailableBefore = vaultBefore->at(sfAssetsAvailable);
2032 Number const borrowerBefore = env.balance(borrower, asset).number();
2033 env(
pay(borrower, terminalLoan.key, asset(remaining), tfLoanFullPayment));
2036 auto const loanAfter = env.le(terminalLoan);
2037 auto const vaultAfter = env.le(broker.vaultKeylet());
2038 if (!BEAST_EXPECT(loanAfter && vaultAfter))
2043 broker.vaultKeylet(),
2045 {terminalLoan, growthLoan},
2046 "after terminal payment");
2047 BEAST_EXPECT(loanAfter->at(sfPaymentRemaining) == 0);
2048 BEAST_EXPECT(loanAfter->at(sfPrincipalOutstanding) ==
beast::kZero);
2050 Number const credit = vaultAfter->at(sfAssetsAvailable) - assetsAvailableBefore;
2051 BEAST_EXPECT(borrowerBefore - env.balance(borrower, asset).number() == credit);
2053 Number const residual = vaultAfter->at(sfAssetsTotal) - vaultAfter->at(sfAssetsAvailable);
2054 BEAST_EXPECT(residual == remaining - credit);
2055 Number const availableCandidate = [&] {
2057 return assetsAvailableBefore + remaining;
2059 int const availableScale =
2061 Number const availableUnit{1, availableScale};
2062 BEAST_EXPECT((residual < availableUnit));
2068 testcase(
"FixedPrecision coarsened LoanPay records interest before credit");
2070 using namespace jtx;
2071 using namespace loan;
2073 Number const trustLimit{3, 10};
2074 Number const lenderAmount{1, 10};
2075 Number const borrowerAmount{5, 9};
2078 auto& [env, issuer, lender, borrower, asset] = f;
2081 Number const vaultDeposit{85, 8};
2082 Number const debtMax{2, 9};
2083 brokerParams.vaultDeposit = vaultDeposit;
2084 brokerParams.debtMax = debtMax;
2085 brokerParams.coverDeposit = 200'000'000;
2088 LoanShape const shape{.paymentTotal = 2, .paymentInterval = 2 * 365 * 24 * 60 * 60};
2089 Number const targetLoanPrincipal{1'000'000};
2096 asset(targetLoanPrincipal).value(),
2099 Number const growthLoanPrincipal{15, 8};
2105 asset(growthLoanPrincipal).value(),
2109 Number const payoffMaximum{4, 9};
2112 auto const targetBefore = env.le(targetLoan);
2113 auto const vaultBefore = env.le(broker.vaultKeylet());
2114 if (!BEAST_EXPECT(targetBefore && vaultBefore))
2117 *
this, env, broker.vaultKeylet(), {}, {targetLoan, growthLoan},
"after growth payment");
2120 Number const principalBefore = targetBefore->at(sfPrincipalOutstanding);
2122 Number const yieldBefore = vaultBefore->at(sfYieldUnrealized);
2123 Number const assetsTotalBefore = vaultBefore->at(sfAssetsTotal);
2124 Number const assetsAvailableBefore = vaultBefore->at(sfAssetsAvailable);
2125 Number const borrowerBefore = env.balance(borrower, asset).number();
2130 env(
pay(borrower, targetLoan.key, asset(payment)));
2133 auto const targetAfter = env.le(targetLoan);
2134 auto const vaultAfter = env.le(broker.vaultKeylet());
2135 if (!BEAST_EXPECT(targetAfter && vaultAfter))
2138 *
this, env, broker.vaultKeylet(), {}, {targetLoan, growthLoan},
"after target payment");
2139 Number const principalAfter = targetAfter->at(sfPrincipalOutstanding);
2141 Number const interestActual = vaultAfter->at(sfAssetsTotal) - assetsTotalBefore;
2142 Number const interestPaid = scheduledBefore - scheduledAfter;
2143 Number const credit = vaultAfter->at(sfAssetsAvailable) - assetsAvailableBefore;
2145 BEAST_EXPECT(interestActual < interestPaid);
2150 Number const principalPaid = principalBefore - principalAfter;
2153 STAmount{asset, principalPaid + interestPaid},
2155 BEAST_EXPECT(credit == expectedCredit);
2156 BEAST_EXPECT(borrowerBefore - env.balance(borrower, asset).number() == credit);
2157 BEAST_EXPECT(scheduledAfter < scheduledBefore);
2159 vaultAfter->at(sfYieldUnrealized) == yieldBefore + scheduledAfter - scheduledBefore);
2170 using namespace jtx;
2171 using namespace loan;
2175 char const* name =
nullptr;
2178 Row
const rows[] = {
2179 {.name =
"FixedPrecision base-scale overpayment", .late =
false},
2180 {.name =
"FixedPrecision base-scale late payment", .late =
true},
2182 for (
auto const& row : rows)
2186 Number const trustLimit{5'000'000};
2187 Number const lenderAmount{2'000'000};
2188 Number const borrowerAmount{500'000};
2191 auto& [env, issuer, lender, borrower, asset] = f;
2194 Number const debtMax{500'000};
2195 brokerParams.debtMax = debtMax;
2196 brokerParams.coverDeposit = 50'000;
2199 Number const loanPrincipal{100'000};
2201 Number const latePaymentFee{1};
2204 auto const loanKeylet = row.late
2210 asset(loanPrincipal).value(),
2211 {.paymentTotal = 12, .paymentInterval = 600},
2213 kLatePaymentFee(asset(latePaymentFee).value()))
2219 asset(loanPrincipal).value(),
2222 .paymentInterval = 24 * 60 * 60,
2223 .flags = tfLoanOverpayment,
2226 kOverpaymentInterestRate(
2236 Number const catchUpMargin{100};
2237 Number const generousAmount =
2240 asset(catchUpMargin).value();
2241 env(
pay(borrower, loanKeylet.key, asset(generousAmount), tfLoanLatePayment));
2246 Number const overpayAmount{50'000};
2247 env(
pay(borrower, loanKeylet.key, asset(overpayAmount), tfLoanOverpayment));
2251 auto const loanAfter = env.le(loanKeylet);
2252 auto const vaultAfter = env.le(broker.vaultKeylet());
2253 if (!BEAST_EXPECT(loanAfter && vaultAfter))
2256 *
this, env, broker.vaultKeylet(), {}, {loanKeylet}, row.name);
2258 BEAST_EXPECT(vaultAfter->at(sfYieldUnrealized) ==
scheduledInterest(loanAfter));
2266 using namespace jtx;
2270 testcase <<
"FixedPrecision regular LoanPay "
2274 Account const issuer{
"issuer"};
2275 Account const lender{
"lender"};
2276 Account const borrower{
"borrower"};
2280 brokerParams.
debtMax = 25'000;
2284 .account = borrower,
2286 .principalRequest = 1'000,
2288 .payInterval = 24 * 60 * 60,
2291 auto const loanOpt =
2292 createLoan(env, assetType, brokerParams, loanParams, issuer, lender, borrower);
2293 if (BEAST_EXPECT(loanOpt); !loanOpt)
2295 auto const& [broker, loanKeylet, unusedBrokerPseudo] = *loanOpt;
2298 topUpBorrower(env, broker, issuer, borrower, state, std::nullopt);
2304 auto const loanAfter = env.le(loanKeylet);
2305 auto const vaultAfter = env.le(broker.vaultKeylet());
2306 if (!BEAST_EXPECT(loanAfter && vaultAfter))
2309 *
this, env, broker.vaultKeylet(), {}, {loanKeylet},
"after integral payment");
2311 BEAST_EXPECT(loanAfter->at(sfPaymentRemaining) == state.paymentRemaining - 1);
2319 testcase(
"FixedPrecision YieldUnrealized equals three-loan sum");
2321 using namespace jtx;
2322 using namespace loan;
2324 Number const trustLimit{10'000'000};
2325 Number const lenderAmount{3'000'000};
2326 Number const borrowerAmount{1'000'000};
2329 auto& [env, issuer, lender, borrower, asset] = f;
2332 Number const vaultDeposit{2'000'000};
2333 Number const debtMax{1'000'000};
2334 brokerParams.vaultDeposit = vaultDeposit;
2335 brokerParams.debtMax = debtMax;
2336 brokerParams.coverDeposit = 100'000;
2340 Number const loanPrincipal{100'000};
2351 asset(loanPrincipal).value(),
2352 {.paymentTotal = 2, .paymentInterval = 24 * 60 * 60},
2356 auto const expectedYield = [&] {
2358 for (
auto const& loanKeylet : loans)
2360 auto const loan = env.le(loanKeylet);
2361 if (BEAST_EXPECT(
loan))
2367 auto vault = env.le(broker.vaultKeylet());
2368 if (!BEAST_EXPECT(vault))
2370 BEAST_EXPECT(vault->at(sfYieldUnrealized) == expectedYield());
2379 env(
pay(borrower, loans[i].key, asset(payment)));
2383 vault = env.le(broker.vaultKeylet());
2384 if (!BEAST_EXPECT(vault))
2387 *
this, env, broker.vaultKeylet(), {}, loans,
"after two of three loans paid");
2388 BEAST_EXPECT(vault->at(sfYieldUnrealized) == expectedYield());
2395 "FixedPrecision YieldUnrealized equals the open-loan sum after overpayment and "
2398 using namespace jtx;
2399 using namespace loan;
2401 Number const trustLimit{10'000'000};
2402 Number const lenderAmount{3'000'000};
2403 Number const borrowerAmount{1'000'000};
2406 auto& [env, issuer, lender, borrower, asset] = f;
2409 Number const vaultDeposit{2'000'000};
2410 Number const debtMax{1'000'000};
2411 brokerParams.vaultDeposit = vaultDeposit;
2412 brokerParams.debtMax = debtMax;
2413 brokerParams.coverDeposit = 100'000;
2416 Number const loanPrincipal{100'000};
2420 Number const latePaymentFee{1};
2429 asset(loanPrincipal).value(),
2430 {.paymentTotal = 3, .paymentInterval = 24 * 60 * 60, .flags = tfLoanOverpayment},
2438 asset(loanPrincipal).value(),
2439 {.paymentTotal = 12, .paymentInterval = 600},
2442 kLatePaymentFee(asset(latePaymentFee).value()));
2448 asset(loanPrincipal).value(),
2449 {.paymentTotal = 3, .paymentInterval = 24 * 60 * 60},
2453 auto const expectedYield = [&] {
2455 for (
auto const& loanKeylet : loans)
2457 auto const loan = env.le(loanKeylet);
2458 if (BEAST_EXPECT(
loan))
2464 auto vault = env.le(broker.vaultKeylet());
2465 if (!BEAST_EXPECT(vault))
2467 BEAST_EXPECT(vault->at(sfYieldUnrealized) == expectedYield());
2470 Number const overpayAmount{50'000};
2471 env(
pay(borrower, overpaidLoan.key, asset(overpayAmount), tfLoanOverpayment));
2480 Number const catchUpMargin{100};
2481 Number const generousAmount =
2484 asset(catchUpMargin).value();
2485 env(
pay(borrower, lateLoan.key, asset(generousAmount), tfLoanLatePayment));
2490 vault = env.le(broker.vaultKeylet());
2491 if (!BEAST_EXPECT(vault))
2494 *
this, env, broker.vaultKeylet(), {}, loans,
"after overpayment and late payment");
2495 BEAST_EXPECT(vault->at(sfYieldUnrealized) == expectedYield());
2520 all_ | featureLendingProtocolV1_1 | featureLendingProtocolV1_2);
2528 testLoanPayLateFullPaymentBypassesPenalties(features);
2542 {fixCleanup3_1_3, fixCleanup3_2_0, featureMPTokensV2},
all_))
A generic endpoint for log messages.
TestcaseT testcase
Memberspace for declaring test cases.
Value removeMember(char const *key)
Remove and return the named member.
constexpr TIss const & get() const
A currency issued by an account.
static constexpr std::uint32_t kDefaultGracePeriod
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.
bool modify(ModifyType const &f)
Modify the open ledger.
Writable ledger view that accumulates state and tx changes.
void rawReplace(SLE::Ref sle) override
Unconditionally replace a state item.
SLE::const_pointer read(Keylet const &k) const override
Return the state item associated with a key.
Asset const & asset() const
std::shared_ptr< STLedgerEntry const > const_pointer
static constexpr SeqProxy rawSequence(std::uint32_t v)
Factory function to return a sequence-based SeqProxy.
virtual OpenLedger & getOpenLedger()=0
static BrokerParameters fixedPrecisionBrokerParams()
void run() override
Runs the suite.
FeatureBitset fixedPrecisionFeatures() const
void testLoanPayAtExactDueDateSucceedsPostAmendment()
void testFixedPrecisionCoarsenedInterestPayment()
void testRepayIntoUnauthorizedVault()
void runAmendmentIndependent()
void testDosLoanPay(FeatureBitset features)
void testLoanPayFundsConservedPayeeBelowReserve(FeatureBitset features)
void testFixedPrecisionYieldAcrossLoans()
void setLoanNextPaymentDueDate(jtx::Env &env, Keylet const &loanKeylet, std::uint32_t dueDate)
void testFixedPrecisionCoarsenedSingleLoanTerminal()
void payOffGrowthLoan(jtx::Env &env, BrokerInfo const &broker, jtx::Account const &borrower, Keylet const &growthLoan, Number const &maximum)
void testLoanLatePaymentAtExactDueDateRejectedPostAmendment()
void testLoanSetNearZeroInterestRateSucceeds()
void testFixedPrecisionScheduledPayment()
void testFixedPrecisionSpecialPayments()
void testLoanPayAtExactDueDateFailsPreAmendment()
void testRedirectedFeeCoverRounding()
void testLoanPaySelfBrokerExistingLineDefaultRipple()
void testFixedPrecisionRedirectedFeeRounding()
void runAmendmentSensitive(FeatureBitset features)
void testLoanNextPaymentDueDateOverflow(FeatureBitset features)
void testFixedPrecisionIntegralPayments()
void testOverpaymentManagementFee(FeatureBitset features)
void testLoanPayCatchUpFeeAtExactDueDatePostAmendment()
void expectPrincipalIsVaultDebt(SLE::const_pointer const &vault, SLE::const_pointer const &loan)
void testFixedPrecisionYieldAfterOverpaymentAndLatePayment()
static Number scheduledInterest(SLE::const_pointer const &loan)
void testLoanPayCatchUpFeeAtExactDueDatePreAmendment()
void testFixedPrecisionCoarsenedPayments()
Keylet originateLoan(jtx::Env &env, BrokerInfo const &broker, jtx::Account const &borrower, jtx::Account const &lender, Principal &&principal, LoanShape const &shape, Extra &&... extra)
Shared base for the Loan*_test family under src/test/app/lending/.
jtx::PrettyAsset createFundedIouAsset(jtx::Env &env, jtx::Account const &issuer, jtx::Account const &lender, jtx::Account const &borrower, Number const &lenderPay=100 '000 '000, Number const &borrowerPay=1 '000 '000)
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)
std::optional< std::tuple< BrokerInfo, Keylet, jtx::Account > > createLoan(jtx::Env &env, AssetType assetType, BrokerParameters const &brokerParams, LoanParameters const &loanParams, jtx::Account const &issuer, jtx::Account const &lender, jtx::Account const &borrower)
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_
static void topUpBorrower(jtx::Env &env, BrokerInfo const &broker, jtx::Account const &issuer, jtx::Account const &borrower, LoanState const &state, std::optional< Number > const &servFee)
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.
bool enabled(UInt256 feature) const
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< STObject const > meta()
Return metadata for the last JTx.
std::shared_ptr< OpenView const > current() const
Returns the current ledger.
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).
Keylet computation functions.
Keylet vault(AccountID const &owner, SeqProxy const &seq) noexcept
Keylet loanBroker(AccountID const &owner, SeqProxy const &seq) noexcept
Keylet account(AccountID const &id) noexcept
AccountID root.
Keylet loan(UInt256 const &loanBrokerID, SeqProxy const &loanSeq) noexcept
Keylet trustLine(AccountID const &id0, AccountID const &id1, Currency const ¤cy) noexcept
The index of a trust line for a given currency.
constexpr TenthBips32 kMaxCloseInterestRate
The maximum close interest rate charged for repaying a loan early in 1/10 bips.
json::Value coverDeposit(AccountID const &account, UInt256 const &brokerID, STAmount const &amount, uint32_t flags)
json::Value set(AccountID const &account, UInt256 const &loanBrokerID, Number principalRequested, std::uint32_t flags)
auto const kPaymentInterval
auto const kLoanServiceFee
auto const kOverpaymentInterestRate
auto const kCloseInterestRate
auto const kClosePaymentFee
json::Value pay(AccountID const &account, UInt256 const &loanID, STAmount const &amount, std::uint32_t flags)
auto const kLatePaymentFee
auto const kLateInterestRate
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 noop(Account const &account)
The null transaction.
std::uint32_t ownerCount(Env const &env, Account const &account)
json::Value fclear(Account const &account, std::uint32_t off)
Remove account flag.
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.
BEAST_DEFINE_TESTSUITE(AMMClawback, app, xrpl)
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={})
constexpr XRPAmount
Convert XRP to drops (integral types).
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 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
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.
int getVaultBaseScale(SLE::ConstRef vault)
Return the Vault's base exponent.
LoanState computeTheoreticalLoanState(Rules const &rules, Number const &periodicPayment, Number const &periodicRate, std::uint32_t const paymentRemaining, TenthBips32 const managementFeeRate)
void roundToAsset(A const &asset, Number &value)
Round an arbitrary precision Number IN PLACE to the precision of a given Asset.
BaseUInt< 160, detail::AccountIDTag > AccountID
A 160-bit unsigned that uniquely identifies an account.
Number roundPeriodicPayment(Asset const &asset, Number const &periodicPayment, std::int32_t scale)
Ensure the periodic payment is always rounded consistently.
bool isTesSuccess(TER x) noexcept
Number computeManagementFee(Asset const &asset, Number const &interest, TenthBips32 managementFeeRate, std::int32_t scale)
TERSubset< CanCvtToTER > TER
Number getAssetsTotal(SLE::ConstRef vault)
Return the Vault's current assets total.
VaultVersion getVaultVersion(SLE::ConstRef vault)
Resolves a Vault's LEVersion.
LoanState constructLoanState(Number const &totalValueOutstanding, Number const &principalOutstanding, Number const &managementFeeOutstanding)
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...
Number computeFullPaymentInterest(Number const &theoreticalPrincipalOutstanding, Number const &periodicRate, NetClock::time_point parentCloseTime, std::uint32_t paymentInterval, std::uint32_t prevPaymentDate, std::uint32_t startDate, TenthBips32 closeInterestRate)
bool isRounded(Asset const &asset, Number const &value, std::int32_t scale)
A pair of SHAMap key and LedgerEntryType.
jtx::Account const borrower
jtx::Account const issuer
jtx::PrettyAsset const asset
jtx::Account const lender
FixedPrecisionIOU(beast::unit_test::Suite &suite, FeatureBitset features, Number const &trustLimit, Number const &lenderAmount, Number const &borrowerAmount)
std::uint32_t paymentInterval
std::uint32_t paymentTotal
Keylet brokerKeylet() const
Keylet vaultKeylet() const
TenthBips16 managementFeeRate
std::optional< std::uint8_t > vaultScale
Asset const & raw() const