xrpld
Loading...
Searching...
No Matches
LoanTestBase.h
1#pragma once
2
3#include <xrpl/beast/unit_test/suite.h>
4//
5#include <test/jtx/Account.h>
6#include <test/jtx/Env.h>
7#include <test/jtx/JTx.h>
8#include <test/jtx/TestHelpers.h>
9#include <test/jtx/amount.h>
10#include <test/jtx/fee.h>
11#include <test/jtx/flags.h>
12#include <test/jtx/mpt.h>
13#include <test/jtx/multisign.h>
14#include <test/jtx/pay.h>
15#include <test/jtx/permissioned_domains.h>
16#include <test/jtx/sig.h>
17#include <test/jtx/tags.h>
18#include <test/jtx/ter.h>
19#include <test/jtx/trust.h>
20#include <test/jtx/vault.h>
21
22#include <xrpld/rpc/detail/Handler.h>
23
24#include <xrpl/basics/Number.h>
25#include <xrpl/basics/base_uint.h>
26#include <xrpl/basics/chrono.h>
27#include <xrpl/beast/utility/Journal.h>
28#include <xrpl/beast/utility/Zero.h>
29#include <xrpl/json/json_value.h>
30#include <xrpl/ledger/helpers/AccountRootHelpers.h>
31#include <xrpl/ledger/helpers/LendingHelpers.h>
32#include <xrpl/ledger/helpers/VaultHelpers.h>
33#include <xrpl/protocol/Asset.h>
34#include <xrpl/protocol/Feature.h>
35#include <xrpl/protocol/Indexes.h>
36#include <xrpl/protocol/Issue.h>
37#include <xrpl/protocol/Keylet.h>
38#include <xrpl/protocol/LedgerFormats.h>
39#include <xrpl/protocol/MPTIssue.h>
40#include <xrpl/protocol/Protocol.h>
41#include <xrpl/protocol/SField.h>
42#include <xrpl/protocol/STAmount.h>
43#include <xrpl/protocol/SeqProxy.h>
44#include <xrpl/protocol/TER.h>
45#include <xrpl/protocol/TxFlags.h>
46#include <xrpl/protocol/Units.h>
47#include <xrpl/protocol/XRPAmount.h>
48#include <xrpl/server/LoadFeeTrack.h>
49#include <xrpl/tx/transactors/lending/LoanSet.h>
50
51#include <algorithm>
52#include <array>
53#include <chrono>
54#include <cstddef>
55#include <cstdint>
56#include <cstdlib>
57#include <functional>
58#include <initializer_list>
59#include <optional>
60#include <ostream>
61#include <sstream>
62#include <stdexcept>
63#include <string>
64#include <tuple>
65#include <type_traits>
66#include <utility>
67#include <vector>
68
69namespace xrpl::test {
70
71// FixedPrecision-only: asserts, on the given vault, that:
72// - AssetsDeployed exactly equals the sum of the given loans'
73// PrincipalOutstanding, and (when brokerKeylets is non-empty) also
74// exactly equals the sum of the given brokers' DebtTotal;
75// - YieldUnrealized exactly equals the sum of the given loans'
76// TotalValueOutstanding - PrincipalOutstanding - ManagementFeeOutstanding;
77// - stored AssetsTotal <= derived getAssetsTotal, with the gap under one
78// live unit (equal below coarsening), since the stored field is a
79// Downward-rounded cache;
80// - AssetsAvailable <= stored AssetsTotal;
81// - AssetsAvailable exactly equals the vault pseudo-account's real balance
82// of the underlying asset.
83// No-op on non-FixedPrecision vaults. Call after every vault-touching step
84// (LoanSet, LoanPay, LoanManage, VaultDeposit/Withdraw/Clawback) in a
85// FixedPrecision scenario to catch a single-writer drift between the
86// vault's own bookkeeping fields and the ledger's real balances.
87//
88// A free function (not a LoanTestBase member) so it is usable from any
89// beast::unit_test::Suite, including suites in this family that do not
90// derive from LoanTestBase (e.g. LoanBroker_test, VaultFixedPrecision_test).
91// Pass an empty brokerKeylets when the broker-sum cross-check does not apply;
92// it is then skipped.
93inline void
96 jtx::Env& env,
97 Keylet const& vaultKeylet,
98 std::vector<Keylet> const& brokerKeylets,
99 std::vector<Keylet> const& loanKeylets,
100 std::string const& label = {})
101{
102 auto const vaultSle = env.le(vaultKeylet);
103 if (!suite.expect(static_cast<bool>(vaultSle)))
104 return;
106 return;
107
108 Number const vaultAssetsDeployed = vaultSle->at(sfAssetsDeployed);
109
110 Number principalSum{0};
111 Number scheduledInterestSum{0};
112 for (auto const& loanKeylet : loanKeylets)
113 {
114 if (auto const loanSle = env.le(loanKeylet))
115 {
116 principalSum += loanSle->at(sfPrincipalOutstanding);
117 scheduledInterestSum += loanSle->at(sfTotalValueOutstanding) -
118 loanSle->at(sfPrincipalOutstanding) - loanSle->at(sfManagementFeeOutstanding);
119 }
120 }
121 suite.expect(
122 vaultAssetsDeployed == principalSum,
123 (label.empty() ? "" : label + ": ") +
124 std::string{"AssetsDeployed vs PrincipalOutstanding sum mismatch"});
125 suite.expect(
126 Number(vaultSle->at(sfYieldUnrealized)) == scheduledInterestSum,
127 (label.empty() ? "" : label + ": ") +
128 std::string{"YieldUnrealized vs scheduled interest sum mismatch"});
129
130 if (!brokerKeylets.empty())
131 {
132 Number brokerDebtSum{0};
133 for (auto const& brokerKeylet : brokerKeylets)
134 {
135 if (auto const brokerSle = env.le(brokerKeylet))
136 brokerDebtSum += brokerSle->at(sfDebtTotal);
137 }
138 suite.expect(
139 vaultAssetsDeployed == brokerDebtSum,
140 (label.empty() ? "" : label + ": ") +
141 std::string{"AssetsDeployed vs broker DebtTotal sum mismatch"});
142 }
143
144 bool const coarsened = getVaultScale(vaultSle) > getVaultBaseScale(vaultSle);
145 Number const liveUnit{1, getVaultScale(vaultSle)};
146 Number const derived = getAssetsTotal(vaultSle);
147 Number const stored = vaultSle->at(sfAssetsTotal);
148 suite.expect(
149 stored <= derived,
150 (label.empty() ? "" : label + ": ") +
151 std::string{"stored AssetsTotal must not exceed derived AssetsTotal"});
152 Number const atGap = derived - stored;
153 suite.expect(
154 coarsened ? atGap < liveUnit : atGap == beast::kZero,
155 (label.empty() ? "" : label + ": ") +
156 std::string{"AssetsTotal cache gap exceeds one live unit"});
157
158 suite.expect(
159 Number(vaultSle->at(sfAssetsAvailable)) <= stored,
160 (label.empty() ? "" : label + ": ") +
161 std::string{"AssetsAvailable must not exceed stored AssetsTotal"});
162
163 // AssetsAvailable must exactly track the vault pseudo-account's real
164 // balance: adjustVaultBalances applies the same arithmetic the ledger
165 // uses for the transfer, so the two never drift apart.
166 jtx::Account const vaultAccount("vault", vaultSle->at(sfAccount));
167 env.memoize(vaultAccount);
168 Asset const vaultAsset = vaultSle->at(sfAsset);
169 Number const pseudoBalance = env.balance(vaultAccount, vaultAsset).value();
170 Number const assetsAvailable = vaultSle->at(sfAssetsAvailable);
171 suite.expect(
172 assetsAvailable == pseudoBalance,
173 (label.empty() ? "" : label + ": ") +
174 std::string{"AssetsAvailable vs pseudo-account balance mismatch"});
175}
176
188{
189protected:
190 // Ensure that all the features needed for Lending Protocol are included,
191 // even if they are set to unsupported.
192 //
193 // featureLendingProtocolV1_1 is excluded from the default set: it changes
194 // Vault/LoanBroker accounting (AssetsTotal/DebtTotal/LossUnrealized), and
195 // most of this file's tests assert instant-interest-recognition-specific expected values
196 // for those fields. Tests that specifically exercise the amendment opt
197 // it back in explicitly (e.g. `all_ | featureLendingProtocolV1_1`).
198 FeatureBitset const all_{jtx::testableAmendments() - featureLendingProtocolV1_1};
200
202 {
203 Number vaultDeposit = 1'000'000;
204 Number debtMax = 25'000;
206 int coverDeposit = 1000;
209 std::string data = {}; // NOLINT(readability-redundant-member-init)
211 // If set, passed to LoanBrokerSet as sfDomainID. Only valid together
212 // with tfLoanBrokerPrivate in `flags`.
214 std::nullopt; // NOLINT(readability-redundant-member-init)
215 // VaultCreate flags (e.g. tfVaultPrivate). Distinct from `flags`,
216 // which are passed to LoanBrokerSet.
218 std::nullopt; // NOLINT(readability-redundant-member-init)
219 // If set, the vault is created with this sfScale value. Useful for
220 // tests that need finer loanScale to exercise rounding edge cases.
222 std::nullopt; // NOLINT(readability-redundant-member-init)
223 // Vault kind axis. When ClosedEnded, createVaultAndBroker sets sfSubscriptionDate /
224 // sfRedemptionDate from env.now() using the offsets below and advances the ledger clock
225 // past SubscriptionDate so the vault is in the Investment phase by the time the broker is
226 // set up. Requires featureLendingProtocolV1_1.
228 // Seconds past env.now() at which SubscriptionDate lands. Must be strictly positive
229 // (VaultCreate::preclaim rejects SubscriptionDate <= parentCloseTime).
231 // Seconds between SubscriptionDate and RedemptionDate. Must be >= kMinInvestmentPeriod, <
232 // kMaxInvestmentPeriod, and generous enough to fit any loan schedule the test runs
233 // (finalPayment must precede RedemptionDate by at least kLoanRedemptionBuffer). Default
234 // sized to comfortably exceed any schedule realistic tests are likely to configure.
235 std::uint32_t redemptionOffset = 10u * 365u * 24u * 60u * 60u;
236 // When true, createVaultAndBroker skips its automatic clock advance past SubscriptionDate.
237 // Useful for tests that need to observe the vault while it is still in the Subscription
238 // phase. Ignored for open-ended vaults.
239 bool skipPhaseAdvance = false;
240
241 [[nodiscard]] Number
242 maxCoveredLoanValue(Number const& currentDebt) const
243 {
245 auto const debtLimit = coverDeposit * kTenthBipsPerUnity.value() / coverRateMin.value();
246
247 return debtLimit - currentDebt;
248 }
249
250 static BrokerParameters const&
252 {
253 static BrokerParameters const kResult{};
254 return kResult;
255 }
256
257 // TODO: create an operator() which returns a transaction similar to
258 // LoanParameters
259 };
260
262 {
267 // Absolute dates resolved by createVaultAndBroker when params.vaultKind
268 // is ClosedEnded; std::nullopt for open-ended vaults.
286
287 [[nodiscard]] Keylet
289 {
291 }
292 [[nodiscard]] Keylet
294 {
295 return keylet::vault(vaultID);
296 }
297
298 [[nodiscard]] int
299 vaultScale(jtx::Env const& env) const
300 {
301 using namespace jtx;
302
303 auto const vaultSle = env.le(keylet::vault(vaultID));
304 return getVaultScale(vaultSle);
305 }
306 };
307
309 {
310 // The account submitting the transaction. May be borrower or broker.
312 // The counterparty. Should be the other of borrower or broker.
314 // Whether the counterparty is specified in the `counterparty` field, or
315 // only signs.
318 // NOLINTBEGIN(readability-redundant-member-init)
333 // NOLINTEND(readability-redundant-member-init)
334
335 template <class... FN>
337 operator()(jtx::Env& env, BrokerInfo const& broker, FN const&... fN) const
338 {
339 using namespace jtx;
340 using namespace jtx::loan;
341
342 JTx jt{loan::set(
343 account,
344 broker.brokerID,
345 broker.asset(principalRequest).number(),
346 flags.value_or(0))};
347
348 Sig(sfCounterpartySignature, counter)(env, jt);
349
350 Fee{setFee.value_or(env.current()->fees().base * 2)}(env, jt);
351
353 kCounterparty(counter)(env, jt);
354 if (originationFee)
355 kLoanOriginationFee(broker.asset(*originationFee).number())(env, jt);
356 if (serviceFee)
357 kLoanServiceFee(broker.asset(*serviceFee).number())(env, jt);
358 if (lateFee)
359 kLatePaymentFee(broker.asset(*lateFee).number())(env, jt);
360 if (closeFee)
361 kClosePaymentFee(broker.asset(*closeFee).number())(env, jt);
362 if (overFee)
363 kOverpaymentFee (*overFee)(env, jt);
364 if (interest)
365 kInterestRate (*interest)(env, jt);
366 if (lateInterest)
367 kLateInterestRate (*lateInterest)(env, jt);
368 if (closeInterest)
369 kCloseInterestRate (*closeInterest)(env, jt);
371 kOverpaymentInterestRate (*overpaymentInterest)(env, jt);
372 if (payTotal)
373 kPaymentTotal (*payTotal)(env, jt);
374 if (payInterval)
375 kPaymentInterval (*payInterval)(env, jt);
376 if (gracePd)
377 kGracePeriod (*gracePd)(env, jt);
378
379 return env.jt(jt, fN...);
380 }
381 };
382
384 {
388 bool showStepBalances = false;
389 bool validateBalances = true;
390
391 static PaymentParameters const&
393 {
394 static PaymentParameters const kResult{};
395 return kResult;
396 }
397 };
398
414
420 {
421 public:
422 jtx::Env const& env;
426
428 jtx::Env const& env,
429 BrokerInfo const& broker,
430 jtx::Account const& pseudo,
431 Keylet const& keylet)
433 {
434 }
435
439 void
441 Number const& principalOutstanding,
442 Number const& interestOwed,
443 TenthBips32 interestRate,
444 std::uint32_t paymentInterval,
445 std::uint32_t paymentsRemaining,
447 {
448 using namespace jtx;
449 if (auto const brokerSle = env.le(keylet::loanBroker(broker.brokerID));
450 env.test.BEAST_EXPECT(brokerSle))
451 {
452 TenthBips16 const managementFeeRate{brokerSle->at(sfManagementFeeRate)};
453 auto const brokerDebt = brokerSle->at(sfDebtTotal);
454
455 if (auto const vaultSle = env.le(keylet::vault(brokerSle->at(sfVaultID)));
456 env.test.BEAST_EXPECT(vaultSle))
457 {
458 auto const expectedDebt =
459 env.current()->rules().enabled(featureLendingProtocolV1_1) &&
461 ? principalOutstanding
462 : principalOutstanding + interestOwed;
463 env.test.BEAST_EXPECT(brokerDebt == expectedDebt);
464 env.test.BEAST_EXPECT(
465 env.balance(pseudoAccount, broker.asset).number() ==
466 brokerSle->at(sfCoverAvailable));
467 env.test.BEAST_EXPECT(brokerSle->at(sfOwnerCount) == ownerCount);
468
469 Account const vaultPseudo{"vaultPseudoAccount", vaultSle->at(sfAccount)};
470 env.test.BEAST_EXPECT(
471 vaultSle->at(sfAssetsAvailable) ==
472 env.balance(vaultPseudo, broker.asset).number());
473 if (ownerCount == 0)
474 {
475 // The Vault must be perfectly balanced if there
476 // are no loans outstanding
477 auto const total = vaultSle->at(sfAssetsTotal);
478 auto const available = vaultSle->at(sfAssetsAvailable);
479 env.test.BEAST_EXPECT(total == available);
480 env.test.BEAST_EXPECT(vaultSle->at(sfLossUnrealized) == 0);
481 }
482 }
483 }
484 }
485
486 void
488 std::int32_t loanScale,
489 jtx::Account const& account,
490 jtx::PrettyAmount const& balanceBefore,
491 STAmount const& expectedPayment,
492 jtx::PrettyAmount const& adjustment) const
493 {
494 auto const borrowerScale = std::max(loanScale, balanceBefore.number().exponent());
495
496 STAmount const balanceChangeAmount{
497 broker.asset,
498 roundToAsset(broker.asset, expectedPayment + adjustment, borrowerScale)};
499 {
500 auto const difference = roundToScale(
501 env.balance(account, broker.asset) - (balanceBefore - balanceChangeAmount),
502 borrowerScale);
503 env.test.expect(
504 roundToScale(difference, loanScale) >= beast::kZero,
505 "Balance before: " + to_string(balanceBefore.value()) +
506 ", expected change: " + to_string(balanceChangeAmount) +
507 ", difference (balance after - expected): " + to_string(difference),
508 __FILE__,
509 __LINE__);
510 }
511 }
512
516 void
518 std::uint32_t previousPaymentDate,
519 std::uint32_t nextPaymentDate,
520 std::uint32_t paymentRemaining,
521 Number const& loanScale,
522 Number const& totalValue,
523 Number const& principalOutstanding,
524 Number const& managementFeeOutstanding,
525 Number const& periodicPayment,
526 std::uint32_t flags) const
527 {
528 using namespace jtx;
529 if (auto const loan = env.le(loanKeylet); env.test.BEAST_EXPECT(loan))
530 {
531 env.test.BEAST_EXPECT(loan->at(sfPreviousPaymentDueDate) == previousPaymentDate);
532 env.test.BEAST_EXPECT(loan->at(sfPaymentRemaining) == paymentRemaining);
533 env.test.BEAST_EXPECT(loan->at(sfNextPaymentDueDate) == nextPaymentDate);
534 env.test.BEAST_EXPECT(loan->at(sfLoanScale) == loanScale);
535 env.test.BEAST_EXPECT(loan->at(sfTotalValueOutstanding) == totalValue);
536 env.test.BEAST_EXPECT(loan->at(sfPrincipalOutstanding) == principalOutstanding);
537 env.test.BEAST_EXPECT(
538 loan->at(sfManagementFeeOutstanding) == managementFeeOutstanding);
539 env.test.BEAST_EXPECT(loan->at(sfPeriodicPayment) == periodicPayment);
540 env.test.BEAST_EXPECT(loan->at(sfFlags) == flags);
541
542 auto const ls = constructLoanState(loan);
543
544 auto const interestRate = TenthBips32{loan->at(sfInterestRate)};
545 auto const paymentInterval = loan->at(sfPaymentInterval);
547 principalOutstanding,
548 ls.interestDue,
549 interestRate,
550 paymentInterval,
551 paymentRemaining,
552 1);
553
554 if (auto const brokerSle = env.le(keylet::loanBroker(broker.brokerID));
555 env.test.BEAST_EXPECT(brokerSle))
556 {
557 if (auto const vaultSle = env.le(keylet::vault(brokerSle->at(sfVaultID)));
558 env.test.BEAST_EXPECT(vaultSle))
559 {
560 if (((flags & lsfLoanImpaired) != 0u) && ((flags & lsfLoanDefault) == 0u))
561 {
562 env.test.BEAST_EXPECT(
563 vaultSle->at(sfLossUnrealized) ==
564 (env.current()->rules().enabled(featureLendingProtocolV1_1) &&
566 ? principalOutstanding
567 : totalValue - managementFeeOutstanding));
568 }
569 else
570 {
571 env.test.BEAST_EXPECT(vaultSle->at(sfLossUnrealized) == 0);
572 }
573 }
574 }
575 }
576 }
577
581 void
582 operator()(LoanState const& state) const
583 {
586 state.nextPaymentDate,
587 state.paymentRemaining,
588 state.loanScale,
589 state.totalValue,
592 state.periodicPayment,
593 state.flags);
594 };
595 };
596
597 BrokerInfo
599 jtx::Env& env,
600 jtx::PrettyAsset const& asset,
601 jtx::Account const& lender,
603 {
604 using namespace jtx;
605
606 Vault const vault{env};
607
608 auto const deposit = asset(params.vaultDeposit);
609 auto const debtMaximumValue = asset(params.debtMax).value();
610 auto const coverDepositValue = asset(params.coverDeposit).value();
611
612 auto const coverRateMinValue = params.coverRateMin;
613
614 // Under featureLendingProtocolV1_1 LoanBrokerSet::preclaim rejects
615 // brokers attached to open-ended vaults. Many callers of this
616 // helper leave vaultKind at the OpenEnded default and don't care
617 // about the vault kind per se — they just need a broker on a
618 // vault. When LP V1.1 is enabled, transparently promote to
619 // ClosedEnded so those tests keep working without threading
620 // vaultKind through every call site. Callers that explicitly
621 // asked for ClosedEnded are left untouched. Tests that want to
622 // exercise the open-ended rejection under LP V1.1 build their own
623 // vault directly instead of going through this helper, since it
624 // always promotes OpenEnded once the amendment is enabled.
625 auto effectiveVaultKind = params.vaultKind;
626 if (env.current()->rules().enabled(featureLendingProtocolV1_1) &&
627 effectiveVaultKind == VaultKind::OpenEnded)
628 {
629 effectiveVaultKind = VaultKind::ClosedEnded;
630 }
631
632 std::optional<std::uint32_t> subscriptionDate;
633 std::optional<std::uint32_t> redemptionDate;
634 if (effectiveVaultKind == VaultKind::ClosedEnded)
635 {
636 auto const nowSec = env.now().time_since_epoch().count();
637 subscriptionDate = nowSec + params.subscriptionOffset;
638 redemptionDate = *subscriptionDate + params.redemptionOffset;
639 }
640
641 auto [tx, vaultKeylet] = vault.create({
642 .owner = lender,
643 .asset = asset,
644 .flags = params.vaultFlags,
645 .vaultKind = effectiveVaultKind == VaultKind::OpenEnded
647 : std::optional<std::uint8_t>{std::to_underlying(effectiveVaultKind)},
648 .subscriptionDate = subscriptionDate,
649 .redemptionDate = redemptionDate,
650 });
651 if (params.vaultScale)
652 tx[sfScale] = *params.vaultScale;
653 env(tx);
654 env.close();
655 BEAST_EXPECT(env.le(vaultKeylet));
656
657 env(vault.deposit({.depositor = lender, .id = vaultKeylet.key, .amount = deposit}));
658 env.close();
659 if (auto const vault = env.le(keylet::vault(vaultKeylet.key)); BEAST_EXPECT(vault))
660 {
661 BEAST_EXPECT(vault->at(sfAssetsAvailable) == deposit.value());
662 }
663
664 // For closed-ended vaults, advance past SubscriptionDate so subsequent LoanSet operations
665 // run in the Investment phase (unless the caller explicitly asked to stay in Subscription).
666 if (subscriptionDate && !params.skipPhaseAdvance)
667 {
668 using D = NetClock::duration;
669 using Tp = NetClock::time_point;
670 env.close(Tp{D{*subscriptionDate + 1}});
671 }
672
673 auto const keylet = keylet::loanBroker(lender.id(), SeqProxy::rawSequence(env.seq(lender)));
674
675 using namespace loan_broker;
676 auto brokerSetTx = set(lender, vaultKeylet.key, params.flags);
677 if (params.domainID)
678 brokerSetTx[sfDomainID] = to_string(*params.domainID);
679 env(brokerSetTx,
680 kData(params.data),
681 kManagementFeeRate(params.managementFeeRate),
682 kDebtMaximum(debtMaximumValue),
683 kCoverRateMinimum(coverRateMinValue),
684 kCoverRateLiquidation(TenthBips32(params.coverRateLiquidation)));
685
686 if (coverDepositValue != beast::kZero)
687 env(coverDeposit(lender, keylet.key, coverDepositValue));
688
689 env.close();
690
691 return {asset, keylet, vaultKeylet, params, subscriptionDate, redemptionDate};
692 }
693
694 // Creates a permissioned domain owned by `owner` that accepts credentials
695 // of `credType` issued by `credIssuer`, and returns its ID.
696 uint256
698 jtx::Env& env,
699 jtx::Account const& owner,
700 jtx::Account const& credIssuer,
701 std::string const& credType)
702 {
703 using namespace jtx;
704
705 pdomain::Credentials const credentials{{.issuer = credIssuer, .credType = credType}};
706 env(pdomain::setTx(owner, credentials));
707 env.close();
708
709 auto const domainID = pdomain::getNewDomain(env.meta());
710 BEAST_EXPECT(domainID != beast::kZero);
711 return domainID;
712 }
713
718 getCurrentState(jtx::Env const& env, BrokerInfo const& broker, Keylet const& loanKeylet)
719 {
720 using D = NetClock::duration;
721 using Tp = NetClock::time_point;
722
723 // Lookup the current loan state
724 if (auto const loan = env.le(loanKeylet); BEAST_EXPECT(loan))
725 {
726 return LoanState{
727 .previousPaymentDate = loan->at(sfPreviousPaymentDueDate),
728 .startDate = Tp{D{loan->at(sfStartDate)}},
729 .nextPaymentDate = loan->at(sfNextPaymentDueDate),
730 .paymentRemaining = loan->at(sfPaymentRemaining),
731 .loanScale = loan->at(sfLoanScale),
732 .totalValue = loan->at(sfTotalValueOutstanding),
733 .principalOutstanding = loan->at(sfPrincipalOutstanding),
734 .managementFeeOutstanding = loan->at(sfManagementFeeOutstanding),
735 .periodicPayment = loan->at(sfPeriodicPayment),
736 .flags = loan->at(sfFlags),
737 .paymentInterval = loan->at(sfPaymentInterval),
738 .interestRate = TenthBips32{loan->at(sfInterestRate)},
739 };
740 }
741 return LoanState{};
742 }
743
750 jtx::Env const& env,
751 BrokerInfo const& broker,
752 Keylet const& loanKeylet,
753 VerifyLoanStatus const& verifyLoanStatus)
754 {
755 using namespace std::chrono_literals;
756 using D = NetClock::duration;
757 using Tp = NetClock::time_point;
758
759 auto const state = getCurrentState(env, broker, loanKeylet);
760 BEAST_EXPECT(state.previousPaymentDate == 0);
761 BEAST_EXPECT(Tp{D{state.nextPaymentDate}} == state.startDate + 600s);
762 BEAST_EXPECT(state.paymentRemaining == 12);
763 BEAST_EXPECT(state.principalOutstanding == broker.asset(1000).value());
764 BEAST_EXPECT(
765 state.loanScale >=
766 (broker.asset.integral()
767 ? 0
768 : std::max(broker.vaultScale(env), state.principalOutstanding.exponent())));
769 BEAST_EXPECT(state.paymentInterval == 600);
770 {
772 BEAST_EXPECT(
773 state.totalValue ==
775 broker.asset, state.periodicPayment * state.paymentRemaining, state.loanScale));
776 }
777 BEAST_EXPECT(
778 state.managementFeeOutstanding ==
780 broker.asset,
781 state.totalValue - state.principalOutstanding,
783 state.loanScale));
784
785 verifyLoanStatus(state);
786
787 return state;
788 }
789
790 bool
791 canImpairLoan(jtx::Env const& env, BrokerInfo const& broker, LoanState const& state)
792 {
793 if (auto const brokerSle = env.le(keylet::loanBroker(broker.brokerID));
794 BEAST_EXPECT(brokerSle))
795 {
796 if (auto const vaultSle = env.le(keylet::vault(brokerSle->at(sfVaultID)));
797 BEAST_EXPECT(vaultSle))
798 {
799 // log << vaultSle->getJson() << std::endl;
800 auto const assetsUnavailable =
801 vaultSle->at(sfAssetsTotal) - vaultSle->at(sfAssetsAvailable);
802 auto const unrealizedLoss = vaultSle->at(sfLossUnrealized) +
803 (env.current()->rules().enabled(featureLendingProtocolV1_1) &&
806 : state.totalValue - state.managementFeeOutstanding);
807
808 if (!BEAST_EXPECT(unrealizedLoss <= assetsUnavailable))
809 {
810 return false;
811 }
812 }
813 }
814 return true;
815 }
816
817 // Under fixCleanup3_4_0, LoanManage rejects tfLoanImpair with tecTOO_SOON
818 // unless the loan payment is already late. Advance the ledger past the
819 // loan's sfNextPaymentDueDate so shared lifecycle flows still exercise
820 // the tesSUCCESS branch when the amendment is active. No-op when the
821 // amendment is disabled.
822 void
823 advancePastDueDate(jtx::Env& env, Keylet const& loanKeylet)
824 {
825 if (!env.current()->rules().enabled(fixCleanup3_4_0))
826 return;
827 auto const loan = env.le(loanKeylet);
828 if (!BEAST_EXPECT(loan))
829 return;
830 std::uint32_t const dueDate = loan->at(sfNextPaymentDueDate);
832 }
833
834 enum class AssetType { XRP = 0, IOU = 1, MPT = 2 };
835
836 // Specify the accounts as params to allow other accounts to be used
839 jtx::Env& env,
840 AssetType assetType,
841 BrokerParameters const& brokerParams,
842 jtx::Account const& issuer,
843 jtx::Account const& lender,
844 jtx::Account const& borrower)
845 {
846 using namespace jtx;
847
848 switch (assetType)
849 {
850 case AssetType::XRP:
851 // TODO: remove the factor, and set up loans in drops
852 return PrettyAsset{xrpIssue(), 1'000'000};
853
854 case AssetType::IOU: {
855 PrettyAsset const asset{issuer[iouCurrency_]};
856
857 auto const limit =
858 asset(100 * (brokerParams.vaultDeposit + brokerParams.coverDeposit));
859 if (lender != issuer)
860 env(trust(lender, limit));
861 if (borrower != issuer)
862 env(trust(borrower, limit));
863
864 return asset;
865 }
866
867 case AssetType::MPT: {
868 // Enough to cover initial fees
869 if (!env.le(keylet::account(issuer)))
870 env.fund(env.current()->fees().accountReserve(10, 1) * 10, issuer);
871 if (!env.le(keylet::account(lender)))
872 env.fund(env.current()->fees().accountReserve(10, 1) * 10, noripple(lender));
873 if (!env.le(keylet::account(borrower)))
874 env.fund(env.current()->fees().accountReserve(10, 1) * 10, noripple(borrower));
875
876 MPTTester mptt{env, issuer, kMptInitNoFund};
877 mptt.create({.flags = tfMPTCanClawback | tfMPTCanTransfer | tfMPTCanLock});
878 // Scale the MPT asset so interest is interesting
879 PrettyAsset const asset{mptt.issuanceID(), 10'000};
880 // Need to do the authorization here because mptt isn't
881 // accessible outside
882 if (lender != issuer)
883 mptt.authorize({.account = lender});
884 if (borrower != issuer)
885 mptt.authorize({.account = borrower});
886
887 env.close();
888
889 return asset;
890 }
891
892 default:
893 throw std::runtime_error("Unknown asset type");
894 }
895 }
896
897 // Predicts the keylet of the next loan `broker` will originate, before
898 // that loan exists, by reading the broker's current LoanSequence.
899 Keylet
900 nextLoanKeylet(jtx::Env const& env, BrokerInfo const& broker)
901 {
902 auto const brokerStateBefore = env.le(keylet::loanBroker(broker.brokerID));
903 if (!BEAST_EXPECT(brokerStateBefore))
905 auto const loanSequence = brokerStateBefore->at(sfLoanSequence);
906 return keylet::loan(broker.brokerID, SeqProxy::rawSequence(loanSequence));
907 }
908
909 // Funds issuer/lender/borrower with XRP, creates an IOU asset issued by
910 // `issuer`, establishes trustlines for lender and borrower, and pays
911 // them starting balances. This is the exact setup shared by several of
912 // the fuzzer-derived regression tests below.
915 jtx::Env& env,
916 jtx::Account const& issuer,
917 jtx::Account const& lender,
918 jtx::Account const& borrower,
919 Number const& lenderPay = 100'000'000,
920 Number const& borrowerPay = 1'000'000)
921 {
922 using namespace jtx;
923
924 env.fund(XRP(1'000'000), issuer, lender, borrower);
925 env.close();
926
927 PrettyAsset const iouAsset = issuer[iouCurrency_];
928 auto const trustLenderTx = env.json(trust(lender, iouAsset(1'000'000'000)));
929 env(trustLenderTx);
930 auto const trustBorrowerTx = env.json(trust(borrower, iouAsset(1'000'000'000)));
931 env(trustBorrowerTx);
932 auto const payLenderTx = pay(issuer, lender, iouAsset(lenderPay));
933 env(payLenderTx);
934 auto const payIssuerTx = pay(issuer, borrower, iouAsset(borrowerPay));
935 env(payIssuerTx);
936 env.close();
937
938 return iouAsset;
939 }
940
941 // Funds issuer/lender/borrower with XRP, sets DefaultRipple on the
942 // issuer, creates a "USD" IOU asset with a large trust limit, and pays
943 // lender/borrower starting balances. Shared setup for several
944 // overpayment/rounding regression tests below.
945 static jtx::PrettyAsset
947 jtx::Env& env,
948 jtx::Account const& issuer,
949 jtx::Account const& lender,
950 jtx::Account const& borrower,
951 Number const& lenderPay = 1'000'000,
952 Number const& borrowerPay = 1'000'000)
953 {
954 using namespace jtx;
955
956 env.fund(XRP(1'000'000), issuer, lender, borrower);
957 env(fset(issuer, asfDefaultRipple));
958 env.close();
959
960 PrettyAsset const iouAsset = issuer["USD"];
961 STAmount const iouLimit{iouAsset.raw(), Number{9'999'999'999'999'999LL}};
962 env(trust(lender, iouLimit));
963 env(trust(borrower, iouLimit));
964 env(pay(issuer, lender, iouAsset(lenderPay)));
965 env(pay(issuer, borrower, iouAsset(borrowerPay)));
966 env.close();
967
968 return iouAsset;
969 }
970
971 // Returns the broker's pseudo-account, or `fallback` if the broker's
972 // ledger entry cannot be read.
974 brokerPseudoAccount(jtx::Env const& env, BrokerInfo const& broker, jtx::Account const& fallback)
975 {
976 auto const brokerSle = env.le(keylet::loanBroker(broker.brokerID));
977 if (!BEAST_EXPECT(brokerSle))
978 return fallback;
979 auto const brokerPseudo = brokerSle->at(sfAccount);
980 return jtx::Account("Broker pseudo-account", brokerPseudo);
981 }
982
983 void
985 jtx::Env& env,
986 BrokerParameters const& brokerParams,
987 LoanParameters const& loanParams,
988 AssetType assetType,
989 jtx::Account const& issuer,
990 jtx::Account const& lender,
991 jtx::Account const& borrower)
992 {
993 using namespace jtx;
994
995 auto const asset = createAsset(env, assetType, brokerParams, issuer, lender, borrower);
996 auto const principal = asset(loanParams.principalRequest).number();
997 auto const interest = loanParams.interest.value_or(TenthBips32{});
998 auto const interval = loanParams.payInterval.value_or(LoanSet::kDefaultPaymentInterval);
999 auto const total = loanParams.payTotal.value_or(LoanSet::kDefaultPaymentTotal);
1000 auto const feeRate = brokerParams.managementFeeRate;
1001 auto const props = computeLoanProperties(
1002 env.current()->rules(),
1003 asset,
1004 principal,
1005 interest,
1006 interval,
1007 total,
1008 feeRate,
1009 asset(brokerParams.vaultDeposit).number().exponent());
1010
1011 // checkGuards returns a TER, so success is 0
1012 BEAST_EXPECT(!checkLoanGuards(
1013 asset,
1014 asset(loanParams.principalRequest).number(),
1015 loanParams.interest.value_or(TenthBips32{}) != beast::kZero,
1017 props,
1018 env.journal));
1019 }
1020
1023 jtx::Env& env,
1024 AssetType assetType,
1025 BrokerParameters const& brokerParams,
1026 LoanParameters const& loanParams,
1027 jtx::Account const& issuer,
1028 jtx::Account const& lender,
1029 jtx::Account const& borrower)
1030 {
1031 using namespace jtx;
1032
1033 // Enough to cover initial fees
1034 env.fund(env.current()->fees().accountReserve(10, 1) * 10, issuer);
1035 if (lender != issuer)
1036 env.fund(env.current()->fees().accountReserve(10, 1) * 10, noripple(lender));
1037 if (borrower != issuer && borrower != lender)
1038 env.fund(env.current()->fees().accountReserve(10, 1) * 10, noripple(borrower));
1039
1040 describeLoan(env, brokerParams, loanParams, assetType, issuer, lender, borrower);
1041
1042 // Make the asset
1043 auto const asset = createAsset(env, assetType, brokerParams, issuer, lender, borrower);
1044
1045 env.close();
1046 if (asset.native() || lender != issuer)
1047 {
1048 env(
1049 pay((asset.native() ? env.master : issuer),
1050 lender,
1051 asset(brokerParams.vaultDeposit + brokerParams.coverDeposit)));
1052 }
1053 // Fund the borrower later once we know the total loan
1054 // size
1055
1056 BrokerInfo const broker = createVaultAndBroker(env, asset, lender, brokerParams);
1057
1058 auto const pseudoAcctOpt = [&] -> std::optional<Account> {
1059 auto const brokerSle = env.le(keylet::loanBroker(broker.brokerID));
1060 if (!BEAST_EXPECT(brokerSle))
1061 return std::nullopt;
1062 auto const brokerPseudo = brokerSle->at(sfAccount);
1063 return Account("Broker pseudo-account", brokerPseudo);
1064 }();
1065 if (!pseudoAcctOpt)
1066 return std::nullopt;
1067 Account const& pseudoAcct = *pseudoAcctOpt;
1068
1069 auto const loanKeyletOpt = [&] -> std::optional<Keylet> {
1070 auto const brokerSle = env.le(keylet::loanBroker(broker.brokerID));
1071 if (!BEAST_EXPECT(brokerSle))
1072 return std::nullopt;
1073
1074 // Broker has no loans
1075 BEAST_EXPECT(brokerSle->at(sfOwnerCount) == 0);
1076
1077 // The loan keylet is based on the LoanSequence of the
1078 // _LOAN_BROKER_ object.
1079 auto const loanSequence = brokerSle->at(sfLoanSequence);
1080 return keylet::loan(broker.brokerID, SeqProxy::rawSequence(loanSequence));
1081 }();
1082 if (!loanKeyletOpt)
1083 return std::nullopt;
1084 Keylet const& loanKeylet = *loanKeyletOpt;
1085
1086 env(loanParams(env, broker));
1087
1088 env.close();
1089
1090 return std::make_tuple(broker, loanKeylet, pseudoAcct);
1091 }
1092
1093 static void
1095 jtx::Env& env,
1096 BrokerInfo const& broker,
1097 jtx::Account const& issuer,
1098 jtx::Account const& borrower,
1099 LoanState const& state,
1100 std::optional<Number> const& servFee)
1101 {
1102 using namespace jtx;
1103
1104 STAmount const serviceFee = broker.asset(servFee.value_or(0));
1105
1106 // Ensure the borrower has enough funds to make the payments
1107 // (including tx fees, if necessary)
1108 auto const borrowerBalance = env.balance(borrower, broker.asset);
1109
1110 auto const baseFee = env.current()->fees().base;
1111
1112 // Add extra for transaction fees and reserves, if appropriate, or a
1113 // tiny amount for the extra paid in each transaction
1114 auto const totalNeeded = state.totalValue + (serviceFee * state.paymentRemaining) +
1115 (broker.asset.native() ? Number(
1116 baseFee * state.paymentRemaining +
1117 accountReserve(*env.current(), borrower.id(), env.journal))
1118 : broker.asset(15).number());
1119
1120 auto const shortage = totalNeeded - borrowerBalance.number();
1121
1122 if (shortage > beast::kZero && (broker.asset.native() || issuer != borrower))
1123 {
1124 env(
1125 pay((broker.asset.native() ? env.master : issuer),
1126 borrower,
1127 STAmount{broker.asset, shortage}));
1128 }
1129 }
1130
1131 void
1133 jtx::Env& env,
1134 BrokerInfo const& broker,
1135 LoanParameters const& loanParams,
1136 Keylet const& loanKeylet,
1137 VerifyLoanStatus const& verifyLoanStatus,
1138 jtx::Account const& issuer,
1139 jtx::Account const& lender,
1140 jtx::Account const& borrower,
1141 PaymentParameters const& paymentParams = PaymentParameters::defaults())
1142 {
1143 // Make all the individual payments
1144 using namespace jtx;
1145 using namespace jtx::loan;
1146 using namespace std::chrono_literals;
1147 using D = NetClock::duration;
1148
1149 bool const showStepBalances = paymentParams.showStepBalances;
1150
1151 auto const currencyLabel = getCurrencyLabel(broker.asset);
1152
1153 auto const baseFee = env.current()->fees().base;
1154
1155 env.close();
1156 auto state = getCurrentState(env, broker, loanKeylet);
1157
1158 verifyLoanStatus(state);
1159
1160 STAmount const serviceFee = broker.asset(loanParams.serviceFee.value_or(0));
1161
1162 topUpBorrower(env, broker, issuer, borrower, state, loanParams.serviceFee);
1163
1164 // Periodic payment amount will consist of
1165 // 1. principal outstanding (1000)
1166 // 2. interest interest rate (at 12%)
1167 // 3. payment interval (600s)
1168 // 4. loan service fee (2)
1169 // Calculate these values without the helper functions
1170 // to verify they're working correctly The numbers in
1171 // the below BEAST_EXPECTs may not hold across assets.
1172 auto const periodicRate = loanPeriodicRate(state.interestRate, state.paymentInterval);
1173 STAmount const roundedPeriodicPayment{
1174 broker.asset,
1175 roundPeriodicPayment(broker.asset, state.periodicPayment, state.loanScale)};
1176
1177 if (!showStepBalances)
1178 {
1179 log << currencyLabel << " Payment components: "
1180 << "Payments remaining, "
1181 << "rawInterest, rawPrincipal, "
1182 "rawMFee, "
1183 << "trackedValueDelta, trackedPrincipalDelta, "
1184 "trackedInterestDelta, trackedMgmtFeeDelta, special"
1185 << std::endl;
1186 }
1187
1188 // Include the service fee
1189 STAmount const totalDue = roundToScale(
1190 roundedPeriodicPayment + serviceFee, state.loanScale, Number::RoundingMode::Upward);
1191
1192 auto currentRoundedState = constructLoanState(
1193 state.totalValue, state.principalOutstanding, state.managementFeeOutstanding);
1194 {
1195 auto const raw = computeTheoreticalLoanState(
1196 env.current()->rules(),
1197 state.periodicPayment,
1198 periodicRate,
1199 state.paymentRemaining,
1200 broker.params.managementFeeRate);
1201
1202 if (showStepBalances)
1203 {
1204 log << currencyLabel << " Starting loan balances: "
1205 << "\n\tTotal value: " << currentRoundedState.valueOutstanding
1206 << "\n\tPrincipal: " << currentRoundedState.principalOutstanding
1207 << "\n\tInterest: " << currentRoundedState.interestDue
1208 << "\n\tMgmt fee: " << currentRoundedState.managementFeeDue
1209 << "\n\tPayments remaining " << state.paymentRemaining << std::endl;
1210 }
1211 else
1212 {
1213 log << currencyLabel << " Loan starting state: " << state.paymentRemaining << ", "
1214 << raw.interestDue << ", " << raw.principalOutstanding << ", "
1215 << raw.managementFeeDue << ", " << currentRoundedState.valueOutstanding << ", "
1216 << currentRoundedState.principalOutstanding << ", "
1217 << currentRoundedState.interestDue << ", "
1218 << currentRoundedState.managementFeeDue << std::endl;
1219 }
1220 }
1221
1222 // Try to pay a little extra to show that it's _not_
1223 // taken
1224 auto const extraAmount = paymentParams.overpaymentExtra
1225 ? broker.asset(*paymentParams.overpaymentExtra).value()
1226 : std::min(broker.asset(10).value(), STAmount{broker.asset, totalDue / 20});
1227
1228 STAmount const transactionAmount =
1229 STAmount{broker.asset, totalDue * paymentParams.overpaymentFactor} + extraAmount;
1230
1231 auto const borrowerInitialBalance = env.balance(borrower, broker.asset).number();
1232 auto const initialState = state;
1234 .trackedValueDelta = 0,
1235 .trackedPrincipalDelta = 0,
1236 .trackedManagementFeeDelta = 0,
1237 };
1238 Number totalInterestPaid = 0;
1239 Number totalFeesPaid = 0;
1240 std::size_t totalPaymentsMade = 0;
1241
1243 env.current()->rules(),
1244 state.periodicPayment,
1245 periodicRate,
1246 state.paymentRemaining,
1247 broker.params.managementFeeRate);
1248
1249 auto const validateBorrowerBalance = [&] {
1250 if (borrower == issuer || !paymentParams.validateBalances)
1251 return;
1252 auto const totalSpent =
1253 (totalPaid.trackedValueDelta + totalFeesPaid +
1254 (broker.asset.native() ? Number(baseFee) * totalPaymentsMade : kNumZero));
1255 BEAST_EXPECT(
1256 env.balance(borrower, broker.asset).number() ==
1257 borrowerInitialBalance - totalSpent);
1258 };
1259
1260 auto const defaultRound = broker.asset.integral() ? 3 : 0;
1261 auto const truncate = [defaultRound](
1262 Number const& n, std::optional<int> places = std::nullopt) {
1263 auto const p = places.value_or(defaultRound);
1264 if (p == 0)
1265 return n;
1266 auto const factor = Number{1, p};
1267 return (n * factor).truncate() / factor;
1268 };
1269 while (state.paymentRemaining > 0)
1270 {
1271 validateBorrowerBalance();
1272 // Compute the expected principal amount
1273 auto const paymentComponents = xrpl::detail::computePaymentComponents(
1274 env.current()->rules(),
1275 broker.asset.raw(),
1276 state.loanScale,
1277 state.totalValue,
1278 state.principalOutstanding,
1279 state.managementFeeOutstanding,
1280 state.periodicPayment,
1281 periodicRate,
1282 state.paymentRemaining,
1283 broker.params.managementFeeRate);
1284
1285 BEAST_EXPECT(
1286 paymentComponents.trackedValueDelta <= roundedPeriodicPayment ||
1287 (paymentComponents.specialCase == xrpl::detail::PaymentSpecialCase::Final &&
1288 paymentComponents.trackedValueDelta >= roundedPeriodicPayment));
1289 BEAST_EXPECT(
1290 paymentComponents.trackedValueDelta ==
1291 paymentComponents.trackedPrincipalDelta + paymentComponents.trackedInterestPart() +
1292 paymentComponents.trackedManagementFeeDelta);
1293
1294 xrpl::LoanState const nextTrueState = computeTheoreticalLoanState(
1295 env.current()->rules(),
1296 state.periodicPayment,
1297 periodicRate,
1298 state.paymentRemaining - 1,
1299 broker.params.managementFeeRate);
1300 xrpl::detail::LoanStateDeltas const deltas = currentTrueState - nextTrueState;
1301 BEAST_EXPECT(
1302 deltas.total() == deltas.principal + deltas.interest + deltas.managementFee);
1303 BEAST_EXPECT(
1304 paymentComponents.specialCase == xrpl::detail::PaymentSpecialCase::Final ||
1305 deltas.total() == state.periodicPayment ||
1306 (state.loanScale - (deltas.total() - state.periodicPayment).exponent()) > 14);
1307
1308 if (!showStepBalances)
1309 {
1310 log << currencyLabel << " Payment components: " << state.paymentRemaining << ", "
1311
1312 << deltas.interest << ", " << deltas.principal << ", " << deltas.managementFee
1313 << ", " << paymentComponents.trackedValueDelta << ", "
1314 << paymentComponents.trackedPrincipalDelta << ", "
1315 << paymentComponents.trackedInterestPart() << ", "
1316 << paymentComponents.trackedManagementFeeDelta << ", " << [&] -> char const* {
1317 if (paymentComponents.specialCase == ::xrpl::detail::PaymentSpecialCase::Final)
1318 return "final";
1319 if (paymentComponents.specialCase == ::xrpl::detail::PaymentSpecialCase::Extra)
1320 return "extra";
1321 return "none";
1322 }() << std::endl;
1323 }
1324
1325 auto const totalDueAmount =
1326 STAmount{broker.asset, paymentComponents.trackedValueDelta + serviceFee};
1327
1328 if (paymentParams.validateBalances)
1329 {
1330 // Due to the rounding algorithms to keep the interest and
1331 // principal in sync with "true" values, the computed amount
1332 // may be a little less than the rounded fixed payment
1333 // amount. For integral types, the difference should be < 3
1334 // (1 unit for each of the interest and management fee). For
1335 // IOUs, the difference should be dust.
1336 Number const diff = totalDue - totalDueAmount;
1337 BEAST_EXPECT(
1338 paymentComponents.specialCase == xrpl::detail::PaymentSpecialCase::Final ||
1339 diff == beast::kZero ||
1340 (diff > beast::kZero &&
1341 ((broker.asset.integral() && (static_cast<Number>(diff) < 3)) ||
1342 (state.loanScale - diff.exponent() > 13))));
1343
1344 BEAST_EXPECT(
1345 paymentComponents.trackedPrincipalDelta >= beast::kZero &&
1346 paymentComponents.trackedPrincipalDelta <= state.principalOutstanding);
1347 BEAST_EXPECT(
1348 paymentComponents.specialCase != xrpl::detail::PaymentSpecialCase::Final ||
1349 paymentComponents.trackedPrincipalDelta == state.principalOutstanding);
1350 }
1351
1352 auto const borrowerBalanceBeforePayment = env.balance(borrower, broker.asset);
1353
1354 // Make the payment
1355 env(pay(borrower, loanKeylet.key, transactionAmount, paymentParams.flags));
1356
1357 env.close(D{state.paymentInterval / 2});
1358
1359 if (paymentParams.validateBalances)
1360 {
1361 // Need to account for fees if the loan is in XRP
1362 PrettyAmount adjustment = broker.asset(0);
1363 if (broker.asset.native())
1364 {
1365 adjustment = env.current()->fees().base;
1366 }
1367
1368 // Check the result
1369 verifyLoanStatus.checkPayment(
1370 state.loanScale,
1371 borrower,
1372 borrowerBalanceBeforePayment,
1373 totalDueAmount,
1374 adjustment);
1375 }
1376
1377 if (showStepBalances)
1378 {
1379 auto const loanSle = env.le(loanKeylet);
1380 if (!BEAST_EXPECT(loanSle))
1381 {
1382 // No reason for this not to exist
1383 return;
1384 }
1385 auto const current = constructLoanState(loanSle);
1386 auto const errors = nextTrueState - current;
1387 log << currencyLabel << " Loan balances: "
1388 << "\n\tAmount taken: " << paymentComponents.trackedValueDelta
1389 << "\n\tTotal value: " << current.valueOutstanding
1390 << " (true: " << truncate(nextTrueState.valueOutstanding)
1391 << ", error: " << truncate(errors.total())
1392 << ")\n\tPrincipal: " << current.principalOutstanding
1393 << " (true: " << truncate(nextTrueState.principalOutstanding)
1394 << ", error: " << truncate(errors.principal)
1395 << ")\n\tInterest: " << current.interestDue
1396 << " (true: " << truncate(nextTrueState.interestDue)
1397 << ", error: " << truncate(errors.interest)
1398 << ")\n\tMgmt fee: " << current.managementFeeDue
1399 << " (true: " << truncate(nextTrueState.managementFeeDue)
1400 << ", error: " << truncate(errors.managementFee) << ")\n\tPayments remaining "
1401 << loanSle->at(sfPaymentRemaining) << std::endl;
1402
1403 currentRoundedState = current;
1404 }
1405
1406 --state.paymentRemaining;
1407 state.previousPaymentDate = state.nextPaymentDate;
1408 if (paymentComponents.specialCase == xrpl::detail::PaymentSpecialCase::Final)
1409 {
1410 state.paymentRemaining = 0;
1411 state.nextPaymentDate = 0;
1412 }
1413 else
1414 {
1415 state.nextPaymentDate += state.paymentInterval;
1416 }
1417 state.principalOutstanding -= paymentComponents.trackedPrincipalDelta;
1418 state.managementFeeOutstanding -= paymentComponents.trackedManagementFeeDelta;
1419 state.totalValue -= paymentComponents.trackedValueDelta;
1420
1421 if (paymentParams.validateBalances)
1422 verifyLoanStatus(state);
1423
1424 totalPaid.trackedValueDelta += paymentComponents.trackedValueDelta;
1425 totalPaid.trackedPrincipalDelta += paymentComponents.trackedPrincipalDelta;
1426 totalPaid.trackedManagementFeeDelta += paymentComponents.trackedManagementFeeDelta;
1427 totalInterestPaid += paymentComponents.trackedInterestPart();
1428 totalFeesPaid += serviceFee;
1429 ++totalPaymentsMade;
1430
1431 currentTrueState = nextTrueState;
1432 }
1433 validateBorrowerBalance();
1434
1435 // Loan is paid off
1436 BEAST_EXPECT(state.paymentRemaining == 0);
1437 BEAST_EXPECT(state.principalOutstanding == 0);
1438
1439 auto const initialInterestDue = initialState.totalValue -
1440 (initialState.principalOutstanding + initialState.managementFeeOutstanding);
1441 if (paymentParams.validateBalances)
1442 {
1443 // Make sure all the payments add up
1444 BEAST_EXPECT(totalPaid.trackedValueDelta == initialState.totalValue);
1445 BEAST_EXPECT(totalPaid.trackedPrincipalDelta == initialState.principalOutstanding);
1446 BEAST_EXPECT(
1447 totalPaid.trackedManagementFeeDelta == initialState.managementFeeOutstanding);
1448 // This is almost a tautology given the previous checks, but
1449 // check it anyway for completeness.
1450 BEAST_EXPECT(totalInterestPaid == initialInterestDue);
1451 BEAST_EXPECT(totalPaymentsMade == initialState.paymentRemaining);
1452 }
1453
1454 if (showStepBalances)
1455 {
1456 auto const loanSle = env.le(loanKeylet);
1457 if (!BEAST_EXPECT(loanSle))
1458 {
1459 // No reason for this not to exist
1460 return;
1461 }
1462 log << currencyLabel << " Total amounts paid: "
1463 << "\n\tTotal value: " << totalPaid.trackedValueDelta
1464 << " (initial: " << truncate(initialState.totalValue)
1465 << ", error: " << truncate(initialState.totalValue - totalPaid.trackedValueDelta)
1466 << ")\n\tPrincipal: " << totalPaid.trackedPrincipalDelta
1467 << " (initial: " << truncate(initialState.principalOutstanding) << ", error: "
1468 << truncate(initialState.principalOutstanding - totalPaid.trackedPrincipalDelta)
1469 << ")\n\tInterest: " << totalInterestPaid
1470 << " (initial: " << truncate(initialInterestDue)
1471 << ", error: " << truncate(initialInterestDue - totalInterestPaid)
1472 << ")\n\tMgmt fee: " << totalPaid.trackedManagementFeeDelta
1473 << " (initial: " << truncate(initialState.managementFeeOutstanding) << ", error: "
1474 << truncate(
1475 initialState.managementFeeOutstanding - totalPaid.trackedManagementFeeDelta)
1476 << ")\n\tTotal payments made: " << totalPaymentsMade << std::endl;
1477 }
1478 }
1479
1480 void
1482 AssetType assetType,
1483 BrokerParameters const& brokerParams,
1484 LoanParameters const& loanParams,
1485 FeatureBitset features)
1486 {
1487 using namespace jtx;
1488
1489 Account const issuer("issuer");
1490 Account const lender("lender");
1491 Account const borrower("borrower");
1492
1493 Env env(*this, features);
1494
1495 auto loanResult =
1496 createLoan(env, assetType, brokerParams, loanParams, issuer, lender, borrower);
1497 if (BEAST_EXPECT(loanResult); !loanResult.has_value())
1498 return;
1499
1500 auto const broker = std::get<BrokerInfo>(*loanResult);
1501 auto const loanKeylet = std::get<Keylet>(*loanResult);
1502 auto const pseudoAcct = std::get<Account>(*loanResult);
1503
1504 VerifyLoanStatus const verifyLoanStatus(env, broker, pseudoAcct, loanKeylet);
1505
1507 env,
1508 broker,
1509 loanParams,
1510 loanKeylet,
1511 verifyLoanStatus,
1512 issuer,
1513 lender,
1514 borrower,
1515 PaymentParameters{.showStepBalances = true});
1516 }
1517
1529 void
1531 std::string const& caseLabel,
1532 char const* label,
1533 jtx::Env& env,
1534 Number const& loanAmount,
1535 int interestExponent,
1536 jtx::Account const& lender,
1537 jtx::Account const& borrower,
1538 jtx::Account const& evan,
1539 BrokerInfo const& broker,
1540 jtx::Account const& pseudoAcct,
1541 std::uint32_t flags,
1542 // The end of life callback is expected to take the loan to 0 payments
1543 // remaining, one way or another
1544 std::function<void(Keylet const& loanKeylet, VerifyLoanStatus const& verifyLoanStatus)>
1545 toEndOfLife)
1546 {
1547 auto const [keylet, loanSequence] = [&] {
1548 auto const brokerSle = env.le(keylet::loanBroker(broker.brokerID));
1549 if (!BEAST_EXPECT(brokerSle))
1550 {
1551 // will be invalid
1553 }
1554
1555 // Broker has no loans
1556 BEAST_EXPECT(brokerSle->at(sfOwnerCount) == 0);
1557
1558 // The loan keylet is based on the LoanSequence of the _LOAN_BROKER_
1559 // object.
1560 auto const loanSequence = brokerSle->at(sfLoanSequence);
1561 return std::make_pair(
1562 keylet::loan(broker.brokerID, SeqProxy::rawSequence(loanSequence)), loanSequence);
1563 }();
1564
1565 VerifyLoanStatus const verifyLoanStatus(env, broker, pseudoAcct, keylet);
1566
1567 // No loans yet
1568 verifyLoanStatus.checkBroker(0, 0, TenthBips32{0}, 1, 0, 0);
1569
1570 if (!BEAST_EXPECT(loanSequence != 0))
1571 return;
1572
1573 testcase << caseLabel << " " << label;
1574
1575 using namespace jtx;
1576 using namespace loan;
1577 using namespace std::chrono_literals;
1578
1579 auto applyExponent = [interestExponent, this](TenthBips32 value) mutable {
1580 BEAST_EXPECT(value > TenthBips32(0));
1581 while (interestExponent > 0)
1582 {
1583 auto const oldValue = value;
1584 value *= 10;
1585 --interestExponent;
1586 BEAST_EXPECT(value / 10 == oldValue);
1587 }
1588 while (interestExponent < 0)
1589 {
1590 auto const oldValue = value;
1591 value /= 10;
1592 ++interestExponent;
1593 BEAST_EXPECT(value * 10 == oldValue);
1594 }
1595 return value;
1596 };
1597
1598 auto const borrowerOwnerCount = env.ownerCount(borrower);
1599
1600 auto const loanSetFee = env.current()->fees().base * 2;
1601 LoanParameters const loanParams{
1602 .account = borrower,
1603 .counter = lender,
1604 .counterpartyExplicit = false,
1605 .principalRequest = loanAmount,
1606 .setFee = loanSetFee,
1607 .originationFee = 1,
1608 .serviceFee = 2,
1609 .lateFee = 3,
1610 .closeFee = 4,
1611 .overFee = applyExponent(percentageToTenthBips(5) / 10),
1612 .interest = applyExponent(percentageToTenthBips(12)),
1613 // 2.4%
1614 .lateInterest = applyExponent(percentageToTenthBips(24) / 10),
1615 .closeInterest = applyExponent(percentageToTenthBips(36) / 10),
1616 .overpaymentInterest = applyExponent(percentageToTenthBips(48) / 10),
1617 .payTotal = 12,
1618 .payInterval = 600,
1619 .gracePd = 60,
1620 .flags = flags,
1621 };
1622 Number const principalRequestAmount = broker.asset(loanParams.principalRequest).value();
1623 auto const originationFeeAmount = broker.asset(*loanParams.originationFee).value();
1624 auto const serviceFeeAmount = broker.asset(*loanParams.serviceFee).value();
1625 auto const lateFeeAmount = broker.asset(*loanParams.lateFee).value();
1626 auto const closeFeeAmount = broker.asset(*loanParams.closeFee).value();
1627
1628 auto const borrowerStartbalance = env.balance(borrower, broker.asset);
1629
1630 auto const createJtx = loanParams(env, broker);
1631 // Successfully create a Loan
1632 env(createJtx);
1633
1634 env.close();
1635
1636 auto const startDate = env.current()->header().parentCloseTime.time_since_epoch().count();
1637
1638 if (auto const brokerSle = env.le(keylet::loanBroker(broker.brokerID));
1639 BEAST_EXPECT(brokerSle))
1640 {
1641 BEAST_EXPECT(brokerSle->at(sfOwnerCount) == 1);
1642 }
1643
1644 {
1645 // Need to account for fees if the loan is in XRP
1646 PrettyAmount adjustment = broker.asset(0);
1647 if (broker.asset.native())
1648 {
1649 adjustment = 2 * env.current()->fees().base;
1650 }
1651
1652 BEAST_EXPECT(
1653 env.balance(borrower, broker.asset).value() ==
1654 borrowerStartbalance.value() + principalRequestAmount - originationFeeAmount -
1655 adjustment.value());
1656 }
1657
1658 auto const loanFlags =
1659 createJtx.stx->isFlag(tfLoanOverpayment) ? lsfLoanOverpayment : LedgerSpecificFlags(0);
1660
1661 if (auto const loan = env.le(keylet); BEAST_EXPECT(loan))
1662 {
1663 // log << "loan after create: " << to_string(loan->getJson())
1664 // << std::endl;
1665 BEAST_EXPECT(
1666 loan->isFlag(lsfLoanOverpayment) == createJtx.stx->isFlag(tfLoanOverpayment));
1667 BEAST_EXPECT(loan->at(sfLoanSequence) == loanSequence);
1668 BEAST_EXPECT(loan->at(sfBorrower) == borrower.id());
1669 BEAST_EXPECT(loan->at(sfLoanBrokerID) == broker.brokerID);
1670 BEAST_EXPECT(loan->at(sfLoanOriginationFee) == originationFeeAmount);
1671 BEAST_EXPECT(loan->at(sfLoanServiceFee) == serviceFeeAmount);
1672 BEAST_EXPECT(loan->at(sfLatePaymentFee) == lateFeeAmount);
1673 BEAST_EXPECT(loan->at(sfClosePaymentFee) == closeFeeAmount);
1674 BEAST_EXPECT(loan->at(sfOverpaymentFee) == *loanParams.overFee);
1675 BEAST_EXPECT(loan->at(sfInterestRate) == *loanParams.interest);
1676 BEAST_EXPECT(loan->at(sfLateInterestRate) == *loanParams.lateInterest);
1677 BEAST_EXPECT(loan->at(sfCloseInterestRate) == *loanParams.closeInterest);
1678 BEAST_EXPECT(loan->at(sfOverpaymentInterestRate) == *loanParams.overpaymentInterest);
1679 BEAST_EXPECT(loan->at(sfStartDate) == startDate);
1680 BEAST_EXPECT(loan->at(sfPaymentInterval) == *loanParams.payInterval);
1681 BEAST_EXPECT(loan->at(sfGracePeriod) == *loanParams.gracePd);
1682 BEAST_EXPECT(loan->at(sfPreviousPaymentDueDate) == 0);
1683 BEAST_EXPECT(loan->at(sfNextPaymentDueDate) == startDate + *loanParams.payInterval);
1684 BEAST_EXPECT(loan->at(sfPaymentRemaining) == *loanParams.payTotal);
1685 BEAST_EXPECT(
1686 loan->at(sfLoanScale) >=
1687 (broker.asset.integral()
1688 ? 0
1689 : std::max(broker.vaultScale(env), principalRequestAmount.exponent())));
1690 BEAST_EXPECT(loan->at(sfPrincipalOutstanding) == principalRequestAmount);
1691 }
1692
1693 auto const state = getCurrentState(env, broker, keylet, verifyLoanStatus);
1694
1695 auto const loanProperties = computeLoanProperties(
1696 env.current()->rules(),
1697 broker.asset.raw(),
1698 state.principalOutstanding,
1699 state.interestRate,
1700 state.paymentInterval,
1701 state.paymentRemaining,
1703 state.loanScale);
1704
1705 verifyLoanStatus(
1706 0,
1707 startDate + *loanParams.payInterval,
1708 *loanParams.payTotal,
1709 state.loanScale,
1710 loanProperties.loanState.valueOutstanding,
1711 principalRequestAmount,
1712 loanProperties.loanState.managementFeeDue,
1713 loanProperties.periodicPayment,
1714 loanFlags | 0);
1715
1716 // Manage the loan
1717 // no-op
1718 env(manage(lender, keylet.key, 0));
1719 {
1720 // no flags
1721 auto jt = manage(lender, keylet.key, 0);
1722 jt.removeMember(sfFlags.getName());
1723 env(jt);
1724 }
1725 // Only the lender can manage
1726 env(manage(evan, keylet.key, 0), Ter(tecNO_PERMISSION));
1727 // unknown flags
1728 env(manage(lender, keylet.key, tfLoanManageMask), Ter(temINVALID_FLAG));
1729 // combinations of flags are not allowed
1730 env(manage(lender, keylet.key, tfLoanUnimpair | tfLoanImpair), Ter(temINVALID_FLAG));
1731 env(manage(lender, keylet.key, tfLoanImpair | tfLoanDefault), Ter(temINVALID_FLAG));
1732 env(manage(lender, keylet.key, tfLoanUnimpair | tfLoanDefault), Ter(temINVALID_FLAG));
1733 env(manage(lender, keylet.key, tfLoanUnimpair | tfLoanImpair | tfLoanDefault),
1735 // invalid loan ID
1736 env(manage(lender, broker.brokerID, tfLoanImpair), Ter(tecNO_ENTRY));
1737 // Loan is unimpaired, can't unimpair it again
1738 env(manage(lender, keylet.key, tfLoanUnimpair), Ter(tecNO_PERMISSION));
1739 // Loan is unimpaired, it can go into default, but only after it's past
1740 // due
1741 env(manage(lender, keylet.key, tfLoanDefault), Ter(tecTOO_SOON));
1742
1743 // Check the vault
1744 bool const canImpair = canImpairLoan(env, broker, state);
1745 // Under fixCleanup3_4_0, impair rejects a not-yet-late loan with
1746 // tecTOO_SOON. Advancing time to satisfy the gate here would push
1747 // the loan into a "late" state and break the toEndOfLife flows
1748 // (singlePayment/fullPayment) that expect a fresh loan without the
1749 // tfLoanLatePayment flag. The tesSUCCESS/tecLIMIT_EXCEEDED impair
1750 // path is already covered under fixCleanup3_4_0 by dedicated tests
1751 // in LoanSecurity_test.cpp and LoanCashBasis_test.cpp.
1752 if (!env.current()->rules().enabled(fixCleanup3_4_0))
1753 {
1754 // Impair the loan, if possible
1755 env(manage(lender, keylet.key, tfLoanImpair),
1756 canImpair ? Ter(tesSUCCESS) : Ter(tecLIMIT_EXCEEDED));
1757 // Unimpair the loan
1758 env(manage(lender, keylet.key, tfLoanUnimpair),
1759 canImpair ? Ter(tesSUCCESS) : Ter(tecNO_PERMISSION));
1760 }
1761 else
1762 {
1763 // With the fix on, a not-yet-late loan can never be impaired
1764 // (tecTOO_SOON) and the follow-up unimpair on an unimpaired
1765 // loan is still tecNO_PERMISSION.
1766 env(manage(lender, keylet.key, tfLoanImpair), Ter(tecTOO_SOON));
1767 env(manage(lender, keylet.key, tfLoanUnimpair), Ter(tecNO_PERMISSION));
1768 }
1769
1770 auto const nextDueDate = startDate + *loanParams.payInterval;
1771
1772 env.close();
1773
1774 verifyLoanStatus(
1775 0,
1776 nextDueDate,
1777 *loanParams.payTotal,
1778 loanProperties.loanScale,
1779 loanProperties.loanState.valueOutstanding,
1780 principalRequestAmount,
1781 loanProperties.loanState.managementFeeDue,
1782 loanProperties.periodicPayment,
1783 loanFlags | 0);
1784
1785 // Can't delete the loan yet. It has payments remaining.
1786 env(del(lender, keylet.key), Ter(tecHAS_OBLIGATIONS));
1787
1788 if (BEAST_EXPECT(toEndOfLife))
1789 toEndOfLife(keylet, verifyLoanStatus);
1790 env.close();
1791
1792 // Verify the loan is at EOL
1793 if (auto const loan = env.le(keylet); BEAST_EXPECT(loan))
1794 {
1795 BEAST_EXPECT(loan->at(sfPaymentRemaining) == 0);
1796 BEAST_EXPECT(loan->at(sfPrincipalOutstanding) == 0);
1797 }
1798 auto const borrowerStartingBalance = env.balance(borrower, broker.asset);
1799
1800 // Try to delete the loan broker with an active loan
1801 env(loan_broker::del(lender, broker.brokerID), Ter(tecHAS_OBLIGATIONS));
1802 // Ensure the above tx doesn't get ordered after the LoanDelete and
1803 // delete our broker!
1804 env.close();
1805
1806 // Test failure cases
1807 env(del(lender, keylet.key, tfLoanOverpayment), Ter(temINVALID_FLAG));
1808 env(del(evan, keylet.key), Ter(tecNO_PERMISSION));
1809 env(del(lender, broker.brokerID), Ter(tecNO_ENTRY));
1810
1811 // Delete the loan
1812 // Either the borrower or the lender can delete the loan. Alternate
1813 // between who does it across tests.
1814 static unsigned kDeleteCounter = 0;
1815 auto const deleter = ((++kDeleteCounter % 2) != 0u) ? lender : borrower;
1816 env(del(deleter, keylet.key));
1817 env.close();
1818
1819 PrettyAmount adjustment = broker.asset(0);
1820 if (deleter == borrower)
1821 {
1822 // Need to account for fees if the loan is in XRP
1823 if (broker.asset.native())
1824 {
1825 adjustment = env.current()->fees().base;
1826 }
1827 }
1828
1829 // No loans left
1830 verifyLoanStatus.checkBroker(0, 0, *loanParams.interest, 1, 0, 0);
1831
1832 BEAST_EXPECT(
1833 env.balance(borrower, broker.asset).value() ==
1834 borrowerStartingBalance.value() - adjustment);
1835 BEAST_EXPECT(env.ownerCount(borrower) == borrowerOwnerCount);
1836
1837 if (auto const brokerSle = env.le(keylet::loanBroker(broker.brokerID));
1838 BEAST_EXPECT(brokerSle))
1839 {
1840 BEAST_EXPECT(brokerSle->at(sfOwnerCount) == 0);
1841 }
1842 }
1843
1844 static std::string
1846 {
1847 if (asset.native())
1848 return "XRP";
1849 if (asset.holds<Issue>())
1850 return "IOU";
1851 if (asset.holds<MPTIssue>())
1852 return "MPT";
1853 return "Unknown";
1854 }
1855
1865 template <class TAsset, std::size_t NAsset>
1866 void
1868 jtx::Env& env,
1869 jtx::MPTTester& mptt,
1870 std::array<TAsset, NAsset> const& assets,
1871 BrokerInfo const& broker,
1872 Number const& loanAmount,
1873 int interestExponent)
1874 {
1875 using namespace jtx;
1876 using namespace lending;
1877
1878 auto const& asset = broker.asset.raw();
1879 auto const currencyLabel = getCurrencyLabel(asset);
1880 auto const caseLabel = [&] {
1882 ss << "Lifecycle: " << loanAmount << " " << currencyLabel
1883 << " Scale interest to: " << interestExponent << " ";
1884 return ss.str();
1885 }();
1886 testcase << caseLabel;
1887
1888 using namespace loan;
1889 using namespace std::chrono_literals;
1890 using D = NetClock::duration;
1891 using Tp = NetClock::time_point;
1892
1893 Account const issuer{"issuer"};
1894 // For simplicity, lender will be the sole actor for the vault &
1895 // brokers.
1896 Account const lender{"lender"};
1897 // Borrower only wants to borrow
1898 Account const borrower{"borrower"};
1899 // Evan will attempt to be naughty
1900 Account const evan{"evan"};
1901 // Do not fund alice
1902 Account const alice{"alice"};
1903
1904 Number const principalRequest = broker.asset(loanAmount).value();
1905 Number const maxCoveredLoanValue = broker.params.maxCoveredLoanValue(0);
1906 BEAST_EXPECT(maxCoveredLoanValue == 1000 * 100 / 10);
1907 Number const maxCoveredLoanRequest = broker.asset(maxCoveredLoanValue).value();
1908 Number const totalVaultRequest = broker.asset(broker.params.vaultDeposit).value();
1909 Number const debtMaximumRequest = broker.asset(broker.params.debtMax).value();
1910
1911 auto const loanSetFee = Fee(env.current()->fees().base * 2);
1912
1913 auto const pseudoAcct = brokerPseudoAccount(env, broker, lender);
1914
1915 auto const baseFee = env.current()->fees().base;
1916
1917 auto const badKeylet = keylet::vault(lender.id(), SeqProxy::rawSequence(env.seq(lender)));
1918 // Try some failure cases
1919 // flags are checked first
1920 env(set(evan, broker.brokerID, principalRequest, tfLoanSetMask),
1921 Sig(sfCounterpartySignature, lender),
1922 loanSetFee,
1924
1925 // field length validation
1926 // sfData: good length, bad account
1927 env(set(evan, broker.brokerID, principalRequest),
1928 Sig(sfCounterpartySignature, borrower),
1930 loanSetFee,
1931 Ter(tefBAD_AUTH));
1932 // sfData: too long
1933 env(set(evan, broker.brokerID, principalRequest),
1934 Sig(sfCounterpartySignature, lender),
1936 loanSetFee,
1937 Ter(temINVALID));
1938
1939 // field range validation
1940 // sfOverpaymentFee: good value, bad account
1941 env(set(evan, broker.brokerID, principalRequest),
1942 Sig(sfCounterpartySignature, borrower),
1943 kOverpaymentFee(kMaxOverpaymentFee),
1944 loanSetFee,
1945 Ter(tefBAD_AUTH));
1946 // sfOverpaymentFee: too big
1947 env(set(evan, broker.brokerID, principalRequest),
1948 Sig(sfCounterpartySignature, lender),
1949 kOverpaymentFee(kMaxOverpaymentFee + 1),
1950 loanSetFee,
1951 Ter(temINVALID));
1952
1953 // sfInterestRate: good value, bad account
1954 env(set(evan, broker.brokerID, principalRequest),
1955 Sig(sfCounterpartySignature, borrower),
1956 kInterestRate(kMaxInterestRate),
1957 loanSetFee,
1958 Ter(tefBAD_AUTH));
1959 env(set(evan, broker.brokerID, principalRequest),
1960 Sig(sfCounterpartySignature, borrower),
1961 kInterestRate(TenthBips32(0)),
1962 loanSetFee,
1963 Ter(tefBAD_AUTH));
1964 // sfInterestRate: too big
1965 env(set(evan, broker.brokerID, principalRequest),
1966 Sig(sfCounterpartySignature, lender),
1967 kInterestRate(kMaxInterestRate + 1),
1968 loanSetFee,
1969 Ter(temINVALID));
1970 // sfInterestRate: too small
1971 env(set(evan, broker.brokerID, principalRequest),
1972 Sig(sfCounterpartySignature, lender),
1973 kInterestRate(TenthBips32(-1)),
1974 loanSetFee,
1975 Ter(temINVALID));
1976
1977 // sfLateInterestRate: good value, bad account
1978 env(set(evan, broker.brokerID, principalRequest),
1979 Sig(sfCounterpartySignature, borrower),
1980 kLateInterestRate(kMaxLateInterestRate),
1981 loanSetFee,
1982 Ter(tefBAD_AUTH));
1983 env(set(evan, broker.brokerID, principalRequest),
1984 Sig(sfCounterpartySignature, borrower),
1985 kLateInterestRate(TenthBips32(0)),
1986 loanSetFee,
1987 Ter(tefBAD_AUTH));
1988 // sfLateInterestRate: too big
1989 env(set(evan, broker.brokerID, principalRequest),
1990 Sig(sfCounterpartySignature, lender),
1991 kLateInterestRate(kMaxLateInterestRate + 1),
1992 loanSetFee,
1993 Ter(temINVALID));
1994 // sfLateInterestRate: too small
1995 env(set(evan, broker.brokerID, principalRequest),
1996 Sig(sfCounterpartySignature, lender),
1997 kLateInterestRate(TenthBips32(-1)),
1998 loanSetFee,
1999 Ter(temINVALID));
2000
2001 // sfCloseInterestRate: good value, bad account
2002 env(set(evan, broker.brokerID, principalRequest),
2003 Sig(sfCounterpartySignature, borrower),
2004 kCloseInterestRate(kMaxCloseInterestRate),
2005 loanSetFee,
2006 Ter(tefBAD_AUTH));
2007 env(set(evan, broker.brokerID, principalRequest),
2008 Sig(sfCounterpartySignature, borrower),
2009 kCloseInterestRate(TenthBips32(0)),
2010 loanSetFee,
2011 Ter(tefBAD_AUTH));
2012 // sfCloseInterestRate: too big
2013 env(set(evan, broker.brokerID, principalRequest),
2014 Sig(sfCounterpartySignature, lender),
2015 kCloseInterestRate(kMaxCloseInterestRate + 1),
2016 loanSetFee,
2017 Ter(temINVALID));
2018 env(set(evan, broker.brokerID, principalRequest),
2019 Sig(sfCounterpartySignature, lender),
2020 kCloseInterestRate(TenthBips32(-1)),
2021 loanSetFee,
2022 Ter(temINVALID));
2023
2024 // sfOverpaymentInterestRate: good value, bad account
2025 env(set(evan, broker.brokerID, principalRequest),
2026 Sig(sfCounterpartySignature, borrower),
2027 kOverpaymentInterestRate(kMaxOverpaymentInterestRate),
2028 loanSetFee,
2029 Ter(tefBAD_AUTH));
2030 env(set(evan, broker.brokerID, principalRequest),
2031 Sig(sfCounterpartySignature, borrower),
2032 kOverpaymentInterestRate(TenthBips32(0)),
2033 loanSetFee,
2034 Ter(tefBAD_AUTH));
2035 // sfOverpaymentInterestRate: too big
2036 env(set(evan, broker.brokerID, principalRequest),
2037 Sig(sfCounterpartySignature, lender),
2038 kOverpaymentInterestRate(kMaxOverpaymentInterestRate + 1),
2039 loanSetFee,
2040 Ter(temINVALID));
2041 env(set(evan, broker.brokerID, principalRequest),
2042 Sig(sfCounterpartySignature, lender),
2043 kOverpaymentInterestRate(TenthBips32(-1)),
2044 loanSetFee,
2045 Ter(temINVALID));
2046
2047 // sfPaymentTotal: good value, bad account
2048 env(set(evan, broker.brokerID, principalRequest),
2049 Sig(sfCounterpartySignature, borrower),
2050 kPaymentTotal(LoanSet::kMinPaymentTotal),
2051 loanSetFee,
2052 Ter(tefBAD_AUTH));
2053 // sfPaymentTotal: too small (there is no max)
2054 env(set(evan, broker.brokerID, principalRequest),
2055 Sig(sfCounterpartySignature, lender),
2056 kPaymentTotal(LoanSet::kMinPaymentTotal - 1),
2057 loanSetFee,
2058 Ter(temINVALID));
2059
2060 // sfPaymentInterval: good value, bad account
2061 env(set(evan, broker.brokerID, principalRequest),
2062 Sig(sfCounterpartySignature, borrower),
2063 kPaymentInterval(LoanSet::kMinPaymentInterval),
2064 loanSetFee,
2065 Ter(tefBAD_AUTH));
2066 // sfPaymentInterval: too small (there is no max)
2067 env(set(evan, broker.brokerID, principalRequest),
2068 Sig(sfCounterpartySignature, lender),
2069 kPaymentInterval(LoanSet::kMinPaymentInterval - 1),
2070 loanSetFee,
2071 Ter(temINVALID));
2072
2073 // sfGracePeriod: good value, bad account
2074 env(set(evan, broker.brokerID, principalRequest),
2075 Sig(sfCounterpartySignature, borrower),
2076 kPaymentInterval(LoanSet::kMinPaymentInterval * 2),
2077 kGracePeriod(LoanSet::kMinPaymentInterval * 2),
2078 loanSetFee,
2079 Ter(tefBAD_AUTH));
2080 // sfGracePeriod: larger than paymentInterval
2081 env(set(evan, broker.brokerID, principalRequest),
2082 Sig(sfCounterpartySignature, lender),
2083 kPaymentInterval(LoanSet::kMinPaymentInterval * 2),
2084 kGracePeriod(LoanSet::kMinPaymentInterval * 3),
2085 loanSetFee,
2086 Ter(temINVALID));
2087
2088 // insufficient fee - single sign
2089 env(set(borrower, broker.brokerID, principalRequest),
2090 Sig(sfCounterpartySignature, lender),
2092 // insufficient fee - multisign
2093 env(signers(lender, 2, {{evan, 1}, {borrower, 1}}));
2094 env(signers(borrower, 2, {{evan, 1}, {lender, 1}}));
2095 env(set(borrower, broker.brokerID, principalRequest),
2096 kCounterparty(lender),
2097 Msig(evan, lender),
2098 Msig(sfCounterpartySignature, evan, borrower),
2099 Fee(env.current()->fees().base * 5 - 1),
2101 // Bad multisign signatures for borrower (Account)
2102 env(set(borrower, broker.brokerID, principalRequest),
2103 kCounterparty(lender),
2104 Msig(alice, issuer),
2105 Msig(sfCounterpartySignature, evan, borrower),
2106 Fee(env.current()->fees().base * 5),
2108 // Bad multisign signatures for issuer (Counterparty)
2109 env(set(borrower, broker.brokerID, principalRequest),
2110 kCounterparty(lender),
2111 Msig(evan, lender),
2112 Msig(sfCounterpartySignature, alice, issuer),
2113 Fee(env.current()->fees().base * 5 - 1),
2115 env(signers(lender, kNone));
2116 env(signers(borrower, kNone));
2117 // multisign sufficient fee, but no signers set up
2118 env(set(borrower, broker.brokerID, principalRequest),
2119 kCounterparty(lender),
2120 Msig(evan, lender),
2121 Msig(sfCounterpartySignature, evan, borrower),
2122 Fee(env.current()->fees().base * 5),
2124 // not the broker owner, no counterparty, not signed by broker
2125 // owner
2126 env(set(borrower, broker.brokerID, principalRequest),
2127 Sig(sfCounterpartySignature, evan),
2128 loanSetFee,
2129 Ter(tefBAD_AUTH));
2130 // not the broker owner, counterparty is borrower
2131 env(set(evan, broker.brokerID, principalRequest),
2132 kCounterparty(borrower),
2133 Sig(sfCounterpartySignature, borrower),
2134 loanSetFee,
2136 // not a LoanBroker object, no counterparty
2137 env(set(lender, badKeylet.key, principalRequest),
2138 Sig(sfCounterpartySignature, evan),
2139 loanSetFee,
2141 // not a LoanBroker object, counterparty is valid
2142 env(set(lender, badKeylet.key, principalRequest),
2143 kCounterparty(borrower),
2144 Sig(sfCounterpartySignature, borrower),
2145 loanSetFee,
2146 Ter(tecNO_ENTRY));
2147 // borrower doesn't exist
2148 env(set(lender, broker.brokerID, principalRequest),
2149 kCounterparty(alice),
2150 Sig(sfCounterpartySignature, alice),
2151 loanSetFee,
2153
2154 // Request more funds than the vault has available
2155 env(set(evan, broker.brokerID, totalVaultRequest + 1),
2156 Sig(sfCounterpartySignature, lender),
2157 loanSetFee,
2159
2160 // Request more funds than the broker's first-loss capital can
2161 // cover.
2162 env(set(evan, broker.brokerID, maxCoveredLoanRequest + 1),
2163 Sig(sfCounterpartySignature, lender),
2164 loanSetFee,
2166
2167 // Frozen trust line / locked MPT issuance
2168 // XRP can not be frozen, but run through the loop anyway to test
2169 // the tecLIMIT_EXCEEDED case
2170 {
2171 auto const brokerSle = env.le(keylet::loanBroker(broker.brokerID));
2172 if (!BEAST_EXPECT(brokerSle))
2173 return;
2174
2175 auto const vaultPseudo = [&] {
2176 auto const vaultSle = env.le(keylet::vault(brokerSle->at(sfVaultID)));
2177 if (!BEAST_EXPECT(vaultSle))
2178 {
2179 // This will be wrong, but the test has failed anyway.
2180 return Account{lender};
2181 }
2182 return Account("Vault pseudo-account", vaultSle->at(sfAccount));
2183 }();
2184
2185 auto const [freeze, deepfreeze, unfreeze, expectedResult] =
2186 [&] -> std::tuple<
2187 std::function<void(Account const& holder)>,
2188 std::function<void(Account const& holder)>,
2189 std::function<void(Account const& holder)>,
2190 TER> {
2191 // Freeze / lock the asset
2192 std::function<void(Account const& holder)> const empty;
2193 if (broker.asset.native())
2194 {
2195 // XRP can't be frozen
2196 return std::make_tuple(empty, empty, empty, tesSUCCESS);
2197 }
2198 if (broker.asset.holds<Issue>())
2199 {
2200 auto const freeze = [&](Account const& holder) {
2201 env(trust(issuer, holder[iouCurrency_](0), tfSetFreeze));
2202 };
2203 auto const deepfreeze = [&](Account const& holder) {
2204 env(trust(issuer, holder[iouCurrency_](0), tfSetFreeze | tfSetDeepFreeze));
2205 };
2206 auto const unfreeze = [&](Account const& holder) {
2207 env(trust(
2208 issuer, holder[iouCurrency_](0), tfClearFreeze | tfClearDeepFreeze));
2209 };
2210 return std::make_tuple(freeze, deepfreeze, unfreeze, tecFROZEN);
2211 }
2212
2213 auto const freeze = [&](Account const& holder) {
2214 mptt.set({.account = issuer, .holder = holder, .flags = tfMPTLock});
2215 };
2216 auto const unfreeze = [&](Account const& holder) {
2217 mptt.set({.account = issuer, .holder = holder, .flags = tfMPTUnlock});
2218 };
2219 return std::make_tuple(freeze, empty, unfreeze, tecLOCKED);
2220 }();
2221
2222 // Try freezing the accounts that can't be frozen
2223 if (freeze)
2224 {
2225 for (auto const& account : {vaultPseudo, evan})
2226 {
2227 // Freeze the account
2228 freeze(account);
2229
2230 // Try to create a loan with a frozen line
2231 env(set(evan, broker.brokerID, debtMaximumRequest),
2232 Sig(sfCounterpartySignature, lender),
2233 loanSetFee,
2234 Ter(expectedResult));
2235
2236 // Unfreeze the account
2237 BEAST_EXPECT(unfreeze);
2238 unfreeze(account);
2239
2240 // Ensure the line is unfrozen with a request that is fine
2241 // except too it requests more principal than the broker can
2242 // carry
2243 env(set(evan, broker.brokerID, debtMaximumRequest + 1),
2244 Sig(sfCounterpartySignature, lender),
2245 loanSetFee,
2247 }
2248 }
2249
2250 // Deep freeze the borrower, which prevents them from receiving
2251 // funds
2252 if (deepfreeze)
2253 {
2254 // Make sure evan has a trust line that so the issuer can
2255 // freeze it. (Don't need to do this for the borrower,
2256 // because LoanSet will create a line to the borrower
2257 // automatically.)
2258 env(trust(evan, issuer[iouCurrency_](100'000)));
2259
2260 for (auto const& account : {
2261 // these accounts can't be frozen, which deep freeze
2262 // implies
2263 vaultPseudo,
2264 evan,
2265 // these accounts can't be deep frozen
2266 lender,
2267 })
2268 {
2269 // Freeze evan
2270 deepfreeze(account);
2271
2272 // Try to create a loan with a deep frozen line
2273 env(set(evan, broker.brokerID, debtMaximumRequest),
2274 Sig(sfCounterpartySignature, lender),
2275 loanSetFee,
2276 Ter(expectedResult));
2277
2278 // Unfreeze evan
2279 BEAST_EXPECT(unfreeze);
2280 unfreeze(account);
2281
2282 // Ensure the line is unfrozen with a request that is fine
2283 // except too it requests more principal than the broker can
2284 // carry
2285 env(set(evan, broker.brokerID, debtMaximumRequest + 1),
2286 Sig(sfCounterpartySignature, lender),
2287 loanSetFee,
2289 }
2290 }
2291 }
2292
2293 // Finally! Create a loan
2294
2295 auto coverAvailable = [&env, this](UInt256 const& brokerID, Number const& expected) {
2296 if (auto const brokerSle = env.le(keylet::loanBroker(brokerID));
2297 BEAST_EXPECT(brokerSle))
2298 {
2299 auto const available = brokerSle->at(sfCoverAvailable);
2300 BEAST_EXPECT(available == expected);
2301 return available;
2302 }
2303 return Number{};
2304 };
2305 auto getDefaultInfo = [&env, this](LoanState const& state, BrokerInfo const& broker) {
2306 if (auto const brokerSle = env.le(keylet::loanBroker(broker.brokerID));
2307 BEAST_EXPECT(brokerSle))
2308 {
2309 BEAST_EXPECT(
2310 state.loanScale >=
2311 (broker.asset.integral()
2312 ? 0
2313 : std::max(
2314 broker.vaultScale(env), state.principalOutstanding.exponent())));
2316 auto const defaultAmount = roundToAsset(
2317 broker.asset,
2318 std::min(
2321 brokerSle->at(sfDebtTotal), broker.params.coverRateMin),
2323 state.totalValue - state.managementFeeOutstanding),
2324 state.loanScale);
2325 return std::make_pair(defaultAmount, brokerSle->at(sfOwner));
2326 }
2327 return std::make_pair(Number{}, AccountID{});
2328 };
2329 auto replenishCover = [&env, &coverAvailable](
2330 BrokerInfo const& broker,
2331 AccountID const& brokerAcct,
2332 Number const& startingCoverAvailable,
2333 Number const& amountToBeCovered) {
2334 coverAvailable(broker.brokerID, startingCoverAvailable - amountToBeCovered);
2336 brokerAcct, broker.brokerID, STAmount{broker.asset, amountToBeCovered}));
2337 coverAvailable(broker.brokerID, startingCoverAvailable);
2338 env.close();
2339 };
2340
2341 auto const defaultImmediately = [&](std::uint32_t baseFlag, bool impair = true) {
2342 return [&, impair, baseFlag](
2343 Keylet const& loanKeylet, VerifyLoanStatus const& verifyLoanStatus) {
2344 // toEndOfLife
2345 //
2346 // Default the loan
2347
2348 // Initialize values with the current state
2349 auto state = getCurrentState(env, broker, loanKeylet, verifyLoanStatus);
2350 BEAST_EXPECT(state.flags == baseFlag);
2351
2352 auto const& broker = verifyLoanStatus.broker;
2353 auto const startingCoverAvailable = coverAvailable(
2354 broker.brokerID, broker.asset(broker.params.coverDeposit).number());
2355
2356 if (impair)
2357 {
2358 // Check the vault
2359 bool const canImpair = canImpairLoan(env, broker, state);
2360 // Under fixCleanup3_4_0 impair requires the payment to
2361 // already be late. Advance past the loan's next due
2362 // date so this exercises the tesSUCCESS branch. No-op
2363 // when the fix is disabled.
2364 advancePastDueDate(env, loanKeylet);
2365 // Impair the loan, if possible
2366 env(manage(lender, loanKeylet.key, tfLoanImpair),
2367 canImpair ? Ter(tesSUCCESS) : Ter(tecLIMIT_EXCEEDED));
2368
2369 if (canImpair)
2370 {
2371 state.flags |= tfLoanImpair;
2372 // Prior to fixCleanup3_4_0 impair rewrote
2373 // sfNextPaymentDueDate to parentCloseTime. Under the
2374 // fix, the due date is preserved.
2375 if (!env.current()->rules().enabled(fixCleanup3_4_0))
2376 state.nextPaymentDate = env.now().time_since_epoch().count();
2377
2378 // Once the loan is impaired, it can't be impaired again
2379 env(manage(lender, loanKeylet.key, tfLoanImpair), Ter(tecNO_PERMISSION));
2380 }
2381 verifyLoanStatus(state);
2382 }
2383
2384 auto const nextDueDate = Tp{D{state.nextPaymentDate}};
2385
2386 // Can't default the loan yet. The grace period hasn't
2387 // expired
2388 env(manage(lender, loanKeylet.key, tfLoanDefault), Ter(tecTOO_SOON));
2389
2390 // Let some time pass so that the loan can be
2391 // defaulted
2392 env.close(nextDueDate + 60s);
2393
2394 auto const [amountToBeCovered, brokerAcct] = getDefaultInfo(state, broker);
2395
2396 // Default the loan
2397 env(manage(lender, loanKeylet.key, tfLoanDefault));
2398 env.close();
2399
2400 // The LoanBroker just lost some of it's first-loss capital.
2401 // Replenish it.
2402 replenishCover(broker, brokerAcct, startingCoverAvailable, amountToBeCovered);
2403
2404 state.flags |= tfLoanDefault;
2405 state.paymentRemaining = 0;
2406 state.totalValue = 0;
2407 state.principalOutstanding = 0;
2408 state.managementFeeOutstanding = 0;
2409 state.nextPaymentDate = 0;
2410 verifyLoanStatus(state);
2411
2412 // Once a loan is defaulted, it can't be managed
2413 env(manage(lender, loanKeylet.key, tfLoanUnimpair), Ter(tecNO_PERMISSION));
2414 env(manage(lender, loanKeylet.key, tfLoanImpair), Ter(tecNO_PERMISSION));
2415 // Can't make a payment on it either
2416 env(pay(borrower, loanKeylet.key, broker.asset(300)), Ter(tecKILLED));
2417 };
2418 };
2419
2420 auto singlePayment = [&](Keylet const& loanKeylet,
2421 VerifyLoanStatus const& verifyLoanStatus,
2422 LoanState& state,
2423 STAmount const& payoffAmount,
2424 std::uint32_t numPayments,
2425 std::uint32_t baseFlag,
2426 std::uint32_t txFlags) {
2427 // toEndOfLife
2428 //
2429 verifyLoanStatus(state);
2430
2431 // Send some bogus pay transactions
2432 env(pay(borrower, keylet::loan(UInt256(0)).key, broker.asset(10), txFlags),
2433 Ter(temINVALID));
2434 // broker.asset(80) is less than a single payment, but all these
2435 // checks fail before that matters
2436 env(pay(borrower, loanKeylet.key, broker.asset(-80), txFlags), Ter(temBAD_AMOUNT));
2437 env(pay(borrower, broker.brokerID, broker.asset(80), txFlags), Ter(tecNO_ENTRY));
2438 env(pay(evan, loanKeylet.key, broker.asset(80), txFlags), Ter(tecNO_PERMISSION));
2439
2440 // TODO: Write a general "isFlag" function? See STObject::isFlag.
2441 // Maybe add a static overloaded member?
2442 if (!(state.flags & lsfLoanOverpayment))
2443 {
2444 // If the loan does not allow overpayments, send a payment that
2445 // tries to make an overpayment. Do not include `txFlags`, so we
2446 // don't end up duplicating the next test transaction.
2447 //
2448 // fixCleanup3_1_3 gates tfLoanOverpayment as a valid flag:
2449 // with fix on → preflight passes, apply returns tecNO_PERMISSION;
2450 // with fix off → preflight rejects the flag, returns temINVALID_FLAG.
2451 bool const hasFix313 = env.current()->rules().enabled(fixCleanup3_1_3);
2452 STAmount const overpayAmount{broker.asset, state.periodicPayment * Number{15, -1}};
2453 XRPAmount const overpayFee{
2454 baseFee * (Number{15, -1} / kLoanPaymentsPerFeeIncrement + 1)};
2455 env(pay(borrower, loanKeylet.key, overpayAmount, tfLoanOverpayment),
2456 Fee(overpayFee),
2457 Ter(hasFix313 ? TER{tecNO_PERMISSION} : TER{temINVALID_FLAG}));
2458
2459 if (hasFix313)
2460 {
2461 env.disableFeature(fixCleanup3_1_3);
2462 env(pay(borrower, loanKeylet.key, overpayAmount, tfLoanOverpayment),
2463 Fee(overpayFee),
2465 env.enableFeature(fixCleanup3_1_3);
2466 }
2467 }
2468 // Try to send a payment marked as multiple mutually exclusive
2469 // payment types. Do not include `txFlags`, so we don't duplicate
2470 // the prior test transaction.
2471 env(pay(borrower,
2472 loanKeylet.key,
2473 broker.asset(state.periodicPayment * 2),
2474 tfLoanLatePayment | tfLoanFullPayment),
2476 env(pay(borrower,
2477 loanKeylet.key,
2478 broker.asset(state.periodicPayment * 2),
2479 tfLoanLatePayment | tfLoanOverpayment),
2481 env(pay(borrower,
2482 loanKeylet.key,
2483 broker.asset(state.periodicPayment * 2),
2484 tfLoanOverpayment | tfLoanFullPayment),
2486 env(pay(borrower,
2487 loanKeylet.key,
2488 broker.asset(state.periodicPayment * 2),
2489 tfLoanLatePayment | tfLoanOverpayment | tfLoanFullPayment),
2491
2492 {
2493 auto const otherAsset =
2494 broker.asset.raw() == assets[0].raw() ? assets[1] : assets[0];
2495 env(pay(borrower, loanKeylet.key, otherAsset(100), txFlags), Ter(tecWRONG_ASSET));
2496 }
2497
2498 // Amount doesn't cover a single payment
2499 env(pay(borrower, loanKeylet.key, STAmount{broker.asset, 1}, txFlags),
2501
2502 // Get the balance after these failed transactions take
2503 // fees
2504 auto const borrowerBalanceBeforePayment = env.balance(borrower, broker.asset);
2505
2506 BEAST_EXPECT(payoffAmount > state.principalOutstanding);
2507 // Try to pay a little extra to show that it's _not_
2508 // taken
2509 auto const transactionAmount = payoffAmount + broker.asset(10);
2510
2511 // Send a transaction that tries to pay more than the borrowers's
2512 // balance
2513 XRPAmount const badFee{
2514 baseFee *
2515 (borrowerBalanceBeforePayment.number() * 2 / state.periodicPayment /
2516 kLoanPaymentsPerFeeIncrement +
2517 1)};
2518 env(pay(borrower,
2519 loanKeylet.key,
2520 STAmount{broker.asset, borrowerBalanceBeforePayment.number() * 2},
2521 txFlags),
2522 Fee(badFee),
2524
2525 XRPAmount const goodFee{baseFee * (numPayments / kLoanPaymentsPerFeeIncrement + 1)};
2526 env(pay(borrower, loanKeylet.key, transactionAmount, txFlags), Fee(goodFee));
2527
2528 env.close();
2529
2530 // log << env.meta()->getJson() << std::endl;
2531
2532 // Need to account for fees if the loan is in XRP
2533 PrettyAmount adjustment = broker.asset(0);
2534 if (broker.asset.native())
2535 {
2536 adjustment = badFee + goodFee;
2537 }
2538
2539 state.paymentRemaining = 0;
2540 state.principalOutstanding = 0;
2541 state.totalValue = 0;
2542 state.managementFeeOutstanding = 0;
2543 state.previousPaymentDate =
2544 state.nextPaymentDate + (state.paymentInterval * (numPayments - 1));
2545 state.nextPaymentDate = 0;
2546 verifyLoanStatus(state);
2547
2548 verifyLoanStatus.checkPayment(
2549 state.loanScale, borrower, borrowerBalanceBeforePayment, payoffAmount, adjustment);
2550
2551 // Can't impair or default a paid off loan
2552 env(manage(lender, loanKeylet.key, tfLoanImpair), Ter(tecNO_PERMISSION));
2553 env(manage(lender, loanKeylet.key, tfLoanDefault), Ter(tecNO_PERMISSION));
2554 };
2555
2556 auto const fullPayment = [&](std::uint32_t baseFlag) {
2557 return [&, baseFlag](
2558 Keylet const& loanKeylet, VerifyLoanStatus const& verifyLoanStatus) {
2559 // toEndOfLife
2560 //
2561 auto state = getCurrentState(env, broker, loanKeylet, verifyLoanStatus);
2562 env.close(state.startDate + 20s);
2563 auto const loanAge = (env.now() - state.startDate).count();
2564 BEAST_EXPECT(loanAge == 30);
2565
2566 // Full payoff amount will consist of
2567 // 1. principal outstanding (1000)
2568 // 2. accrued interest (at 12%)
2569 // 3. prepayment penalty (closeInterest at 3.6%)
2570 // 4. close payment fee (4)
2571 // Calculate these values without the helper functions
2572 // to verify they're working correctly The numbers in
2573 // the below BEAST_EXPECTs may not hold across assets.
2574 Number const interval = state.paymentInterval;
2575 auto const periodicRate = interval * Number(12, -2) / kSecondsInYear;
2576 BEAST_EXPECT(
2577 periodicRate == Number(2283105022831050228ULL, -24, Number::Normalized{}));
2578 STAmount const principalOutstanding{broker.asset, state.principalOutstanding};
2579 STAmount const accruedInterest{
2580 broker.asset, state.principalOutstanding * periodicRate * loanAge / interval};
2581 BEAST_EXPECT(accruedInterest == broker.asset(Number(1141552511415525, -19)));
2582 STAmount const prepaymentPenalty{
2583 broker.asset, state.principalOutstanding * Number(36, -3)};
2584 BEAST_EXPECT(prepaymentPenalty == broker.asset(36));
2585 STAmount const closePaymentFee = broker.asset(4);
2586 auto const payoffAmount = roundToScale(
2587 principalOutstanding + accruedInterest + prepaymentPenalty + closePaymentFee,
2588 state.loanScale);
2589 BEAST_EXPECT(
2590 payoffAmount ==
2592 broker.asset,
2593 broker.asset(Number(1040000114155251, -12)).number(),
2594 state.loanScale));
2595
2596 // The terms of this loan actually make the early payoff
2597 // more expensive than just making payments
2598 BEAST_EXPECT(
2599 payoffAmount >
2600 state.paymentRemaining * (state.periodicPayment + broker.asset(2).value()));
2601
2602 singlePayment(
2603 loanKeylet,
2604 verifyLoanStatus,
2605 state,
2606 payoffAmount,
2607 1,
2608 baseFlag,
2609 tfLoanFullPayment);
2610 };
2611 };
2612
2613 auto const combineAllPayments = [&](std::uint32_t baseFlag) {
2614 return
2615 [&, baseFlag](Keylet const& loanKeylet, VerifyLoanStatus const& verifyLoanStatus) {
2616 // toEndOfLife
2617 //
2618
2619 auto state = getCurrentState(env, broker, loanKeylet, verifyLoanStatus);
2620 env.close();
2621
2622 BEAST_EXPECT(
2623 STAmount(broker.asset, state.periodicPayment) ==
2624 broker.asset(Number(8333457002039338267, -17)));
2625
2626 // Make all the payments in one transaction
2627 // service fee is 2
2628 auto const startingPayments = state.paymentRemaining;
2629 STAmount const payoffAmount = [&] {
2631 auto const rawPayoff =
2632 startingPayments * (state.periodicPayment + broker.asset(2).value());
2633 STAmount payoffAmount{broker.asset, rawPayoff};
2634 BEAST_EXPECTS(
2635 payoffAmount == broker.asset(Number(1024014840244721, -12)),
2636 to_string(payoffAmount));
2637 BEAST_EXPECT(payoffAmount > state.principalOutstanding);
2638
2639 payoffAmount = roundToScale(payoffAmount, state.loanScale);
2640
2641 return payoffAmount;
2642 }();
2643
2644 auto const totalPayoffValue =
2645 state.totalValue + startingPayments * broker.asset(2).value();
2646 STAmount const totalPayoffAmount{broker.asset, totalPayoffValue};
2647
2648 BEAST_EXPECTS(
2649 totalPayoffAmount == payoffAmount,
2650 "Payoff amount: " + to_string(payoffAmount) +
2651 ". Total Value: " + to_string(totalPayoffAmount));
2652
2653 singlePayment(
2654 loanKeylet,
2655 verifyLoanStatus,
2656 state,
2657 payoffAmount,
2658 state.paymentRemaining,
2659 baseFlag,
2660 0);
2661 };
2662 };
2663
2664 // There are a lot of fields that can be set on a loan, but most
2665 // of them only affect the "math" when a payment is made. The
2666 // only one that really affects behavior is the
2667 // `tfLoanOverpayment` flag.
2668 lifecycle(
2669 caseLabel,
2670 "Loan overpayment allowed - Impair and Default",
2671 env,
2672 loanAmount,
2673 interestExponent,
2674 lender,
2675 borrower,
2676 evan,
2677 broker,
2678 pseudoAcct,
2679 tfLoanOverpayment,
2680 defaultImmediately(lsfLoanOverpayment));
2681
2682 lifecycle(
2683 caseLabel,
2684 "Loan overpayment prohibited - Impair and Default",
2685 env,
2686 loanAmount,
2687 interestExponent,
2688 lender,
2689 borrower,
2690 evan,
2691 broker,
2692 pseudoAcct,
2693 0,
2694 defaultImmediately(0));
2695
2696 lifecycle(
2697 caseLabel,
2698 "Loan overpayment allowed - Default without Impair",
2699 env,
2700 loanAmount,
2701 interestExponent,
2702 lender,
2703 borrower,
2704 evan,
2705 broker,
2706 pseudoAcct,
2707 tfLoanOverpayment,
2708 defaultImmediately(lsfLoanOverpayment, false));
2709
2710 lifecycle(
2711 caseLabel,
2712 "Loan overpayment prohibited - Default without Impair",
2713 env,
2714 loanAmount,
2715 interestExponent,
2716 lender,
2717 borrower,
2718 evan,
2719 broker,
2720 pseudoAcct,
2721 0,
2722 defaultImmediately(0, false));
2723
2724 lifecycle(
2725 caseLabel,
2726 "Loan overpayment prohibited - Pay off immediately",
2727 env,
2728 loanAmount,
2729 interestExponent,
2730 lender,
2731 borrower,
2732 evan,
2733 broker,
2734 pseudoAcct,
2735 0,
2736 fullPayment(0));
2737
2738 lifecycle(
2739 caseLabel,
2740 "Loan overpayment allowed - Pay off immediately",
2741 env,
2742 loanAmount,
2743 interestExponent,
2744 lender,
2745 borrower,
2746 evan,
2747 broker,
2748 pseudoAcct,
2749 tfLoanOverpayment,
2750 fullPayment(lsfLoanOverpayment));
2751
2752 lifecycle(
2753 caseLabel,
2754 "Loan overpayment prohibited - Combine all payments",
2755 env,
2756 loanAmount,
2757 interestExponent,
2758 lender,
2759 borrower,
2760 evan,
2761 broker,
2762 pseudoAcct,
2763 0,
2764 combineAllPayments(0));
2765
2766 lifecycle(
2767 caseLabel,
2768 "Loan overpayment allowed - Combine all payments",
2769 env,
2770 loanAmount,
2771 interestExponent,
2772 lender,
2773 borrower,
2774 evan,
2775 broker,
2776 pseudoAcct,
2777 tfLoanOverpayment,
2778 combineAllPayments(lsfLoanOverpayment));
2779
2780 lifecycle(
2781 caseLabel,
2782 "Loan overpayment prohibited - Make payments",
2783 env,
2784 loanAmount,
2785 interestExponent,
2786 lender,
2787 borrower,
2788 evan,
2789 broker,
2790 pseudoAcct,
2791 0,
2792 [&](Keylet const& loanKeylet, VerifyLoanStatus const& verifyLoanStatus) {
2793 // toEndOfLife
2794 //
2795 // Draw and make multiple payments
2796 auto state = getCurrentState(env, broker, loanKeylet, verifyLoanStatus);
2797 BEAST_EXPECT(state.flags == 0);
2798 env.close();
2799
2800 verifyLoanStatus(state);
2801
2802 env.close(state.startDate + 20s);
2803 auto const loanAge = (env.now() - state.startDate).count();
2804 BEAST_EXPECT(loanAge == 30);
2805
2806 // Periodic payment amount will consist of
2807 // 1. principal outstanding (1000)
2808 // 2. interest interest rate (at 12%)
2809 // 3. payment interval (600s)
2810 // 4. loan service fee (2)
2811 // Calculate these values without the helper functions
2812 // to verify they're working correctly The numbers in
2813 // the below BEAST_EXPECTs may not hold across assets.
2814 Number const interval = state.paymentInterval;
2815 auto const periodicRate = interval * Number(12, -2) / kSecondsInYear;
2816 BEAST_EXPECT(
2817 periodicRate == Number(2283105022831050228, -24, Number::Normalized{}));
2818 STAmount const roundedPeriodicPayment{
2819 broker.asset,
2820 roundPeriodicPayment(broker.asset, state.periodicPayment, state.loanScale)};
2821
2822 testcase << currencyLabel << " Payment components: "
2823 << "Payments remaining, rawInterest, rawPrincipal, "
2824 "rawMFee, trackedValueDelta, trackedPrincipalDelta, "
2825 "trackedInterestDelta, trackedMgmtFeeDelta, special";
2826
2827 auto const serviceFee = broker.asset(2);
2828
2829 BEAST_EXPECT(
2830 roundedPeriodicPayment ==
2832 broker.asset(
2833 Number(8333457002039338267, -17), Number::RoundingMode::Upward),
2834 state.loanScale,
2836 // 83334570.01162141
2837 // Include the service fee
2838 STAmount const totalDue = roundToScale(
2839 roundedPeriodicPayment + serviceFee,
2840 state.loanScale,
2842 // Only check the first payment since the rounding
2843 // may drift as payments are made
2844 BEAST_EXPECT(
2845 totalDue ==
2847 broker.asset(
2848 Number(8533457002039338267, -17), Number::RoundingMode::Upward),
2849 state.loanScale,
2851
2852 {
2853 auto const raw = computeTheoreticalLoanState(
2854 env.current()->rules(),
2855 state.periodicPayment,
2856 periodicRate,
2857 state.paymentRemaining,
2858 broker.params.managementFeeRate);
2859 auto const rounded = constructLoanState(
2860 state.totalValue,
2861 state.principalOutstanding,
2862 state.managementFeeOutstanding);
2863 testcase << currencyLabel << " Loan starting state: " << state.paymentRemaining
2864 << ", " << raw.interestDue << ", " << raw.principalOutstanding << ", "
2865 << raw.managementFeeDue << ", " << rounded.valueOutstanding << ", "
2866 << rounded.principalOutstanding << ", " << rounded.interestDue << ", "
2867 << rounded.managementFeeDue;
2868 }
2869
2870 // Try to pay a little extra to show that it's _not_
2871 // taken
2872 STAmount const transactionAmount =
2873 STAmount{broker.asset, totalDue} + broker.asset(10);
2874 // Only check the first payment since the rounding
2875 // may drift as payments are made
2876 BEAST_EXPECT(
2877 transactionAmount ==
2879 broker.asset(Number(9533457002039400, -14), Number::RoundingMode::Upward),
2880 state.loanScale,
2882
2883 auto const initialState = state;
2885 .trackedValueDelta = 0,
2886 .trackedPrincipalDelta = 0,
2887 .trackedManagementFeeDelta = 0,
2888 };
2889 Number totalInterestPaid = 0;
2890 std::size_t totalPaymentsMade = 0;
2891
2893 env.current()->rules(),
2894 state.periodicPayment,
2895 periodicRate,
2896 state.paymentRemaining,
2897 broker.params.managementFeeRate);
2898
2899 while (state.paymentRemaining > 0)
2900 {
2901 // Compute the expected principal amount
2902 auto const paymentComponents = xrpl::detail::computePaymentComponents(
2903 env.current()->rules(),
2904 broker.asset.raw(),
2905 state.loanScale,
2906 state.totalValue,
2907 state.principalOutstanding,
2908 state.managementFeeOutstanding,
2909 state.periodicPayment,
2910 periodicRate,
2911 state.paymentRemaining,
2912 broker.params.managementFeeRate);
2913
2914 BEAST_EXPECTS(
2915 paymentComponents.specialCase == xrpl::detail::PaymentSpecialCase::Final ||
2916 paymentComponents.trackedValueDelta <= roundedPeriodicPayment,
2917 "Delta: " + to_string(paymentComponents.trackedValueDelta) +
2918 ", periodic payment: " + to_string(roundedPeriodicPayment));
2919
2920 xrpl::LoanState const nextTrueState = computeTheoreticalLoanState(
2921 env.current()->rules(),
2922 state.periodicPayment,
2923 periodicRate,
2924 state.paymentRemaining - 1,
2925 broker.params.managementFeeRate);
2926 xrpl::detail::LoanStateDeltas const deltas = currentTrueState - nextTrueState;
2927
2928 testcase << currencyLabel << " Payment components: " << state.paymentRemaining
2929 << ", " << deltas.interest << ", " << deltas.principal << ", "
2930 << deltas.managementFee << ", " << paymentComponents.trackedValueDelta
2931 << ", " << paymentComponents.trackedPrincipalDelta << ", "
2932 << paymentComponents.trackedInterestPart() << ", "
2933 << paymentComponents.trackedManagementFeeDelta << ", "
2934 << [&] -> char const* {
2935 if (paymentComponents.specialCase ==
2937 return "final";
2938 if (paymentComponents.specialCase ==
2940 return "extra";
2941 return "none";
2942 }();
2943
2944 auto const totalDueAmount = STAmount{
2945 broker.asset, paymentComponents.trackedValueDelta + serviceFee.number()};
2946
2947 // Due to the rounding algorithms to keep the interest and
2948 // principal in sync with "true" values, the computed amount
2949 // may be a little less than the rounded fixed payment
2950 // amount. For integral types, the difference should be < 3
2951 // (1 unit for each of the interest and management fee). For
2952 // IOUs, the difference should be after the 8th digit.
2953 Number const diff = totalDue - totalDueAmount;
2954 BEAST_EXPECT(
2955 paymentComponents.specialCase == xrpl::detail::PaymentSpecialCase::Final ||
2956 diff == beast::kZero ||
2957 (diff > beast::kZero &&
2958 ((broker.asset.integral() && (static_cast<Number>(diff) < 3)) ||
2959 (state.loanScale - diff.exponent() > 13))));
2960
2961 BEAST_EXPECT(
2962 paymentComponents.trackedValueDelta ==
2963 paymentComponents.trackedPrincipalDelta +
2964 paymentComponents.trackedInterestPart() +
2965 paymentComponents.trackedManagementFeeDelta);
2966 BEAST_EXPECT(
2967 paymentComponents.specialCase == xrpl::detail::PaymentSpecialCase::Final ||
2968 paymentComponents.trackedValueDelta <= roundedPeriodicPayment);
2969
2970 BEAST_EXPECT(
2971 state.paymentRemaining < 12 ||
2973 broker.asset,
2974 deltas.principal,
2975 state.loanScale,
2978 broker.asset(
2979 Number(8333228691531218890, -17), Number::RoundingMode::Upward),
2980 state.loanScale,
2982 BEAST_EXPECT(
2983 paymentComponents.trackedPrincipalDelta >= beast::kZero &&
2984 paymentComponents.trackedPrincipalDelta <= state.principalOutstanding);
2985 BEAST_EXPECT(
2986 paymentComponents.specialCase != xrpl::detail::PaymentSpecialCase::Final ||
2987 paymentComponents.trackedPrincipalDelta == state.principalOutstanding);
2988 BEAST_EXPECT(
2989 paymentComponents.specialCase == xrpl::detail::PaymentSpecialCase::Final ||
2990 (state.periodicPayment.exponent() -
2991 (deltas.principal + deltas.interest + deltas.managementFee -
2992 state.periodicPayment)
2993 .exponent()) > 14);
2994
2995 auto const borrowerBalanceBeforePayment = env.balance(borrower, broker.asset);
2996
2997 // Under fixCleanup3_4_0 impair requires the payment to
2998 // already be late. This periodic-payment loop stays
2999 // within each payment interval, so the loan is never
3000 // late here; skip the impair rather than perturb the
3001 // payment schedule.
3002 auto const loanSle = env.le(loanKeylet);
3003 bool const impairAllowed = BEAST_EXPECT(loanSle) &&
3004 canImpairLoan(env, broker, state) &&
3005 (!env.current()->rules().enabled(fixCleanup3_4_0) ||
3006 isPaymentLate(*env.current(), loanSle));
3007 if (impairAllowed)
3008 {
3009 // Making a payment will unimpair the loan
3010 env(manage(lender, loanKeylet.key, tfLoanImpair));
3011 }
3012
3013 env.close();
3014
3015 // Make the payment
3016 env(pay(borrower, loanKeylet.key, transactionAmount));
3017
3018 env.close();
3019
3020 // Need to account for fees if the loan is in XRP
3021 PrettyAmount adjustment = broker.asset(0);
3022 if (broker.asset.native())
3023 {
3024 adjustment = env.current()->fees().base;
3025 }
3026
3027 // Check the result
3028 verifyLoanStatus.checkPayment(
3029 state.loanScale,
3030 borrower,
3031 borrowerBalanceBeforePayment,
3032 totalDueAmount,
3033 adjustment);
3034
3035 --state.paymentRemaining;
3036 state.previousPaymentDate = state.nextPaymentDate;
3037 if (paymentComponents.specialCase == xrpl::detail::PaymentSpecialCase::Final)
3038 {
3039 state.paymentRemaining = 0;
3040 state.nextPaymentDate = 0;
3041 }
3042 else
3043 {
3044 state.nextPaymentDate += state.paymentInterval;
3045 }
3046 state.principalOutstanding -= paymentComponents.trackedPrincipalDelta;
3047 state.managementFeeOutstanding -= paymentComponents.trackedManagementFeeDelta;
3048 state.totalValue -= paymentComponents.trackedValueDelta;
3049
3050 verifyLoanStatus(state);
3051
3052 totalPaid.trackedValueDelta += paymentComponents.trackedValueDelta;
3053 totalPaid.trackedPrincipalDelta += paymentComponents.trackedPrincipalDelta;
3054 totalPaid.trackedManagementFeeDelta +=
3055 paymentComponents.trackedManagementFeeDelta;
3056 totalInterestPaid += paymentComponents.trackedInterestPart();
3057 ++totalPaymentsMade;
3058
3059 currentTrueState = nextTrueState;
3060 }
3061
3062 // Loan is paid off
3063 BEAST_EXPECT(state.paymentRemaining == 0);
3064 BEAST_EXPECT(state.principalOutstanding == 0);
3065
3066 // Make sure all the payments add up
3067 BEAST_EXPECT(totalPaid.trackedValueDelta == initialState.totalValue);
3068 BEAST_EXPECT(totalPaid.trackedPrincipalDelta == initialState.principalOutstanding);
3069 BEAST_EXPECT(
3070 totalPaid.trackedManagementFeeDelta == initialState.managementFeeOutstanding);
3071 // This is almost a tautology given the previous checks, but
3072 // check it anyway for completeness.
3073 BEAST_EXPECT(
3074 totalInterestPaid ==
3075 initialState.totalValue -
3076 (initialState.principalOutstanding +
3077 initialState.managementFeeOutstanding));
3078 BEAST_EXPECT(totalPaymentsMade == initialState.paymentRemaining);
3079
3080 // Can't impair or default a paid off loan
3081 env(manage(lender, loanKeylet.key, tfLoanImpair), Ter(tecNO_PERMISSION));
3082 env(manage(lender, loanKeylet.key, tfLoanDefault), Ter(tecNO_PERMISSION));
3083 });
3084
3085#if LOAN_TODO
3086 // TODO
3087
3088 /*
3089 LoanPay fails with tecINVARIANT_FAILED error when loan_broker(also
3090 borrower) tries to do the payment. Here's the scenario: Create a XRP
3091 loan with loan broker as borrower, loan origination fee and loan service
3092 fee. Loan broker makes the first payment with periodic payment and loan
3093 service fee.
3094 */
3095
3096 auto time = [&](std::string label, std::function<void()> timed) {
3097 if (!BEAST_EXPECT(timed))
3098 return;
3099
3100 using ClockType = std::chrono::steady_clock;
3101 using DurationType = std::chrono::milliseconds;
3102
3103 auto const start = ClockType::now();
3104 timed();
3105 auto const duration =
3106 std::chrono::duration_cast<DurationType>(ClockType::now() - start);
3107
3108 log << label << " took " << duration.count() << "ms" << std::endl;
3109
3110 return duration;
3111 };
3112
3113 lifecycle(
3114 caseLabel,
3115 "timing",
3116 env,
3117 loanAmount,
3118 interestExponent,
3119 lender,
3120 borrower,
3121 evan,
3122 broker,
3123 pseudoAcct,
3124 tfLoanOverpayment,
3125 [&](Keylet const& loanKeylet, VerifyLoanStatus const& verifyLoanStatus) {
3126 // Estimate optimal values for kLoanPaymentsPerFeeIncrement and
3127 // kLoanMaximumPaymentsPerTransaction.
3128 using namespace loan;
3129
3130 auto const state = getCurrentState(env, broker, verifyLoanStatus.keylet);
3131 auto const serviceFee = broker.asset(2).value();
3132
3133 STAmount const totalDue{
3134 broker.asset,
3136 broker.asset, state.periodicPayment + serviceFee, state.loanScale)};
3137
3138 // Make a single payment
3139 time("single payment", [&]() { env(pay(borrower, loanKeylet.key, totalDue)); });
3140 env.close();
3141
3142 // Make all but the final payment
3143 auto const numPayments = (state.paymentRemaining - 2);
3144 STAmount const bigPayment{broker.asset, totalDue * numPayments};
3145 XRPAmount const bigFee{baseFee * (numPayments / kLoanPaymentsPerFeeIncrement + 1)};
3146 time("ten payments", [&]() {
3147 env(pay(borrower, loanKeylet.key, bigPayment), Fee(bigFee));
3148 });
3149 env.close();
3150
3151 time("final payment", [&]() {
3152 // Make the final payment
3153 env(pay(borrower, loanKeylet.key, totalDue + STAmount{broker.asset, 1}));
3154 });
3155 env.close();
3156 });
3157
3158 lifecycle(
3159 caseLabel,
3160 "Loan overpayment allowed - Explicit overpayment",
3161 env,
3162 loanAmount,
3163 interestExponent,
3164 lender,
3165 borrower,
3166 evan,
3167 broker,
3168 pseudoAcct,
3169 tfLoanOverpayment,
3170 [&](Keylet const& loanKeylet, VerifyLoanStatus const& verifyLoanStatus) { throw 0; });
3171
3172 lifecycle(
3173 caseLabel,
3174 "Loan overpayment prohibited - Late payment",
3175 env,
3176 loanAmount,
3177 interestExponent,
3178 lender,
3179 borrower,
3180 evan,
3181 broker,
3182 pseudoAcct,
3183 tfLoanOverpayment,
3184 [&](Keylet const& loanKeylet, VerifyLoanStatus const& verifyLoanStatus) { throw 0; });
3185
3186 lifecycle(
3187 caseLabel,
3188 "Loan overpayment allowed - Late payment",
3189 env,
3190 loanAmount,
3191 interestExponent,
3192 lender,
3193 borrower,
3194 evan,
3195 broker,
3196 pseudoAcct,
3197 tfLoanOverpayment,
3198 [&](Keylet const& loanKeylet, VerifyLoanStatus const& verifyLoanStatus) { throw 0; });
3199
3200 lifecycle(
3201 caseLabel,
3202 "Loan overpayment allowed - Late payment and overpayment",
3203 env,
3204 loanAmount,
3205 interestExponent,
3206 lender,
3207 borrower,
3208 evan,
3209 broker,
3210 pseudoAcct,
3211 tfLoanOverpayment,
3212 [&](Keylet const& loanKeylet, VerifyLoanStatus const& verifyLoanStatus) { throw 0; });
3213
3214#endif
3215 }
3216};
3217
3218} // namespace xrpl::test
A testsuite class.
Definition suite.h:52
bool expect(Condition const &shouldBeTrue)
Evaluate a test condition.
Definition suite.h:235
LogOs< char > log
Logging output stream.
Definition suite.h:150
TestcaseT testcase
Memberspace for declaring test cases.
Definition suite.h:155
constexpr bool native() const
Definition Asset.h:125
constexpr bool holds() const
Definition Asset.h:177
A currency issued by an account.
Definition Issue.h:18
static constexpr std::uint32_t kDefaultPaymentTotal
static constexpr std::uint32_t kMinPaymentTotal
static constexpr std::uint32_t kDefaultPaymentInterval
static constexpr std::uint32_t kMinPaymentInterval
std::chrono::time_point< NetClock > time_point
Definition chrono.h:48
std::chrono::duration< rep, period > duration
Definition chrono.h:47
Number is a floating point type that can represent a wide range of values.
Definition Number.h:351
Number truncate() const noexcept
constexpr int exponent() const noexcept
Returns the exponent of the external view of the Number.
Definition Number.h:718
STAmount const & value() const noexcept
Definition STAmount.h:610
static constexpr SeqProxy rawSequence(std::uint32_t v)
Factory function to return a sequence-based SeqProxy.
Definition SeqProxy.h:62
Shared base for the Loan*_test family under src/test/app/lending/.
void testCaseWrapper(jtx::Env &env, jtx::MPTTester &mptt, std::array< TAsset, NAsset > const &assets, BrokerInfo const &broker, Number const &loanAmount, int interestExponent)
Wrapper to run a series of lifecycle tests for a given asset and loan amount.
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)
FeatureBitset const all_
void advancePastDueDate(jtx::Env &env, Keylet const &loanKeylet)
void runLoan(AssetType assetType, BrokerParameters const &brokerParams, LoanParameters const &loanParams, FeatureBitset features)
jtx::Account brokerPseudoAccount(jtx::Env const &env, BrokerInfo const &broker, jtx::Account const &fallback)
BrokerInfo createVaultAndBroker(jtx::Env &env, jtx::PrettyAsset const &asset, jtx::Account const &lender, BrokerParameters const &params=BrokerParameters::defaults())
void describeLoan(jtx::Env &env, BrokerParameters const &brokerParams, LoanParameters const &loanParams, AssetType assetType, jtx::Account const &issuer, jtx::Account const &lender, jtx::Account const &borrower)
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)
void lifecycle(std::string const &caseLabel, char const *label, jtx::Env &env, Number const &loanAmount, int interestExponent, jtx::Account const &lender, jtx::Account const &borrower, jtx::Account const &evan, BrokerInfo const &broker, jtx::Account const &pseudoAcct, std::uint32_t flags, std::function< void(Keylet const &loanKeylet, VerifyLoanStatus const &verifyLoanStatus)> toEndOfLife)
Runs through the complete lifecycle of a loan.
void makeLoanPayments(jtx::Env &env, BrokerInfo const &broker, LoanParameters const &loanParams, Keylet const &loanKeylet, VerifyLoanStatus const &verifyLoanStatus, jtx::Account const &issuer, jtx::Account const &lender, jtx::Account const &borrower, PaymentParameters const &paymentParams=PaymentParameters::defaults())
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)
LoanState getCurrentState(jtx::Env const &env, BrokerInfo const &broker, Keylet const &loanKeylet, VerifyLoanStatus const &verifyLoanStatus)
Get the state and check the values against the parameters used in lifecycle.
uint256 createDomain(jtx::Env &env, jtx::Account const &owner, jtx::Account const &credIssuer, std::string const &credType)
jtx::PrettyAsset createAsset(jtx::Env &env, AssetType assetType, BrokerParameters const &brokerParams, jtx::Account const &issuer, jtx::Account const &lender, jtx::Account const &borrower)
std::string const iouCurrency_
bool canImpairLoan(jtx::Env const &env, BrokerInfo const &broker, LoanState const &state)
static std::string getCurrencyLabel(Asset const &asset)
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.
Definition jtx/Account.h:21
AccountID id() const
Returns the Account ID.
A transaction testing environment.
Definition Env.h:161
bool close(NetClock::time_point closeTime, std::optional< std::chrono::milliseconds > consensusDelay=std::nullopt)
Close and advance the ledger.
Definition Env.cpp:133
json::Value json(JsonValue &&jv, FN const &... fN)
Create JSON from parameters.
Definition Env.h:752
SLE::const_pointer le(Account const &account) const
Return an account root.
Definition Env.cpp:311
std::uint32_t ownerCount(Account const &account) const
Return the number of objects owned by an account.
Definition Env.cpp:266
void fund(bool setDefaultRipple, STAmount const &amount, Account const &account)
Definition Env.cpp:323
std::uint32_t seq(Account const &account) const
Returns the next sequence number on account.
Definition Env.cpp:302
Account const & master
Definition Env.h:165
JTx jt(JsonValue &&jv, FN const &... fN)
Create a JTx from parameters.
Definition Env.h:723
PrettyAmount balance(Account const &account) const
Returns the XRP balance on an account.
Definition Env.cpp:201
void disableFeature(UInt256 const feature)
Definition Env.cpp:717
void enableFeature(UInt256 const feature)
Definition Env.cpp:709
std::shared_ptr< STObject const > meta()
Return metadata for the last JTx.
Definition Env.cpp:538
void memoize(Account const &account)
Associate AccountID with account.
Definition Env.cpp:174
beast::Journal const journal
Definition Env.h:204
std::shared_ptr< OpenView const > current() const
Returns the current ledger.
Definition Env.h:377
NetClock::time_point now()
Returns the current network time.
Definition Env.h:326
Set the fee on a JTx.
Definition fee.h:20
Converts to IOU Issue or STAmount.
Test helper for creating, mutating, and asserting MPT and confidential MPT ledger state.
Definition mpt.h:512
MPTID const & issuanceID() const
Definition mpt.h:777
void create(MPTCreate const &arg=MPTCreate{}, std::source_location const &loc=std::source_location::current())
Definition mpt.cpp:346
void set(MPTSet const &set={}, std::source_location const &loc=std::source_location::current())
Definition mpt.cpp:581
void authorize(MPTAuthorize const &arg=MPTAuthorize{}, std::source_location const &loc=std::source_location::current())
Definition mpt.cpp:459
Converts to MPT Issue or STAmount.
Set a multisignature on a JTx.
Definition multisign.h:53
Set the regular signature on a JTx.
Definition sig.h:19
Set the expected result code for a JTx The test will fail if the code doesn't match.
Definition ter.h:18
T duration_cast(T... args)
T empty(T... args)
T endl(T... args)
T make_pair(T... args)
T make_tuple(T... args)
T max(T... args)
T min(T... args)
constexpr Zero kZero
Definition Zero.h:30
STL namespace.
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.
Definition Indexes.h:39
Keylet vault(AccountID const &owner, SeqProxy const &seq) noexcept
Definition Indexes.cpp:565
Keylet loanBroker(AccountID const &owner, SeqProxy const &seq) noexcept
Definition Indexes.cpp:571
Keylet account(AccountID const &id) noexcept
AccountID root.
Definition Indexes.cpp:233
Keylet loan(UInt256 const &loanBrokerID, SeqProxy const &loanSeq) noexcept
Definition Indexes.cpp:577
Deposit preauthorize operations.
Definition deposit.h:16
json::Value coverDeposit(AccountID const &account, UInt256 const &brokerID, STAmount const &amount, uint32_t flags)
json::Value del(AccountID const &account, UInt256 const &brokerID, uint32_t flags)
json::Value set(AccountID const &account, UInt256 const &loanBrokerID, Number principalRequested, std::uint32_t flags)
std::vector< Credential > Credentials
UInt256 getNewDomain(std::shared_ptr< STObject const > const &meta)
json::Value setTx(AccountID const &account, Credentials const &credentials, std::optional< UInt256 > domain)
static NoneT const kNone
Definition tags.h:9
json::Value pay(AccountID const &account, AccountID const &to, AnyAmount amount)
Create a payment.
Definition pay.cpp:14
XrpT const XRP
Converts to XRP Issue or STAmount.
Definition amount.cpp:92
std::uint32_t ownerCount(Env const &env, Account const &account)
static Number number(STAmount const &a)
Definition AMM.cpp:44
FeatureBitset testableAmendments()
Definition Env.h:92
auto const kData
General field definitions, or fields used in multiple transaction namespaces.
std::array< Account, 1+sizeof...(Args)> noripple(Account const &account, Args const &... args)
Designate accounts as no-ripple in Env::fund.
Definition Env.h:86
json::Value trust(Account const &account, STAmount const &amount, std::uint32_t flags)
Modify a trust line.
Definition trust.cpp:18
json::Value signers(Account const &account, std::uint32_t quorum, std::vector< Signer > const &v)
Definition multisign.cpp:31
json::Value fset(Account const &account, std::uint32_t on, std::uint32_t off=0)
Add and/or remove flag.
Definition flags.cpp:15
static MPTInit const kMptInitNoFund
Definition mpt.h:201
static STAmount accountReserve(jtx::Env const &env, std::uint32_t count=1)
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).
Definition TxTest.h:53
static constexpr Number kNumZero
Definition Number.h:667
@ telINSUF_FEE_P
Definition TER.h:43
@ terNO_ACCOUNT
Definition TER.h:219
bool set(T &target, std::string const &name, Section const &section)
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.
Definition Issue.h:108
Number loanPeriodicRate(TenthBips32 interestRate, std::uint32_t paymentInterval)
constexpr TenthBips32 percentageToTenthBips(std::uint32_t percentage)
Definition Protocol.h:127
constexpr T tenthBipsOfValue(T value, TenthBips< TBips > bips)
Definition Protocol.h:139
@ tefBAD_SIGNATURE
Definition TER.h:173
@ tefBAD_AUTH
Definition TER.h:163
@ tefNOT_MULTI_SIGNING
Definition TER.h:175
int getVaultScale(SLE::ConstRef vault)
Return the Vault's current live exponent.
TenthBips< std::uint32_t > TenthBips32
Definition Units.h:454
TenthBips< std::uint16_t > TenthBips16
Definition Units.h:453
VaultKind
Vault kind.
Definition Protocol.h:358
std::string to_string(BaseUInt< Bits, Tag > const &a)
Definition base_uint.h:658
constexpr std::size_t kMaxDataPayloadLength
The maximum length of Data payload.
Definition Protocol.h:303
TER checkLoanGuards(Asset const &vaultAsset, Number const &principalRequested, bool expectInterest, std::uint32_t paymentTotal, LoanProperties const &properties, beast::Journal j)
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.
constexpr TenthBips32 kTenthBipsPerUnity(kBipsPerUnity.value() *10)
BaseUInt< 256 > UInt256
Definition base_uint.h:581
LedgerSpecificFlags
bool isPaymentLate(ReadView const &view, SLE::ConstRef loanSle)
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.
Definition STAmount.h:745
BaseUInt< 160, detail::AccountIDTag > AccountID
A 160-bit unsigned that uniquely identifies an account.
Definition AccountID.h:34
Number roundPeriodicPayment(Asset const &asset, Number const &periodicPayment, std::int32_t scale)
Ensure the periodic payment is always rounded consistently.
@ temINVALID
Definition TER.h:98
@ temINVALID_FLAG
Definition TER.h:99
@ temBAD_AMOUNT
Definition TER.h:77
@ temBAD_SIGNER
Definition TER.h:103
Number computeManagementFee(Asset const &asset, Number const &interest, TenthBips32 managementFeeRate, std::int32_t scale)
TERSubset< CanCvtToTER > TER
Definition TER.h:657
@ tecWRONG_ASSET
Definition TER.h:371
@ tecLOCKED
Definition TER.h:369
@ tecNO_ENTRY
Definition TER.h:317
@ tecTOO_SOON
Definition TER.h:329
@ tecFROZEN
Definition TER.h:314
@ tecINSUFFICIENT_FUNDS
Definition TER.h:336
@ tecKILLED
Definition TER.h:327
@ tecLIMIT_EXCEEDED
Definition TER.h:372
@ tecNO_PERMISSION
Definition TER.h:316
@ tecHAS_OBLIGATIONS
Definition TER.h:328
@ tecINSUFFICIENT_PAYMENT
Definition TER.h:338
Number getAssetsTotal(SLE::ConstRef vault)
Return the Vault's current assets total.
static constexpr std::uint32_t kSecondsInYear
LoanProperties computeLoanProperties(Rules const &rules, Asset const &asset, Number const &principalOutstanding, TenthBips32 interestRate, std::uint32_t paymentInterval, std::uint32_t paymentsRemaining, TenthBips32 managementFeeRate, std::int32_t minimumScale)
VaultVersion getVaultVersion(SLE::ConstRef vault)
Resolves a Vault's LEVersion.
LoanState constructLoanState(Number const &totalValueOutstanding, Number const &principalOutstanding, Number const &managementFeeOutstanding)
@ tesSUCCESS
Definition TER.h:253
UInt256 uint256
Definition base_uint.h:587
T str(T... args)
A pair of SHAMap key and LedgerEntryType.
Definition Keylet.h:20
UInt256 key
Definition Keylet.h:21
This structure captures the parts of a loan state.
Number principalOutstanding
Number total() const
Calculates the total change across all components.
std::optional< std::uint32_t > subscriptionDate
std::optional< std::uint32_t > redemptionDate
int vaultScale(jtx::Env const &env) const
BrokerInfo(jtx::PrettyAsset const &asset, Keylet const &brokerKeylet, Keylet const &vaultKeylet, BrokerParameters p, std::optional< std::uint32_t > subscriptionDate=std::nullopt, std::optional< std::uint32_t > redemptionDate=std::nullopt)
static BrokerParameters const & defaults()
Number maxCoveredLoanValue(Number const &currentDebt) const
std::optional< std::uint32_t > vaultFlags
std::optional< std::uint8_t > vaultScale
std::optional< std::uint32_t > payTotal
std::optional< std::uint32_t > flags
std::optional< std::uint32_t > gracePd
jtx::JTx operator()(jtx::Env &env, BrokerInfo const &broker, FN const &... fN) const
std::optional< TenthBips32 > overpaymentInterest
std::optional< TenthBips32 > overFee
std::optional< TenthBips32 > lateInterest
std::optional< TenthBips32 > closeInterest
std::optional< TenthBips32 > interest
std::optional< std::uint32_t > payInterval
static PaymentParameters const & defaults()
Helper class to compare the expected state of a loan and loan broker against the data in the ledger.
void operator()(std::uint32_t previousPaymentDate, std::uint32_t nextPaymentDate, std::uint32_t paymentRemaining, Number const &loanScale, Number const &totalValue, Number const &principalOutstanding, Number const &managementFeeOutstanding, Number const &periodicPayment, std::uint32_t flags) const
Checks both the loan and broker expect states against the ledger.
void checkBroker(Number const &principalOutstanding, Number const &interestOwed, TenthBips32 interestRate, std::uint32_t paymentInterval, std::uint32_t paymentsRemaining, std::uint32_t ownerCount) const
Checks the expected broker state against the ledger.
void checkPayment(std::int32_t loanScale, jtx::Account const &account, jtx::PrettyAmount const &balanceBefore, STAmount const &expectedPayment, jtx::PrettyAmount const &adjustment) const
void operator()(LoanState const &state) const
Checks both the loan and broker expect states against the ledger.
VerifyLoanStatus(jtx::Env const &env, BrokerInfo const &broker, jtx::Account const &pseudo, Keylet const &keylet)
Execution context for applying a JSON transaction.
Definition JTx.h:27
Represents an XRP, IOU, or MPT quantity This customizes the string conversion and supports XRP conver...
STAmount const & value() const
T time_since_epoch(T... args)
T value_or(T... args)