1#include <test/app/lending/LoanFixedPrecisionBase.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/sig.h>
8#include <test/jtx/ter.h>
9#include <test/jtx/vault.h>
11#include <xrpl/basics/Number.h>
12#include <xrpl/basics/chrono.h>
13#include <xrpl/beast/unit_test/suite.h>
14#include <xrpl/beast/utility/Zero.h>
15#include <xrpl/ledger/helpers/VaultHelpers.h>
16#include <xrpl/protocol/Asset.h>
17#include <xrpl/protocol/Feature.h>
18#include <xrpl/protocol/Indexes.h>
19#include <xrpl/protocol/Issue.h>
20#include <xrpl/protocol/Keylet.h>
21#include <xrpl/protocol/Protocol.h>
22#include <xrpl/protocol/SField.h>
23#include <xrpl/protocol/STAmount.h>
24#include <xrpl/protocol/SeqProxy.h>
25#include <xrpl/protocol/TER.h>
26#include <xrpl/protocol/Units.h>
46 char const* name =
nullptr;
52 "LoanSet on a FixedPrecision vault increments AssetsDeployed by the principal",
53 .principals = {
Number{300}},
56 .name =
"Two Loans on the same FixedPrecision vault sum into AssetsDeployed",
60 for (
auto const& row : rows)
64 Number const vaultDeposit{1'000};
68 auto const [issuer, owner, depositor, asset] =
setupIou(env);
70 auto const fixture =
setupLendingVault(env, owner, depositor, asset, vaultDeposit);
76 for (
auto const& principal : row.principals)
79 totalPrincipal += principal;
85 {.available = vaultDeposit - totalPrincipal, .assetsDeployed = totalPrincipal});
89 BEAST_EXPECT(sle->at(sfAssetsTotal) == vaultDeposit);
91 Number principalOutstanding{0};
92 for (
auto const& loanKeylet : loanKeylets)
94 auto const loanSle = env.le(loanKeylet);
95 if (!BEAST_EXPECT(loanSle))
97 principalOutstanding += loanSle->at(sfPrincipalOutstanding);
99 BEAST_EXPECT(sle->at(sfAssetsDeployed) == principalOutstanding);
112 enum class AssetKind { Iou, Xrp, Mpt };
115 char const* name =
nullptr;
116 AssetKind kind = AssetKind::Iou;
122 .name =
"LoanSet on an IOU FixedPrecision vault books interest net of the "
124 .kind = AssetKind::Iou,
129 .name =
"LoanSet on an XRP FixedPrecision vault books interest net of the "
131 .kind = AssetKind::Xrp,
132 .deposit =
Number{10'000'000},
133 .principal =
Number{3'000'000},
136 .name =
"LoanSet on an MPT FixedPrecision vault books interest net of the "
138 .kind = AssetKind::Mpt,
139 .deposit =
Number{10'000'000},
140 .principal =
Number{3'000'000},
143 for (
auto const& row : rows)
167 {.maxAmt = 100'000'000, .withDepositor =
true, .holderFunds = 10'000'000});
184 env, fixture, row.principal, paymentTotal, interestRate, 0, paymentInterval);
186 auto const loanSle = env.le(loanKeylet);
187 auto const vaultSle = env.le(fixture.vaultKeylet);
188 if (!BEAST_EXPECT(loanSle && vaultSle))
191 Number const principal = loanSle->at(sfPrincipalOutstanding);
192 Number const grossInterest = loanSle->at(sfTotalValueOutstanding) - principal;
193 Number const managementFee = loanSle->at(sfManagementFeeOutstanding);
194 BEAST_EXPECT(principal == row.principal);
196 BEAST_EXPECT(grossInterest > managementFee);
198 BEAST_EXPECT(vaultSle->at(sfAssetsDeployed) == row.principal);
199 BEAST_EXPECT(
Number(vaultSle->at(sfYieldUnrealized)) == grossInterest - managementFee);
201 BEAST_EXPECT(vaultSle->at(sfAssetsTotal) == row.deposit);
211 testcase(
"VaultClawback and partial VaultWithdraw succeed while a Loan is open");
213 Number const vaultDeposit{1'000};
215 Number const principal{400};
218 Number const withdrawAmount{100};
221 auto const [issuer, owner, depositor, asset] =
setupIou(env, {.clawback =
true});
225 auto const loanKeylet =
openLoan(env, fixture, principal, paymentTotal);
233 env(fixture.vault.clawback({
235 .id = fixture.vaultKeylet.key,
237 .amount = asset(clawbackAmount).value(),
247 .available = availableAfterClawback,
248 .assetsDeployed = principal,
249 .total = totalAfterClawback,
255 env(fixture.vault.withdraw({
256 .depositor = depositor,
257 .id = fixture.vaultKeylet.key,
258 .amount = asset(withdrawAmount),
262 sle = env.le(fixture.vaultKeylet);
263 if (!BEAST_EXPECT(sle))
265 Number const availableAfterWithdraw = availableAfterClawback - withdrawAmount;
266 Number const totalAfterWithdraw = totalAfterClawback - withdrawAmount;
267 BEAST_EXPECT(sle->at(sfAssetsAvailable) == availableAfterWithdraw);
268 BEAST_EXPECT(sle->at(sfAssetsDeployed) == principal);
270 BEAST_EXPECT(sle->at(sfAssetsTotal) == totalAfterWithdraw);
284 char const* name =
nullptr;
287 bool fixedPrecision =
false;
291 .name =
"full-value VaultWithdraw while AssetsDeployed is non-zero hits the "
292 "FixedPrecision tecHAS_OBLIGATIONS guard",
295 .fixedPrecision =
true,
299 "CashBasis: full-value VaultWithdraw while a Loan is open hits the ordinary "
300 "insufficient-funds guard",
301 .amendments =
features() - featureLendingProtocolV1_2,
303 .fixedPrecision =
false,
306 Number const vaultDeposit{1'000};
308 Number const principal{400};
311 for (
auto const& row : rows)
315 Env env(*
this, row.amendments);
316 auto const [issuer, owner, depositor, asset] =
setupIou(env);
320 if (!row.fixedPrecision)
322 auto const sleBefore = env.le(fixture.vaultKeylet);
323 if (!BEAST_EXPECT(sleBefore))
325 BEAST_EXPECT(!sleBefore->isFieldPresent(sfAssetsDeployed));
327 auto const loanKeylet =
openLoan(env, fixture, principal, paymentTotal);
334 env(fixture.vault.withdraw({
335 .depositor = depositor,
336 .id = fixture.vaultKeylet.key,
337 .amount = asset(vaultDeposit),
342 if (row.fixedPrecision)
347 {.available = vaultDeposit - principal, .assetsDeployed = principal});
364 "full-value VaultClawback with a large AssetsDeployed clamps to "
365 "AssetsAvailable instead of tecHAS_OBLIGATIONS");
367 Number const vaultDeposit{1'000};
369 Number const principal{400};
373 auto const [issuer, owner, depositor, asset] =
setupIou(env, {.clawback =
true});
377 auto const loanKeylet =
openLoan(env, fixture, principal, paymentTotal);
381 auto const sleBefore = env.le(fixture.vaultKeylet);
382 if (!BEAST_EXPECT(sleBefore))
384 Number const assetsDeployed = sleBefore->at(sfAssetsDeployed);
385 BEAST_EXPECT(assetsDeployed == principal);
386 BEAST_EXPECT(
Number(sleBefore->at(sfAssetsAvailable)) == vaultDeposit - principal);
388 auto const shareMPTID = sleBefore->at(sfShareMPTID);
389 auto const tokenBefore = env.le(
keylet::mptoken(shareMPTID, depositor.id()));
391 if (!BEAST_EXPECT(tokenBefore) || !BEAST_EXPECT(issuanceBefore))
393 std::uint64_t const sharesBefore = tokenBefore->getFieldU64(sfMPTAmount);
394 BEAST_EXPECT(sharesBefore == issuanceBefore->getFieldU64(sfOutstandingAmount));
396 env(fixture.vault.clawback(
397 {.issuer = issuer, .id = fixture.vaultKeylet.key, .holder = depositor}),
401 auto const sleAfter = env.le(fixture.vaultKeylet);
402 if (!BEAST_EXPECT(sleAfter))
404 BEAST_EXPECT(
Number(sleAfter->at(sfAssetsDeployed)) == assetsDeployed);
407 auto const tokenAfter = env.le(
keylet::mptoken(shareMPTID, depositor.id()));
409 if (!BEAST_EXPECT(tokenAfter) || !BEAST_EXPECT(issuanceAfter))
411 std::uint64_t const sharesAfter = tokenAfter->getFieldU64(sfMPTAmount);
412 BEAST_EXPECT(sharesAfter > 0);
413 BEAST_EXPECT(sharesAfter < sharesBefore);
414 BEAST_EXPECT(issuanceAfter->getFieldU64(sfOutstandingAmount) == sharesAfter);
417 env, fixture, {loanKeylet},
"full clawback clamps instead of HAS_OBLIGATIONS");
424 using namespace loan;
427 "CashBasis vault never gets an AssetsDeployed field through the same loan "
430 Number const vaultDeposit{1'000};
431 Number const principal{300};
434 Number const repaymentInstallment = principal / 2;
436 Env env(*
this,
features() - featureLendingProtocolV1_2);
437 auto const [issuer, owner, depositor, asset] =
setupIou(env);
439 auto const fixture =
setupLendingVault(env, owner, depositor, asset, vaultDeposit);
441 auto const sleAtCreate = env.le(fixture.vaultKeylet);
442 if (!BEAST_EXPECT(sleAtCreate))
445 BEAST_EXPECT(!sleAtCreate->isFieldPresent(sfAssetsDeployed));
447 auto const loanKeylet =
openLoan(env, fixture, principal, paymentTotal);
449 auto sle = env.le(fixture.vaultKeylet);
450 if (!BEAST_EXPECT(sle))
452 BEAST_EXPECT(!sle->isFieldPresent(sfAssetsDeployed));
453 BEAST_EXPECT(sle->at(sfAssetsAvailable) == vaultDeposit - principal);
454 BEAST_EXPECT(sle->at(sfAssetsTotal) == vaultDeposit);
456 env(pay(depositor, loanKeylet.key, asset(repaymentInstallment).value()));
458 sle = env.le(fixture.vaultKeylet);
459 if (!BEAST_EXPECT(sle))
461 BEAST_EXPECT(!sle->isFieldPresent(sfAssetsDeployed));
463 env(pay(depositor, loanKeylet.key, asset(repaymentInstallment).value()));
465 sle = env.le(fixture.vaultKeylet);
466 if (!BEAST_EXPECT(sle))
468 BEAST_EXPECT(!sle->isFieldPresent(sfAssetsDeployed));
469 BEAST_EXPECT(sle->at(sfAssetsAvailable) == vaultDeposit);
470 BEAST_EXPECT(sle->at(sfAssetsTotal) == vaultDeposit);
481 using namespace loan;
489 kInterestRate(interestRate),
490 kGracePeriod(gracePeriod),
491 kPaymentInterval(paymentInterval),
492 kPaymentTotal(paymentTotal),
493 Sig(sfCounterpartySignature, fixture.
owner),
494 Fee(env.
current()->fees().base * 2),
499 if (!BEAST_EXPECT(vaultSle))
502 BEAST_EXPECT(vaultSle->at(sfAssetsDeployed) ==
beast::kZero);
510 using namespace loan_broker;
514 char const* name =
nullptr;
518 bool withCover =
false;
522 .name =
"LoanSet rejects coarsening origination: 16-digit deposit",
523 .depositAmount =
Number{8999999999999999LL, -10},
529 .name =
"LoanSet rejects coarsening origination: cover deposited",
530 .depositAmount =
Number{899'999},
531 .principal = std::nullopt,
535 .name =
"LoanSet rejects coarsening origination: plain",
536 .depositAmount =
Number{899'999},
537 .principal = std::nullopt,
541 for (
auto const& row : rows)
546 auto const [issuer, owner, depositor, asset] =
setupIou(
549 .depositorTrust = 3'000'000,
550 .ownerTrust = row.withCover ? 100'000 : 1'000,
551 .depositorFunds = row.depositAmount,
557 auto const coverRateMinimum =
559 auto const coverRateLiquidation =
572 coverRateLiquidation);
574 auto const vaultSle = env.le(fixture.vaultKeylet);
575 if (!BEAST_EXPECT(vaultSle))
578 row.principal.value_or(
Number{vaultSle->at(sfAssetsAvailable)});
584 Number const coverDepositAmount = principal / 10;
585 env(coverDeposit(owner, fixture.brokerKeylet.key, asset(coverDepositAmount)));
601 using namespace loan;
605 char const* name =
nullptr;
607 bool issuerIsBorrower =
false;
608 bool issuerIsBrokerOwner =
false;
615 .name =
"LoanSet transfer legs: no fee",
616 .originationFee =
Number{0},
617 .issuerIsBorrower =
false,
618 .issuerIsBrokerOwner =
false,
621 .name =
"LoanSet transfer legs: with fee",
622 .originationFee =
Number{20},
623 .issuerIsBorrower =
false,
624 .issuerIsBrokerOwner =
false,
627 .name =
"LoanSet transfer legs: issuer is borrower",
628 .originationFee =
Number{0},
629 .issuerIsBorrower =
true,
630 .issuerIsBrokerOwner =
false,
633 .name =
"LoanSet transfer legs: issuer is broker owner",
634 .originationFee =
Number{20},
635 .issuerIsBorrower =
false,
636 .issuerIsBrokerOwner =
true,
639 Number const vaultDeposit{1'000};
640 Number const principal{300};
645 for (
auto const& row : rows)
650 auto const [issuer, owner, depositor, asset] =
setupIou(env);
651 Account const& brokerOwner = row.issuerIsBrokerOwner ? issuer : owner;
652 Account const& borrower = row.issuerIsBorrower ? issuer : depositor;
656 auto const before =
snapshotVault(env, fixture.vaultKeylet, asset);
657 Number const ownerBalanceBefore = env.balance(brokerOwner, asset).value();
659 auto const loanKeylet =
661 auto const submit = [&](
auto&&... extra) {
662 env(
set(borrower, fixture.brokerKeylet.key, principal),
664 kGracePeriod(gracePeriod),
665 kPaymentInterval(paymentInterval),
666 kPaymentTotal(paymentTotal),
667 Sig(sfCounterpartySignature, brokerOwner),
668 Fee(env.current()->fees().base * 2),
674 submit(kLoanOriginationFee(row.originationFee));
683 BEAST_EXPECT(before.available -
after.available == principal);
684 BEAST_EXPECT(
after.available ==
after.vaultBalance);
685 if (row.originationFee !=
beast::kZero && !row.issuerIsBrokerOwner)
688 env.balance(brokerOwner, asset).value() - ownerBalanceBefore ==
700 testcase(
"VaultSet AssetsMaximum below the derived total (AA + DT) is refused on FP");
702 Number const vaultDeposit{1'000};
703 Number const principal{300};
707 auto const [issuer, owner, depositor, asset] =
setupIou(env);
709 auto const fixture =
setupLendingVault(env, owner, depositor, asset, vaultDeposit);
710 auto const loanKeylet =
openLoan(env, fixture, principal, paymentTotal);
712 auto const vaultSle = env.le(fixture.vaultKeylet);
713 if (!BEAST_EXPECT(vaultSle))
716 BEAST_EXPECT(derivedTotal == vaultDeposit);
730 for (
auto const& row : rows)
732 auto tx = vault.set({.owner = owner, .id = fixture.vaultKeylet.key});
733 tx[sfAssetsMaximum] = row.max;
734 env(tx, Ter(row.ter));
739 auto const sle = env.le(fixture.vaultKeylet);
740 if (BEAST_EXPECT(sle))
741 BEAST_EXPECT(
Number(sle->at(sfAssetsMaximum)) == row.
max);
744 checkVaultLoanSums(env, fixture, {loanKeylet},
"testAssetsMaximumBelowDerivedTotalRefused");
751 using namespace loan;
754 "VaultDelete on FP with AssetsAvailable == 0 and AssetsDeployed > 0 is "
757 Number const vaultDeposit{1'000};
760 Number const principal = vaultDeposit;
764 auto const [issuer, owner, depositor, asset] =
setupIou(env);
766 auto const fixture =
setupLendingVault(env, owner, depositor, asset, vaultDeposit);
767 openLoan(env, fixture, principal, paymentTotal);
769 auto const vaultSle = env.le(fixture.vaultKeylet);
770 if (!BEAST_EXPECT(vaultSle))
773 BEAST_EXPECT(
Number(vaultSle->at(sfAssetsDeployed)) == principal);
776 env(vault.del({.owner = owner, .id = fixture.vaultKeylet.key}), Ter(
tecHAS_OBLIGATIONS));
778 BEAST_EXPECT(env.le(fixture.vaultKeylet));
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))
void checkVaultLoanSums(test::jtx::Env &env, LendingFixture const &fixture, std::vector< Keylet > const &loanKeylets, std::string const &label={})
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 testLendingClawbackAndWithdrawWhileLoanOpen()
void testLendingFinalWithdrawalWhileLoanOpen()
void testLendingFullClawbackClampsInsteadOfHasObligations()
void expectCoarseningLoanRejected(test::jtx::Env &env, LendingFixture const &fixture, Number const &principal, std::string const &label)
void testAssetsMaximumBelowDerivedTotalRefused()
void testLendingCashBasisControl()
void testVaultDeleteRefusedWhileDebtOutstanding()
void testAssetsDeployedOrigination()
void testOriginationGuardBlocksCoarsening()
void testLoanSetTransferLegShapes()
void testOriginationBooksInterestDueNetOfManagementFee()
void run() override
Runs the suite.
Number is a floating point type that can represent a wide range of values.
static Number max() noexcept
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)
void checkFixedPrecisionSync(test::jtx::Env const &env, Keylet const &vaultKeylet, Number const &expectedAvailable)
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.
std::shared_ptr< OpenView const > current() const
Returns the current ledger.
Keylet mptoken(MPTID const &issuanceID, AccountID const &holder) noexcept
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 clawbackAmount(SLE::ConstRef vault, std::optional< STAmount > const &maybeAmount, AccountID const &account)
constexpr TenthBips32 percentageToTenthBips(std::uint32_t percentage)
int getVaultScale(SLE::ConstRef vault)
Return the Vault's current live exponent.
TenthBips< std::uint32_t > TenthBips32
TenthBips< std::uint16_t > TenthBips16
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.
TERSubset< CanCvtToTER > TER
Number getAssetsTotal(SLE::ConstRef vault)
Return the Vault's current assets total.
BEAST_DEFINE_TESTSUITE(AccountTxPaging, app, xrpl)
test::jtx::Account depositor
test::jtx::Account depositor
test::jtx::PrettyAsset asset