xrpld
Loading...
Searching...
No Matches
InvariantsVault_test.cpp
1#include <test/app/invariants/InvariantsBase.h>
2#include <test/jtx/Account.h>
3#include <test/jtx/Env.h>
4#include <test/jtx/TestHelpers.h>
5#include <test/jtx/amount.h>
6#include <test/jtx/fee.h>
7#include <test/jtx/pay.h>
8#include <test/jtx/sig.h>
9#include <test/jtx/trust.h>
10#include <test/jtx/vault.h>
11#include <test/unit_test/SuiteJournal.h>
12
13#include <xrpl/basics/Number.h>
14#include <xrpl/basics/base_uint.h>
15#include <xrpl/basics/chrono.h>
16#include <xrpl/beast/unit_test/suite.h>
17#include <xrpl/beast/utility/Journal.h>
18#include <xrpl/beast/utility/Zero.h>
19#include <xrpl/ledger/ApplyView.h>
20#include <xrpl/ledger/OpenView.h>
21#include <xrpl/ledger/helpers/AccountRootHelpers.h>
22#include <xrpl/ledger/helpers/DirectoryHelpers.h>
23#include <xrpl/protocol/AccountID.h>
24#include <xrpl/protocol/Feature.h>
25#include <xrpl/protocol/Indexes.h>
26#include <xrpl/protocol/Issue.h>
27#include <xrpl/protocol/Keylet.h>
28#include <xrpl/protocol/LedgerFormats.h>
29#include <xrpl/protocol/MPTIssue.h>
30#include <xrpl/protocol/Protocol.h>
31#include <xrpl/protocol/Rules.h>
32#include <xrpl/protocol/SField.h>
33#include <xrpl/protocol/STAmount.h>
34#include <xrpl/protocol/STLedgerEntry.h>
35#include <xrpl/protocol/STObject.h>
36#include <xrpl/protocol/STTx.h>
37#include <xrpl/protocol/SeqProxy.h>
38#include <xrpl/protocol/TER.h>
39#include <xrpl/protocol/TxFlags.h>
40#include <xrpl/protocol/TxFormats.h>
41#include <xrpl/protocol/UintTypes.h>
42#include <xrpl/protocol/XRPAmount.h>
43#include <xrpl/protocol/jss.h>
44#include <xrpl/tx/ApplyContext.h>
45#include <xrpl/tx/Transactor.h>
46#include <xrpl/tx/applySteps.h>
47#include <xrpl/tx/invariants/VaultInvariant.h>
48
49#include <array>
50#include <chrono>
51#include <cstdint>
52#include <functional>
53#include <initializer_list>
54#include <memory>
55#include <optional>
56#include <string>
57#include <tuple>
58#include <utility>
59#include <vector>
60
61namespace xrpl::test {
62
64{
65 FeatureBitset const all_{test::jtx::testableAmendments() | featureLendingProtocolV1_2};
66
67 void
68 testVault() // NOLINT(readability-function-size)
69 {
70 using namespace test::jtx;
71
72 struct AccountAmount
73 {
74 AccountID account;
75 int amount;
76 };
77 // Parameters for a synthetic loan object created alongside a vault
78 // adjustment. The interest due booked to the vault is
79 // totalValueOutstanding - principalOutstanding - managementFeeOutstanding.
80 struct LoanParams
81 {
82 int principalOutstanding = 0;
83 int totalValueOutstanding = 0;
84 int managementFeeOutstanding = 0;
85 AccountID borrower = beast::kZero;
86 // Broker the created loan references. Left unset when the test does
87 // not depend on the broker resolving to a real ledger entry.
88 UInt256 brokerKey = beast::kZero;
89 };
90 struct Adjustments
91 {
92 // NOLINTBEGIN(readability-redundant-member-init)
93 std::optional<int> assetsTotal = std::nullopt;
94 std::optional<int> assetsAvailable = std::nullopt;
95 std::optional<int> lossUnrealized = std::nullopt;
96 std::optional<int> assetsMaximum = std::nullopt;
97 std::optional<int> sharesTotal = std::nullopt;
98 std::optional<int> vaultAssets = std::nullopt;
99 std::optional<AccountAmount> accountAssets = std::nullopt;
100 std::optional<AccountAmount> accountShares = std::nullopt;
101 std::optional<LoanParams> createLoan = std::nullopt;
102 // Number of loan objects to create (only used when createLoan is
103 // set); a valid loan set creates exactly one.
104 int loanCount = 1;
105 // NOLINTEND(readability-redundant-member-init)
106 };
107 constexpr auto kAdjust = [&](ApplyView& ac, xrpl::Keylet keylet, Adjustments args) {
108 // Avoid uint64 + negative-int wrap (flagged by UBSan
109 // unsigned-integer-overflow) when adjusting UINT64 fields.
110 auto const addSigned = [](std::uint64_t current, int adj) -> std::uint64_t {
111 return adj >= 0 //
112 ? current + static_cast<std::uint64_t>(adj)
113 : current - static_cast<std::uint64_t>(-adj);
114 };
115 auto const sleVault = ac.peek(keylet);
116 if (!sleVault)
117 return false;
118
119 auto const mptIssuanceID = (*sleVault)[sfShareMPTID];
120 auto const sleShares = ac.peek(keylet::mptokenIssuance(mptIssuanceID));
121 if (!sleShares)
122 return false;
123
124 // These two fields are adjusted in absolute terms
125 if (args.lossUnrealized)
126 (*sleVault)[sfLossUnrealized] = *args.lossUnrealized;
127 if (args.assetsMaximum)
128 (*sleVault)[sfAssetsMaximum] = *args.assetsMaximum;
129
130 // Remaining fields are adjusted in terms of difference
131 if (args.assetsTotal)
132 (*sleVault)[sfAssetsTotal] = *(*sleVault)[sfAssetsTotal] + *args.assetsTotal;
133 if (args.assetsAvailable)
134 {
135 (*sleVault)[sfAssetsAvailable] =
136 *(*sleVault)[sfAssetsAvailable] + *args.assetsAvailable;
137 }
138 ac.update(sleVault);
139
140 if (args.sharesTotal)
141 {
142 (*sleShares)[sfOutstandingAmount] =
143 addSigned(*(*sleShares)[sfOutstandingAmount], *args.sharesTotal);
144 ac.update(sleShares);
145 }
146
147 auto const assets = *(*sleVault)[sfAsset];
148 auto const pseudoId = *(*sleVault)[sfAccount];
149 if (args.vaultAssets)
150 {
151 if (assets.native())
152 {
153 auto const slePseudoAccount = ac.peek(keylet::account(pseudoId));
154 if (!slePseudoAccount)
155 return false;
156 (*slePseudoAccount)[sfBalance] =
157 *(*slePseudoAccount)[sfBalance] + *args.vaultAssets;
158 ac.update(slePseudoAccount);
159 }
160 else if (assets.holds<MPTIssue>())
161 {
162 auto const mptId = assets.get<MPTIssue>().getMptID();
163 auto const sleMPToken = ac.peek(keylet::mptoken(mptId, pseudoId));
164 if (!sleMPToken)
165 return false;
166 (*sleMPToken)[sfMPTAmount] =
167 addSigned(*(*sleMPToken)[sfMPTAmount], *args.vaultAssets);
168 ac.update(sleMPToken);
169 }
170 else
171 {
172 return false; // Not supporting testing with IOU
173 }
174 }
175
176 if (args.accountAssets)
177 {
178 auto const& pair = *args.accountAssets;
179 if (assets.native())
180 {
181 auto const sleAccount = ac.peek(keylet::account(pair.account));
182 if (!sleAccount)
183 return false;
184 (*sleAccount)[sfBalance] = *(*sleAccount)[sfBalance] + pair.amount;
185 ac.update(sleAccount);
186 }
187 else if (assets.holds<MPTIssue>())
188 {
189 auto const mptID = assets.get<MPTIssue>().getMptID();
190 auto const sleMPToken = ac.peek(keylet::mptoken(mptID, pair.account));
191 if (!sleMPToken)
192 return false;
193 (*sleMPToken)[sfMPTAmount] =
194 addSigned(*(*sleMPToken)[sfMPTAmount], pair.amount);
195 ac.update(sleMPToken);
196 }
197 else
198 {
199 return false; // Not supporting testing with IOU
200 }
201 }
202
203 if (args.accountShares)
204 {
205 auto const& pair = *args.accountShares;
206 auto const sleMPToken = ac.peek(keylet::mptoken(mptIssuanceID, pair.account));
207 if (!sleMPToken)
208 return false;
209 (*sleMPToken)[sfMPTAmount] = addSigned(*(*sleMPToken)[sfMPTAmount], pair.amount);
210 ac.update(sleMPToken);
211 }
212
213 if (args.createLoan)
214 {
215 auto const& lp = *args.createLoan;
216 bool const anyOutstanding = lp.principalOutstanding != 0 ||
217 lp.totalValueOutstanding != 0 || lp.managementFeeOutstanding != 0;
218 // The vault key stands in for an unset broker: it keeps the loan
219 // keylet distinct per vault while resolving to no broker.
220 UInt256 const brokerKey = lp.brokerKey != beast::kZero ? lp.brokerKey : keylet.key;
221 for (std::uint32_t seq = 1; seq <= static_cast<std::uint32_t>(args.loanCount);
222 ++seq)
223 {
224 auto const sleLoan = makeLoanSle(brokerKey, seq, lp.borrower);
225 sleLoan->at(sfPrincipalOutstanding) = Number(lp.principalOutstanding);
226 sleLoan->at(sfTotalValueOutstanding) = Number(lp.totalValueOutstanding);
227 sleLoan->at(sfManagementFeeOutstanding) = Number(lp.managementFeeOutstanding);
228 sleLoan->setFieldU32(sfPaymentRemaining, anyOutstanding ? 1 : 0);
229 ac.insert(sleLoan);
230 }
231 }
232 return true;
233 };
234
235 static constexpr auto kArgs = [](AccountID id, int adjustment, auto fn) -> Adjustments {
236 Adjustments sample = {
237 .assetsTotal = adjustment,
238 .assetsAvailable = adjustment,
239 .lossUnrealized = 0,
240 .sharesTotal = adjustment,
241 .vaultAssets = adjustment,
242 .accountAssets = //
243 AccountAmount{.account = id, .amount = -adjustment},
244 .accountShares = //
245 AccountAmount{.account = id, .amount = adjustment},
246 };
247 fn(sample);
248 return sample;
249 };
250
251 Account const a3{"A3"};
252 Account const a4{"A4"};
253 auto const precloseXrp = [&](Account const& a1,
254 Account const& a2,
255 Env& env,
256 VaultVersion version = VaultVersion::CashBasis) -> bool {
257 env.fund(XRP(1000), a3, a4);
258 Vault const vault{env};
259 auto [tx, keylet] = vault.create({.owner = a1, .asset = xrpIssue()});
260 env(tx);
261 env(vault.deposit({.depositor = a1, .id = keylet.key, .amount = XRP(10)}));
262 env(vault.deposit({.depositor = a2, .id = keylet.key, .amount = XRP(10)}));
263 env(vault.deposit({.depositor = a3, .id = keylet.key, .amount = XRP(10)}));
264 return true;
265 };
266
267 auto const createClosedXrpBroker =
268 [&](Account const& owner, Env& env) -> std::optional<std::pair<Keylet, Keylet>> {
269 PrettyAsset const xrpAsset{xrpIssue(), 1'000'000};
270 auto const brokerKeylet = createLoanBroker(owner, env, xrpAsset);
271 auto const sleBroker = env.le(brokerKeylet);
272 if (!BEAST_EXPECT(sleBroker))
273 return std::nullopt;
274 auto const vaultKeylet = keylet::vault(sleBroker->at(sfVaultID));
275 env.close(std::chrono::seconds{61});
276 return std::pair{vaultKeylet, brokerKeylet};
277 };
278
279 testcase << "Vault general checks";
281 {"vault deletion succeeded without deleting a vault"},
282 [&](Account const& a1, Account const& a2, ApplyContext& ac) {
283 auto const keylet = keylet::vault(a1.id(), SeqProxy::rawSequence(ac.view().seq()));
284 auto const sleVault = ac.view().peek(keylet);
285 if (!sleVault)
286 return false;
287 ac.view().update(sleVault);
288 return true;
289 },
290 XRPAmount{},
291 STTx{ttVAULT_DELETE, [](STObject&) {}},
293 [&](Account const& a1, Account const& a2, Env& env) {
294 Vault const vault{env};
295 auto [tx, _] = vault.create({.owner = a1, .asset = xrpIssue()});
296 env(tx);
297 return true;
298 });
299
301 {
302 "vault updated by a wrong transaction type",
303 "deleted Vault without deleting its pseudo-account",
304 },
305 [&](Account const& a1, Account const& a2, ApplyContext& ac) {
306 auto const keylet = keylet::vault(a1.id(), SeqProxy::rawSequence(ac.view().seq()));
307 auto const sleVault = ac.view().peek(keylet);
308 if (!sleVault)
309 return false;
310 ac.view().erase(sleVault);
311 return true;
312 },
313 XRPAmount{},
314 STTx{ttPAYMENT, [](STObject&) {}},
316 [&](Account const& a1, Account const& a2, Env& env) {
317 Vault const vault{env};
318 auto [tx, _] = vault.create({.owner = a1, .asset = xrpIssue()});
319 env(tx);
320 return true;
321 });
322
324 {"vault updated by a wrong transaction type"},
325 [&](Account const& a1, Account const& a2, ApplyContext& ac) {
326 auto const keylet = keylet::vault(a1.id(), SeqProxy::rawSequence(ac.view().seq()));
327 auto const sleVault = ac.view().peek(keylet);
328 if (!sleVault)
329 return false;
330 ac.view().update(sleVault);
331 return true;
332 },
333 XRPAmount{},
334 STTx{ttPAYMENT, [](STObject&) {}},
336 [&](Account const& a1, Account const& a2, Env& env) {
337 Vault const vault{env};
338 auto [tx, _] = vault.create({.owner = a1, .asset = xrpIssue()});
339 env(tx);
340 return true;
341 });
342
344 {"vault updated by a wrong transaction type"},
345 [&](Account const& a1, Account const& a2, ApplyContext& ac) {
346 auto const sequence = ac.view().seq();
347 auto const vaultKeylet = keylet::vault(a1.id(), SeqProxy::rawSequence(sequence));
348 auto const sleVault = std::make_shared<SLE>(vaultKeylet);
349 auto const vaultPage = ac.view().dirInsert(
350 keylet::ownerDir(a1.id()), sleVault->key(), describeOwnerDir(a1.id()));
351 sleVault->setFieldU64(sfOwnerNode, *vaultPage);
352 sleVault->setAccountID(sfAccount, a1.id());
353 ac.view().insert(sleVault);
354 return true;
355 },
356 XRPAmount{},
357 STTx{ttPAYMENT, [](STObject&) {}},
359
361 {
362 "vault deleted by a wrong transaction type",
363 "deleted Vault without deleting its pseudo-account",
364 },
365 [&](Account const& a1, Account const& a2, ApplyContext& ac) {
366 auto const keylet = keylet::vault(a1.id(), SeqProxy::rawSequence(ac.view().seq()));
367 auto const sleVault = ac.view().peek(keylet);
368 if (!sleVault)
369 return false;
370 ac.view().erase(sleVault);
371 return true;
372 },
373 XRPAmount{},
374 STTx{ttVAULT_SET, [](STObject&) {}},
376 [&](Account const& a1, Account const& a2, Env& env) {
377 Vault const vault{env};
378 auto [tx, _] = vault.create({.owner = a1, .asset = xrpIssue()});
379 env(tx);
380 return true;
381 });
382
384 {
385 "vault operation updated more than single vault",
386 "deleted Vault without deleting its pseudo-account",
387 },
388 [&](Account const& a1, Account const& a2, ApplyContext& ac) {
389 {
390 auto const keylet =
391 keylet::vault(a1.id(), SeqProxy::rawSequence(ac.view().seq()));
392 auto const sleVault = ac.view().peek(keylet);
393 if (!sleVault)
394 return false;
395 ac.view().erase(sleVault);
396 }
397 {
398 auto const keylet =
399 keylet::vault(a2.id(), SeqProxy::rawSequence(ac.view().seq()));
400 auto const sleVault = ac.view().peek(keylet);
401 if (!sleVault)
402 return false;
403 ac.view().erase(sleVault);
404 }
405 return true;
406 },
407 XRPAmount{},
408 STTx{ttVAULT_DELETE, [](STObject&) {}},
410 [&](Account const& a1, Account const& a2, Env& env) {
411 Vault const vault{env};
412 {
413 auto [tx, _] = vault.create({.owner = a1, .asset = xrpIssue()});
414 env(tx);
415 }
416 {
417 auto [tx, _] = vault.create({.owner = a2, .asset = xrpIssue()});
418 env(tx);
419 }
420 return true;
421 });
422
424 {"vault operation updated more than single vault"},
425 [&](Account const& a1, Account const& a2, ApplyContext& ac) {
426 auto const sequence = ac.view().seq();
427 auto const insertVault = [&](Account const a) {
428 auto const vaultKeylet = keylet::vault(a.id(), SeqProxy::rawSequence(sequence));
429 auto const sleVault = std::make_shared<SLE>(vaultKeylet);
430 auto const vaultPage = ac.view().dirInsert(
431 keylet::ownerDir(a.id()), sleVault->key(), describeOwnerDir(a.id()));
432 sleVault->setFieldU64(sfOwnerNode, *vaultPage);
433 sleVault->setAccountID(sfAccount, a.id());
434 ac.view().insert(sleVault);
435 };
436 insertVault(a1);
437 insertVault(a2);
438 return true;
439 },
440 XRPAmount{},
441 STTx{ttVAULT_CREATE, [](STObject&) {}},
443
445 {
446 "deleted vault must also delete shares",
447 "deleted Vault without deleting its pseudo-account",
448 },
449 [&](Account const& a1, Account const& a2, ApplyContext& ac) {
450 auto const keylet = keylet::vault(a1.id(), SeqProxy::rawSequence(ac.view().seq()));
451 auto const sleVault = ac.view().peek(keylet);
452 if (!sleVault)
453 return false;
454 ac.view().erase(sleVault);
455 return true;
456 },
457 XRPAmount{},
458 STTx{ttVAULT_DELETE, [](STObject&) {}},
460 [&](Account const& a1, Account const& a2, Env& env) {
461 Vault const vault{env};
462 auto [tx, _] = vault.create({.owner = a1, .asset = xrpIssue()});
463 env(tx);
464 return true;
465 });
466
468 {
469 "deleted vault must have no shares outstanding",
470 "deleted vault must have no assets outstanding",
471 "deleted vault must have no assets available",
472 },
473 [&](Account const& a1, Account const& a2, ApplyContext& ac) {
474 auto const keylet = keylet::vault(a1.id(), SeqProxy::rawSequence(ac.view().seq()));
475 auto const sleVault = ac.view().peek(keylet);
476 if (!sleVault)
477 return false;
478 auto const sleShares =
479 ac.view().peek(keylet::mptokenIssuance((*sleVault)[sfShareMPTID]));
480 if (!sleShares)
481 return false;
482 ac.view().erase(sleVault);
483 ac.view().erase(sleShares);
484 return true;
485 },
486 XRPAmount{},
487 STTx{ttVAULT_DELETE, [](STObject&) {}},
489 [&](Account const& a1, Account const& a2, Env& env) {
490 Vault const vault{env};
491 auto [tx, keylet] = vault.create({.owner = a1, .asset = xrpIssue()});
492 env(tx);
493 env(vault.deposit({.depositor = a1, .id = keylet.key, .amount = XRP(10)}));
494 return true;
495 });
496
498 {"vault operation succeeded without modifying a vault"},
499 [&](Account const& a1, Account const& a2, ApplyContext& ac) {
500 auto const keylet = keylet::vault(a1.id(), SeqProxy::rawSequence(ac.view().seq()));
501 auto const sleVault = ac.view().peek(keylet);
502 if (!sleVault)
503 return false;
504 auto const sleShares =
505 ac.view().peek(keylet::mptokenIssuance((*sleVault)[sfShareMPTID]));
506 if (!sleShares)
507 return false;
508 // Note, such an "orphaned" update of MPT issuance attached to a
509 // vault is invalid; ttVAULT_SET must also update Vault object.
510 sleShares->setFieldH256(sfDomainID, UInt256(13));
511 ac.view().update(sleShares);
512 return true;
513 },
514 XRPAmount{},
515 STTx{ttVAULT_SET, [](STObject& tx) {}},
517 precloseXrp,
519
521 {"vault operation succeeded without modifying a vault"},
522 [&](Account const& a1, Account const& a2, ApplyContext& ac) { return true; },
523 XRPAmount{},
524 STTx{ttVAULT_CREATE, [](STObject&) {}},
526 [&](Account const& a1, Account const& a2, Env& env) {
527 Vault const vault{env};
528 auto [tx, _] = vault.create({.owner = a1, .asset = xrpIssue()});
529 env(tx);
530 return true;
531 });
532
534 {"vault operation succeeded without modifying a vault"},
535 [&](Account const& a1, Account const& a2, ApplyContext& ac) { return true; },
536 XRPAmount{},
537 STTx{ttVAULT_DEPOSIT, [](STObject&) {}},
539 [&](Account const& a1, Account const& a2, Env& env) {
540 Vault const vault{env};
541 auto [tx, _] = vault.create({.owner = a1, .asset = xrpIssue()});
542 env(tx);
543 return true;
544 });
545
547 {"vault operation succeeded without modifying a vault"},
548 [&](Account const& a1, Account const& a2, ApplyContext& ac) { return true; },
549 XRPAmount{},
550 STTx{ttVAULT_WITHDRAW, [](STObject&) {}},
552 [&](Account const& a1, Account const& a2, Env& env) {
553 Vault const vault{env};
554 auto [tx, _] = vault.create({.owner = a1, .asset = xrpIssue()});
555 env(tx);
556 return true;
557 });
558
560 {"vault operation succeeded without modifying a vault"},
561 [&](Account const& a1, Account const& a2, ApplyContext& ac) { return true; },
562 XRPAmount{},
563 STTx{ttVAULT_CLAWBACK, [](STObject&) {}},
565 [&](Account const& a1, Account const& a2, Env& env) {
566 Vault const vault{env};
567 auto [tx, _] = vault.create({.owner = a1, .asset = xrpIssue()});
568 env(tx);
569 return true;
570 });
571
573 {"vault operation succeeded without modifying a vault"},
574 [&](Account const& a1, Account const& a2, ApplyContext& ac) { return true; },
575 XRPAmount{},
576 STTx{ttVAULT_DELETE, [](STObject&) {}},
578 [&](Account const& a1, Account const& a2, Env& env) {
579 Vault const vault{env};
580 auto [tx, _] = vault.create({.owner = a1, .asset = xrpIssue()});
581 env(tx);
582 return true;
583 });
584
586 {"updated vault must have shares"},
587 [&](Account const& a1, Account const& a2, ApplyContext& ac) {
588 auto const keylet = keylet::vault(a1.id(), SeqProxy::rawSequence(ac.view().seq()));
589 auto const sleVault = ac.view().peek(keylet);
590 if (!sleVault)
591 return false;
592 (*sleVault)[sfAssetsMaximum] = 200;
593 ac.view().update(sleVault);
594
595 auto const sleShares =
596 ac.view().peek(keylet::mptokenIssuance((*sleVault)[sfShareMPTID]));
597 if (!sleShares)
598 return false;
599 ac.view().erase(sleShares);
600 return true;
601 },
602 XRPAmount{},
603 STTx{ttVAULT_SET, [](STObject&) {}},
605 [&](Account const& a1, Account const& a2, Env& env) {
606 Vault const vault{env};
607 auto [tx, _] = vault.create({.owner = a1, .asset = xrpIssue()});
608 env(tx);
609 return true;
610 });
611
613 {
614 "vault operation succeeded without updating shares",
615 "assets available must not be greater than assets outstanding",
616 },
617 [&](Account const& a1, Account const& a2, ApplyContext& ac) {
618 auto const keylet = keylet::vault(a1.id(), SeqProxy::rawSequence(ac.view().seq()));
619 auto const sleVault = ac.view().peek(keylet);
620 if (!sleVault)
621 return false;
622 (*sleVault)[sfAssetsTotal] = 9;
623 ac.view().update(sleVault);
624 return true;
625 },
626 XRPAmount{},
627 STTx{ttVAULT_WITHDRAW, [](STObject&) {}},
629 [&](Account const& a1, Account const& a2, Env& env) {
630 Vault const vault{env};
631 auto [tx, keylet] = vault.create({.owner = a1, .asset = xrpIssue()});
632 env(tx);
633 env(vault.deposit({.depositor = a1, .id = keylet.key, .amount = XRP(10)}));
634 return true;
635 });
636
638 {
639 "set must not change assets outstanding",
640 "set must not change assets available",
641 "set must not change shares outstanding",
642 "set must not change vault balance",
643 "assets available must not be negative",
644 "assets available must not be greater than assets outstanding",
645 "assets outstanding must not be negative",
646 },
647 [&](Account const& a1, Account const& a2, ApplyContext& ac) {
648 auto const keylet = keylet::vault(a1.id(), SeqProxy::rawSequence(ac.view().seq()));
649 auto const sleVault = ac.view().peek(keylet);
650 if (!sleVault)
651 return false;
652 auto const slePseudoAccount =
653 ac.view().peek(keylet::account(*(*sleVault)[sfAccount]));
654 if (!slePseudoAccount)
655 return false;
656 (*slePseudoAccount)[sfBalance] = *(*slePseudoAccount)[sfBalance] - 10;
657 ac.view().update(slePseudoAccount);
658
659 // Move 10 drops to A4 to enforce total XRP balance
660 auto const sleA4 = ac.view().peek(keylet::account(a4.id()));
661 if (!sleA4)
662 return false;
663 (*sleA4)[sfBalance] = *(*sleA4)[sfBalance] + 10;
664 ac.view().update(sleA4);
665
666 return kAdjust(ac.view(), keylet, kArgs(a2.id(), 0, [&](Adjustments& sample) {
667 sample.assetsAvailable = (kDropsPerXrp * -100).value();
668 sample.assetsTotal = (kDropsPerXrp * -200).value();
669 sample.sharesTotal = -1;
670 }));
671 },
672 XRPAmount{},
673 STTx{ttVAULT_SET, [](STObject& tx) {}},
675 precloseXrp,
677
678 // Under featureLendingProtocolV1_1 the immutability of sfAsset, sfAccount,
679 // sfShareMPTID and sfLEVersion is enforced by NoModifiedUnmodifiableFields.
681 {"changed an unchangeable field"},
682 [&](Account const& a1, Account const& a2, ApplyContext& ac) {
683 auto const keylet = keylet::vault(a1.id(), SeqProxy::rawSequence(ac.view().seq()));
684 auto const sleVault = ac.view().peek(keylet);
685 if (!sleVault)
686 return false;
687 sleVault->setFieldIssue(sfAsset, STIssue{sfAsset, MPTIssue(MPTID(42))});
688 ac.view().update(sleVault);
689 return true;
690 },
691 XRPAmount{},
692 STTx{ttVAULT_SET, [](STObject& tx) {}},
694 precloseXrp);
695
697 {"changed an unchangeable field"},
698 [&](Account const& a1, Account const& a2, ApplyContext& ac) {
699 auto const keylet = keylet::vault(a1.id(), SeqProxy::rawSequence(ac.view().seq()));
700 auto const sleVault = ac.view().peek(keylet);
701 if (!sleVault)
702 return false;
703 sleVault->setAccountID(sfAccount, a2.id());
704 ac.view().update(sleVault);
705 return true;
706 },
707 XRPAmount{},
708 STTx{ttVAULT_SET, [](STObject& tx) {}},
710 precloseXrp);
711
713 {"changed an unchangeable field"},
714 [&](Account const& a1, Account const& a2, ApplyContext& ac) {
715 auto const keylet = keylet::vault(a1.id(), SeqProxy::rawSequence(ac.view().seq()));
716 auto const sleVault = ac.view().peek(keylet);
717 if (!sleVault)
718 return false;
719 (*sleVault)[sfShareMPTID] = MPTID(42);
720 ac.view().update(sleVault);
721 return true;
722 },
723 XRPAmount{},
724 STTx{ttVAULT_SET, [](STObject& tx) {}},
726 precloseXrp);
727
729 {"changed an unchangeable field"},
730 [&](Account const& a1, Account const& a2, ApplyContext& ac) {
731 auto const keylet = keylet::vault(a1.id(), SeqProxy::rawSequence(ac.view().seq()));
732 auto const sleVault = ac.view().peek(keylet);
733 if (!sleVault)
734 return false;
735 (*sleVault)[sfLEVersion] = std::to_underlying(VaultVersion::Legacy);
736 ac.view().update(sleVault);
737 return true;
738 },
739 XRPAmount{},
740 STTx{ttVAULT_SET, [](STObject& tx) {}},
742 [&precloseXrp](Account const& a1, Account const& a2, Env& env) {
743 return precloseXrp(a1, a2, env, VaultVersion::CashBasis);
744 });
745
746 // Pre-featureLendingProtocolV1_1 sfAsset, sfAccount and sfShareMPTID are
747 // guarded by ValidVault instead, so both paths need coverage. ValidVault
748 // returns early once the result is already tec, hence no escalation to
749 // tef on the second pass.
750 auto const preLendingV11Amendments = all_ - featureLendingProtocolV1_1;
752 makeEnv(preLendingV11Amendments),
753 {"violation of vault immutable data"},
754 [&](Account const& a1, Account const& a2, ApplyContext& ac) {
755 auto const keylet = keylet::vault(a1.id(), SeqProxy::rawSequence(ac.view().seq()));
756 auto const sleVault = ac.view().peek(keylet);
757 if (!sleVault)
758 return false;
759 sleVault->setFieldIssue(sfAsset, STIssue{sfAsset, MPTIssue(MPTID(42))});
760 ac.view().update(sleVault);
761 return true;
762 },
763 XRPAmount{},
764 STTx{ttVAULT_SET, [](STObject& tx) {}},
766 precloseXrp);
767
769 makeEnv(preLendingV11Amendments),
770 {"violation of vault immutable data"},
771 [&](Account const& a1, Account const& a2, ApplyContext& ac) {
772 auto const keylet = keylet::vault(a1.id(), SeqProxy::rawSequence(ac.view().seq()));
773 auto const sleVault = ac.view().peek(keylet);
774 if (!sleVault)
775 return false;
776 sleVault->setAccountID(sfAccount, a2.id());
777 ac.view().update(sleVault);
778 return true;
779 },
780 XRPAmount{},
781 STTx{ttVAULT_SET, [](STObject& tx) {}},
783 precloseXrp);
784
786 makeEnv(preLendingV11Amendments),
787 {"violation of vault immutable data"},
788 [&](Account const& a1, Account const& a2, ApplyContext& ac) {
789 auto const keylet = keylet::vault(a1.id(), SeqProxy::rawSequence(ac.view().seq()));
790 auto const sleVault = ac.view().peek(keylet);
791 if (!sleVault)
792 return false;
793 (*sleVault)[sfShareMPTID] = MPTID(42);
794 ac.view().update(sleVault);
795 return true;
796 },
797 XRPAmount{},
798 STTx{ttVAULT_SET, [](STObject& tx) {}},
800 precloseXrp);
801
803 {
804 "vault transaction must not change loss unrealized",
805 "set must not change assets outstanding",
806 },
807 [&](Account const& a1, Account const& a2, ApplyContext& ac) {
808 auto const keylet = keylet::vault(a1.id(), SeqProxy::rawSequence(ac.view().seq()));
809 return kAdjust(ac.view(), keylet, kArgs(a2.id(), 0, [&](Adjustments& sample) {
810 sample.lossUnrealized = 13;
811 sample.assetsTotal = 20;
812 }));
813 },
814 XRPAmount{},
815 STTx{ttVAULT_SET, [](STObject& tx) {}},
817 precloseXrp,
819
821 {
822 "loss unrealized must not exceed the difference "
823 "between assets outstanding and available",
824 "vault transaction must not change loss unrealized",
825 },
826 [&](Account const& a1, Account const& a2, ApplyContext& ac) {
827 auto const keylet = keylet::vault(a1.id(), SeqProxy::rawSequence(ac.view().seq()));
828 return kAdjust(ac.view(), keylet, kArgs(a2.id(), 100, [&](Adjustments& sample) {
829 sample.lossUnrealized = 13;
830 }));
831 },
832 XRPAmount{},
833 STTx{
834 ttVAULT_DEPOSIT, [](STObject& tx) { tx.setFieldAmount(sfAmount, XRPAmount(200)); }},
836 precloseXrp,
838
839 // A negative loss unrealized must trip the invariant. ttLOAN_MANAGE is
840 // allowed to change loss unrealized, so it isolates this check from the
841 // "must not change loss unrealized" invariant. Gated behind
842 // fixCleanup3_4_0 (see below).
844 {"loss unrealized must not be negative"},
845 [&](Account const& a1, Account const& a2, ApplyContext& ac) {
846 auto const keylet = keylet::vault(a1.id(), SeqProxy::rawSequence(ac.view().seq()));
847 return kAdjust(ac.view(), keylet, kArgs(a2.id(), 0, [&](Adjustments& sample) {
848 sample.lossUnrealized = -1;
849 }));
850 },
851 XRPAmount{},
852 STTx{ttLOAN_MANAGE, [](STObject& tx) {}},
854 precloseXrp,
856
857 // Without fixCleanup3_4_0 the same state must NOT trip the invariant,
858 // preserving pre-amendment behavior (no fork risk). Also remove
859 // featureLendingProtocolV1_1 so finalizeLoanManage's stricter checks
860 // (exactly one loan touched) do not fire from a bare vault mutation
861 // that does not touch a loan.
863 makeEnv(all_ - fixCleanup3_4_0 - featureLendingProtocolV1_1),
864 {},
865 [&](Account const& a1, Account const& a2, ApplyContext& ac) {
866 auto const keylet = keylet::vault(a1.id(), SeqProxy::rawSequence(ac.view().seq()));
867 return kAdjust(ac.view(), keylet, kArgs(a2.id(), 0, [&](Adjustments& sample) {
868 sample.lossUnrealized = -1;
869 }));
870 },
871 XRPAmount{},
872 STTx{ttLOAN_MANAGE, [](STObject& tx) {}},
874 precloseXrp,
876
878 {"set assets outstanding must not exceed assets maximum"},
879 [&](Account const& a1, Account const& a2, ApplyContext& ac) {
880 auto const keylet = keylet::vault(a1.id(), SeqProxy::rawSequence(ac.view().seq()));
881 return kAdjust(ac.view(), keylet, kArgs(a2.id(), 0, [&](Adjustments& sample) {
882 sample.assetsMaximum = 1;
883 }));
884 },
885 XRPAmount{},
886 STTx{ttVAULT_SET, [](STObject& tx) {}},
888 precloseXrp,
890
891 // The cap check has two post-fixCleanup3_4_0 triggers: the transaction
892 // supplied sfAssetsMaximum, or the cap changed. The case above covers
893 // the cap-changed one (its ttVAULT_SET carries no fields). This covers
894 // the other: the cap is left alone at 30 XRP and the transaction
895 // carries sfAssetsMaximum, so only the isFieldPresent disjunct can
896 // fire. AssetsTotal is pushed past the cap here rather than in
897 // preclose because VaultSet::doApply refuses to set a cap below
898 // AssetsTotal, so the over-cap state is only reachable by fabrication.
899 // Raising AssetsTotal also trips the "must not change assets
900 // outstanding" check, hence two expected messages.
901 Number const vaultCap = XRP(30).number();
903 {
904 "set must not change assets outstanding",
905 "set assets outstanding must not exceed assets maximum",
906 },
907 [&](Account const& a1, Account const& a2, ApplyContext& ac) {
908 auto const keylet = keylet::vault(a1.id(), SeqProxy::rawSequence(ac.view().seq()));
909 return kAdjust(ac.view(), keylet, kArgs(a2.id(), 0, [&](Adjustments& sample) {
910 sample.assetsTotal = XRP(1).value().xrp().drops();
911 }));
912 },
913 XRPAmount{},
914 STTx{ttVAULT_SET, [&](STObject& tx) { tx[sfAssetsMaximum] = vaultCap; }},
916 [&](Account const& a1, Account const& a2, Env& env) -> bool {
917 env.fund(XRP(1000), a3, a4);
918 Vault const vault{env};
919 auto [tx, keylet] = vault.create({.owner = a1, .asset = xrpIssue()});
920 tx[sfAssetsMaximum] = vaultCap;
921 env(tx);
922 env(vault.deposit({.depositor = a1, .id = keylet.key, .amount = XRP(10)}));
923 env(vault.deposit({.depositor = a2, .id = keylet.key, .amount = XRP(10)}));
924 env(vault.deposit({.depositor = a3, .id = keylet.key, .amount = XRP(10)}));
925 return true;
926 },
928
930 {"assets maximum must not be negative"},
931 [&](Account const& a1, Account const& a2, ApplyContext& ac) {
932 auto const keylet = keylet::vault(a1.id(), SeqProxy::rawSequence(ac.view().seq()));
933 return kAdjust(ac.view(), keylet, kArgs(a2.id(), 0, [&](Adjustments& sample) {
934 sample.assetsMaximum = -1;
935 }));
936 },
937 XRPAmount{},
938 STTx{ttVAULT_SET, [](STObject& tx) {}},
940 precloseXrp,
942
944 {
945 "set must not change shares outstanding",
946 "updated zero sized vault must have no assets outstanding",
947 "updated zero sized vault must have no assets available",
948 },
949 [&](Account const& a1, Account const& a2, ApplyContext& ac) {
950 auto const keylet = keylet::vault(a1.id(), SeqProxy::rawSequence(ac.view().seq()));
951 auto const sleVault = ac.view().peek(keylet);
952 if (!sleVault)
953 return false;
954 ac.view().update(sleVault);
955 auto const sleShares =
956 ac.view().peek(keylet::mptokenIssuance((*sleVault)[sfShareMPTID]));
957 if (!sleShares)
958 return false;
959 (*sleShares)[sfOutstandingAmount] = 0;
960 ac.view().update(sleShares);
961 return true;
962 },
963 XRPAmount{},
964 STTx{ttVAULT_SET, [](STObject& tx) {}},
966 precloseXrp,
968
970 {"updated shares must not exceed maximum"},
971 [&](Account const& a1, Account const& a2, ApplyContext& ac) {
972 auto const keylet = keylet::vault(a1.id(), SeqProxy::rawSequence(ac.view().seq()));
973 auto const sleVault = ac.view().peek(keylet);
974 if (!sleVault)
975 return false;
976 auto const sleShares =
977 ac.view().peek(keylet::mptokenIssuance((*sleVault)[sfShareMPTID]));
978 if (!sleShares)
979 return false;
980 (*sleShares)[sfMaximumAmount] = 10;
981 ac.view().update(sleShares);
982
983 return kAdjust(ac.view(), keylet, kArgs(a2.id(), 10, [](Adjustments&) {}));
984 },
985 XRPAmount{},
986 STTx{ttVAULT_DEPOSIT, [](STObject&) {}},
988 precloseXrp,
990
992 {"updated shares must not exceed maximum"},
993 [&](Account const& a1, Account const& a2, ApplyContext& ac) {
994 auto const keylet = keylet::vault(a1.id(), SeqProxy::rawSequence(ac.view().seq()));
995 kAdjust(ac.view(), keylet, kArgs(a2.id(), 10, [](Adjustments&) {}));
996
997 auto const sleVault = ac.view().peek(keylet);
998 if (!sleVault)
999 return false;
1000 auto const sleShares =
1001 ac.view().peek(keylet::mptokenIssuance((*sleVault)[sfShareMPTID]));
1002 if (!sleShares)
1003 return false;
1004 (*sleShares)[sfOutstandingAmount] = kMaxMpTokenAmount + 1;
1005 ac.view().update(sleShares);
1006 return true;
1007 },
1008 XRPAmount{},
1009 STTx{ttVAULT_DEPOSIT, [](STObject&) {}},
1011 precloseXrp,
1013
1014 // ttLOAN_SET pre-featureLendingProtocolV1_1: finalizeLoanSet short-
1015 // circuits and returns success without inspecting the loan or the
1016 // vault. The same state that trips the principal-outstanding check
1017 // under V1_1 must be silently accepted here.
1018 //
1019 // V1_2 is disabled too: it alone makes VaultCreate pick FixedPrecision,
1020 // whose AssetsTotal-sync invariant would fire on this scenario.
1022 makeEnv(all_ - featureLendingProtocolV1_1 - featureLendingProtocolV1_2),
1023 {},
1024 [&](Account const& a1, Account const& a2, ApplyContext& ac) {
1025 auto const keylet = keylet::vault(a1.id(), SeqProxy::rawSequence(ac.view().seq()));
1026 return kAdjust(
1027 ac.view(),
1028 keylet,
1029 Adjustments{
1030 .assetsAvailable = -200,
1031 .vaultAssets = -200,
1032 .accountAssets = AccountAmount{.account = a2.id(), .amount = 200},
1033 .createLoan =
1034 LoanParams{
1035 .principalOutstanding = 300,
1036 .totalValueOutstanding = 300,
1037 .borrower = a1.id(),
1038 },
1039 });
1040 },
1041 XRPAmount{},
1042 STTx{ttLOAN_SET, [](STObject& tx) { tx.at(sfPrincipalRequested) = Number(200); }},
1044 precloseXrp);
1045
1046 // ttLOAN_MANAGE: a loan is created rather than modified. This object-
1047 // existence rule applies on both invariant passes.
1049 {"Loan created by a transaction other than LoanSet"},
1050 [&](Account const& a1, Account const& a2, ApplyContext& ac) {
1051 auto const keylet = keylet::vault(a1.id(), SeqProxy::rawSequence(ac.view().seq()));
1052 return kAdjust(
1053 ac.view(),
1054 keylet,
1055 Adjustments{
1056 .createLoan =
1057 LoanParams{
1058 .principalOutstanding = 100,
1059 .totalValueOutstanding = 100,
1060 .borrower = a1.id(),
1061 },
1062 });
1063 },
1064 XRPAmount{},
1065 STTx{ttLOAN_MANAGE, [](STObject& tx) { tx.setFieldU32(sfFlags, tfLoanImpair); }},
1067 precloseXrp);
1068
1069 // ttLOAN_MANAGE: loss unrealized driven negative
1070 doInvariantCheck(
1071 {"loss unrealized must not be negative"},
1072 [&](Account const& a1, Account const& a2, ApplyContext& ac) {
1073 auto const keylet = keylet::vault(a1.id(), SeqProxy::rawSequence(ac.view().seq()));
1074 return kAdjust(ac.view(), keylet, Adjustments{.lossUnrealized = -1});
1075 },
1076 XRPAmount{},
1077 STTx{ttLOAN_MANAGE, [](STObject&) {}},
1079 precloseXrp);
1080
1081 // Loan flags may only change under the transaction types that own
1082 // those transitions.
1083 {
1084 struct Case
1085 {
1086 std::uint32_t before;
1087 std::uint32_t after;
1088 std::string expected;
1089 };
1090 auto const cases = std::to_array<Case>({
1091 {
1092 .before = 0,
1093 .after = lsfLoanImpaired,
1094 .expected = "lsfLoanImpaired changed outside LoanManage or LoanPay",
1095 },
1096 {
1097 .before = lsfLoanImpaired,
1098 .after = 0,
1099 .expected = "lsfLoanImpaired changed outside LoanManage or LoanPay",
1100 },
1101 {
1102 .before = 0,
1103 .after = lsfLoanDefault,
1104 .expected = "lsfLoanDefault changed outside LoanManage",
1105 },
1106 });
1107
1108 for (auto const& c : cases)
1109 {
1110 Env env{*this, all_};
1111 Account const a1{"A1"};
1112 Account const a2{"A2"};
1113 env.fund(XRP(1000), a1, a2);
1114 auto const keys = createClosedXrpBroker(a1, env);
1115 if (!keys)
1116 continue;
1117 auto const& brokerKeylet = keys->second;
1118
1119 OpenView ov{*env.current()};
1120 auto const loanKeylet = keylet::loan(brokerKeylet.key, SeqProxy::rawSequence(1));
1121 {
1122 auto const sleLoan = makeLoanSle(brokerKeylet.key, 1, a1.id());
1123 sleLoan->at(sfPrincipalOutstanding) = Number(100);
1124 sleLoan->at(sfTotalValueOutstanding) = Number(150);
1125 sleLoan->setFieldU32(sfPaymentRemaining, 1);
1126 sleLoan->setFieldU32(sfFlags, c.before);
1127 ov.rawInsert(sleLoan);
1128 }
1129
1130 STTx const tx{ttACCOUNT_SET, [](STObject&) {}};
1131 test::StreamSink sink{beast::Severity::Warning};
1132 beast::Journal const jlog{sink};
1133 ApplyContext ac{
1134 env.app(), ov, tx, tesSUCCESS, env.current()->fees().base, TapNone, jlog};
1135 CurrentTransactionRulesGuard const rulesGuard(ov.rules());
1136
1137 auto const sleLoan = ac.view().peek(loanKeylet);
1138 if (!BEAST_EXPECT(sleLoan))
1139 continue;
1140 sleLoan->setFieldU32(sfFlags, c.after);
1141 ac.view().update(sleLoan);
1142
1143 auto transactor = makeTransactor(ac);
1144 if (!BEAST_EXPECT(transactor))
1145 continue;
1146 TER const result = transactor->checkInvariants(
1148 BEAST_EXPECT(result == tecINVARIANT_FAILED);
1149 BEAST_EXPECT(sink.messages().str().contains(c.expected));
1150 }
1151 }
1152
1153 // ttLOAN_MANAGE (default): a defaulted loan atomically enters a
1154 // terminal state, which drops sfNextPaymentDueDate from the ledger
1155 // entry. Seed a loan that already carries lsfLoanDefault so the
1156 // "must newly set" check passes, then leave sfNextPaymentDueDate
1157 // present and non-zero on the after-image; the residual due-date
1158 // check must then fire.
1159 {
1160 Env env{*this, all_};
1161 Account const a1{"A1"};
1162 Account const a2{"A2"};
1163 env.fund(XRP(1000), a1, a2);
1164 BEAST_EXPECT(precloseXrp(a1, a2, env));
1165 env.close();
1166
1167 OpenView ov{*env.current()};
1168
1169 auto const brokerKeylet = keylet::loanBroker(a1.id(), SeqProxy::rawSequence(1));
1170 auto const loanKeylet = keylet::loan(brokerKeylet.key, SeqProxy::rawSequence(1));
1171 // Pre-insert a loan that is not yet defaulted but has a
1172 // NextPaymentDueDate set; the apply-view mutation below flips
1173 // lsfLoanDefault (so the "must newly set" check passes) while
1174 // leaving the due date behind.
1175 {
1176 auto const sleLoan = makeLoanSle(brokerKeylet.key, 1, a2.id());
1177 sleLoan->setFieldU32(sfNextPaymentDueDate, 123);
1178 ov.rawInsert(sleLoan);
1179 }
1180
1181 STTx const tx{
1182 ttLOAN_MANAGE, [](STObject& t) { t.setFieldU32(sfFlags, tfLoanDefault); }};
1183 test::StreamSink sink{beast::Severity::Warning};
1184 beast::Journal const jlog{sink};
1185 ApplyContext ac{
1186 env.app(), ov, tx, tesSUCCESS, env.current()->fees().base, TapNone, jlog};
1187 CurrentTransactionRulesGuard const rulesGuard(ov.rules());
1188
1189 auto const sleLoan = ac.view().peek(loanKeylet);
1190 if (!BEAST_EXPECT(sleLoan))
1191 return;
1192 sleLoan->setFieldU32(sfFlags, lsfLoanDefault);
1193 ac.view().update(sleLoan);
1194
1195 auto transactor = makeTransactor(ac);
1196 if (!BEAST_EXPECT(transactor))
1197 return;
1198 TER const result = transactor->checkInvariants(
1200 BEAST_EXPECT(result == tecINVARIANT_FAILED);
1201 BEAST_EXPECT(sink.messages().str().contains(
1202 "Loan with zero payments must have zero next payment due date"));
1203 }
1204
1205 // ttLOAN_PAY pre-featureLendingProtocolV1_1: finalizeLoanPay short-
1206 // circuits and returns success. The same "no vault balance change"
1207 // state that trips the check under V1_1 must be silently accepted
1208 // here.
1209 doInvariantCheck(
1210 makeEnv(all_ - featureLendingProtocolV1_1),
1211 {},
1212 [&](Account const& a1, Account const& a2, ApplyContext& ac) {
1213 auto const keylet = keylet::vault(a1.id(), SeqProxy::rawSequence(ac.view().seq()));
1214 return kAdjust(ac.view(), keylet, Adjustments{});
1215 },
1216 XRPAmount{},
1217 STTx{ttLOAN_PAY, [](STObject& tx) { tx.setFieldAmount(sfAmount, XRPAmount(200)); }},
1219 precloseXrp);
1220
1221 // ttLOAN_PAY: cash is credited to the vault and a loan is created
1222 // rather than modified. This object-existence rule applies on both
1223 // invariant passes.
1224 doInvariantCheck(
1225 {"Loan created by a transaction other than LoanSet"},
1226 [&](Account const& a1, Account const& a2, ApplyContext& ac) {
1227 auto const keylet = keylet::vault(a1.id(), SeqProxy::rawSequence(ac.view().seq()));
1228 return kAdjust(
1229 ac.view(),
1230 keylet,
1231 Adjustments{
1232 .assetsTotal = 50,
1233 .assetsAvailable = 50,
1234 .vaultAssets = 50,
1235 .accountAssets = AccountAmount{.account = a2.id(), .amount = -50},
1236 .createLoan =
1237 LoanParams{
1238 .principalOutstanding = 100,
1239 .totalValueOutstanding = 100,
1240 .borrower = a1.id(),
1241 },
1242 });
1243 },
1244 XRPAmount{},
1245 STTx{ttLOAN_PAY, [](STObject& tx) { tx.setFieldAmount(sfAmount, XRPAmount(50)); }},
1247 precloseXrp);
1248
1249 // ttLOAN_PAY: loss unrealized driven negative. The cash inflow is
1250 // valid, but loss unrealized is set below zero.
1251 doInvariantCheck(
1252 {"loss unrealized must not be negative"},
1253 [&](Account const& a1, Account const& a2, ApplyContext& ac) {
1254 auto const keylet = keylet::vault(a1.id(), SeqProxy::rawSequence(ac.view().seq()));
1255 return kAdjust(
1256 ac.view(),
1257 keylet,
1258 Adjustments{
1259 .assetsTotal = 100,
1260 .assetsAvailable = 100,
1261 .lossUnrealized = -1,
1262 .vaultAssets = 100,
1263 .accountAssets = AccountAmount{.account = a2.id(), .amount = -100},
1264 });
1265 },
1266 XRPAmount{},
1267 STTx{ttLOAN_PAY, [](STObject& tx) { tx.setFieldAmount(sfAmount, XRPAmount(200)); }},
1269 precloseXrp);
1270
1271 // ttLOAN_PAY success post-conditions. A loan left with payments still
1272 // remaining after a successful payment must show that payment in its
1273 // balance and schedule: neither PrincipalOutstanding nor
1274 // TotalValueOutstanding may increase, at least one of them must
1275 // strictly decrease, PaymentRemaining must strictly decrease, and
1276 // NextPaymentDueDate must advance by a positive multiple of
1277 // PaymentInterval. Each failing case seeds the same loan, then applies
1278 // an after-image that breaks exactly one of those conditions.
1279 {
1280 struct Case
1281 {
1282 Number principal;
1283 Number totalValue;
1284 std::uint32_t remaining;
1285 std::uint32_t dueDate;
1286 std::string expected;
1287 };
1288 auto const cases = std::to_array<Case>({
1289 {
1290 .principal = Number(100),
1291 .totalValue = Number(150),
1292 .remaining = 1,
1293 .dueDate = 110,
1294 .expected = "loan pay must decrease PrincipalOutstanding or "
1295 "TotalValueOutstanding",
1296 },
1297 {
1298 .principal = Number(110),
1299 .totalValue = Number(150),
1300 .remaining = 1,
1301 .dueDate = 110,
1302 .expected = "loan pay must not increase PrincipalOutstanding",
1303 },
1304 {
1305 .principal = Number(50),
1306 .totalValue = Number(160),
1307 .remaining = 1,
1308 .dueDate = 110,
1309 .expected = "loan pay must not increase TotalValueOutstanding",
1310 },
1311 {
1312 .principal = Number(50),
1313 .totalValue = Number(150),
1314 .remaining = 2,
1315 .dueDate = 110,
1316 .expected = "loan pay must decrease PaymentRemaining",
1317 },
1318 {
1319 .principal = Number(50),
1320 .totalValue = Number(150),
1321 .remaining = 1,
1322 .dueDate = 100,
1323 .expected = "loan pay must advance NextPaymentDueDate",
1324 },
1325 // Advanced, but not by a whole number of payment intervals.
1326 {
1327 .principal = Number(50),
1328 .totalValue = Number(150),
1329 .remaining = 1,
1330 .dueDate = 105,
1331 .expected = "loan pay must advance NextPaymentDueDate",
1332 },
1333 });
1334
1335 for (auto const& c : cases)
1336 {
1337 Env env{*this, all_};
1338 Account const a1{"A1"};
1339 Account const a2{"A2"};
1340 env.fund(XRP(1000), a1, a2);
1341 auto const keys = createClosedXrpBroker(a1, env);
1342 if (!keys)
1343 continue;
1344 auto const& brokerKeylet = keys->second;
1345
1346 OpenView ov{*env.current()};
1347 auto const loanKeylet = keylet::loan(brokerKeylet.key, SeqProxy::rawSequence(1));
1348 {
1349 auto const sleLoan = makeLoanSle(brokerKeylet.key, 1, a2.id());
1350 sleLoan->at(sfPrincipalOutstanding) = Number(100);
1351 sleLoan->at(sfTotalValueOutstanding) = Number(150);
1352 sleLoan->at(sfPaymentInterval) = 10u;
1353 sleLoan->setFieldU32(sfPaymentRemaining, 2);
1354 sleLoan->setFieldU32(sfNextPaymentDueDate, 100);
1355 ov.rawInsert(sleLoan);
1356 }
1357
1358 STTx const tx{
1359 ttLOAN_PAY, [](STObject& t) { t.setFieldAmount(sfAmount, XRPAmount(50)); }};
1360 test::StreamSink sink{beast::Severity::Warning};
1361 beast::Journal const jlog{sink};
1362 ApplyContext ac{
1363 env.app(), ov, tx, tesSUCCESS, env.current()->fees().base, TapNone, jlog};
1364 CurrentTransactionRulesGuard const rulesGuard(ov.rules());
1365
1366 auto const sleLoan = ac.view().peek(loanKeylet);
1367 if (!BEAST_EXPECT(sleLoan))
1368 continue;
1369 sleLoan->at(sfPrincipalOutstanding) = c.principal;
1370 sleLoan->at(sfTotalValueOutstanding) = c.totalValue;
1371 sleLoan->setFieldU32(sfPaymentRemaining, c.remaining);
1372 sleLoan->setFieldU32(sfNextPaymentDueDate, c.dueDate);
1373 ac.view().update(sleLoan);
1374
1375 auto transactor = makeTransactor(ac);
1376 if (!BEAST_EXPECT(transactor))
1377 continue;
1378 TER const result = transactor->checkInvariants(
1379 tesSUCCESS, XRPAmount{}, Transactor::InvariantScope::Full);
1380 BEAST_EXPECT(result == tecINVARIANT_FAILED);
1381 BEAST_EXPECT(sink.messages().str().contains(c.expected));
1382 }
1383
1384 // Principal may stick while TotalValueOutstanding falls. This
1385 // after-image is only a Loan mutation, so other (vault) invariants
1386 // still fail under Full scope; ValidLoan itself must not.
1387 {
1388 Env env{*this, all_};
1389 Account const a1{"A1"};
1390 Account const a2{"A2"};
1391 env.fund(XRP(1000), a1, a2);
1392 auto const keys = createClosedXrpBroker(a1, env);
1393 if (!keys)
1394 {
1395 fail();
1396 }
1397 else
1398 {
1399 auto const& brokerKeylet = keys->second;
1400 OpenView ov{*env.current()};
1401 auto const loanKeylet =
1402 keylet::loan(brokerKeylet.key, SeqProxy::rawSequence(1));
1403 {
1404 auto const sleLoan = makeLoanSle(brokerKeylet.key, 1, a2.id());
1405 sleLoan->at(sfPrincipalOutstanding) = Number(100);
1406 sleLoan->at(sfTotalValueOutstanding) = Number(150);
1407 sleLoan->at(sfPaymentInterval) = 10u;
1408 sleLoan->setFieldU32(sfPaymentRemaining, 2);
1409 sleLoan->setFieldU32(sfNextPaymentDueDate, 100);
1410 ov.rawInsert(sleLoan);
1411 }
1412
1413 STTx const tx{
1414 ttLOAN_PAY, [](STObject& t) { t.setFieldAmount(sfAmount, XRPAmount(50)); }};
1415 test::StreamSink sink{beast::Severity::Warning};
1416 beast::Journal const jlog{sink};
1417 ApplyContext ac{
1418 env.app(), ov, tx, tesSUCCESS, env.current()->fees().base, TapNone, jlog};
1419 CurrentTransactionRulesGuard const rulesGuard(ov.rules());
1420
1421 auto const sleLoan = ac.view().peek(loanKeylet);
1422 if (BEAST_EXPECT(sleLoan))
1423 {
1424 sleLoan->at(sfPrincipalOutstanding) = Number(100);
1425 sleLoan->at(sfTotalValueOutstanding) = Number(140);
1426 sleLoan->setFieldU32(sfPaymentRemaining, 1);
1427 sleLoan->setFieldU32(sfNextPaymentDueDate, 110);
1428 ac.view().update(sleLoan);
1429
1430 auto transactor = makeTransactor(ac);
1431 if (BEAST_EXPECT(transactor))
1432 {
1433 std::ignore = transactor->checkInvariants(
1434 tesSUCCESS, XRPAmount{}, Transactor::InvariantScope::Full);
1435 auto const logs = sink.messages().str();
1436 BEAST_EXPECT(!logs.contains("Invariant failed: Loan"));
1437 BEAST_EXPECT(!logs.contains("loan pay"));
1438 }
1439 }
1440 }
1441 }
1442 }
1443
1444 // ttLOAN_MANAGE (default): the write-off is rounded downward at the
1445 // pre-default AssetsTotal scale. A near-total IOU default can leave
1446 // valid positive dust while moving the posterior AssetsTotal to a much
1447 // finer scale. The dust must be bounded by the former scale rather than
1448 // compared with one unit at the posterior scale.
1449 //
1450 // CashBasis, not FixedPrecision: AssetsTotal is set independently of
1451 // AssetsAvailable plus the vault's AssetsDeployed, which the FixedPrecision
1452 // sync invariant rejects.
1453 {
1454 Env env{*this, (all_ | featureLendingProtocolV1_1) - featureLendingProtocolV1_2};
1455 Account const issuer{"issuer"};
1456 Account const owner{"owner"};
1457 Account const borrower{"borrower"};
1458 env.fund(XRP(1000), issuer, owner, borrower);
1459 env.close();
1460
1461 PrettyAsset const iouAsset{issuer["IOU"]};
1462 auto const brokerKeylet = createLoanBroker(owner, env, iouAsset);
1463 auto const sleBrokerBase = env.le(brokerKeylet);
1464 if (!BEAST_EXPECT(sleBrokerBase))
1465 return;
1466 auto const vaultKeylet = keylet::vault(sleBrokerBase->at(sfVaultID));
1467 env.close();
1468
1469 Number const assetsTotalBefore{1, 1};
1470 Number const loanOwed{9'999'999'999'999'999LL, -15};
1471 Number const assetsTotalAfter{1, -14};
1472 auto const beforeScale = scale(assetsTotalBefore, iouAsset);
1473 auto const afterScale = scale(assetsTotalAfter, iouAsset);
1474 Number const residual = (assetsTotalAfter - assetsTotalBefore) - (-loanOwed);
1475 Number const beforeTolerance{1, beforeScale};
1476 Number const afterTolerance{1, afterScale};
1477
1478 BEAST_EXPECT(afterScale < beforeScale);
1479 BEAST_EXPECT(residual > beast::kZero && residual < beforeTolerance);
1480 BEAST_EXPECT(residual > afterTolerance);
1481
1482 OpenView ov{*env.current()};
1483 {
1484 auto const sleVaultRead = ov.read(vaultKeylet);
1485 if (!BEAST_EXPECT(sleVaultRead))
1486 return;
1487 auto const sleVault = std::make_shared<SLE>(*sleVaultRead);
1488 sleVault->at(sfAssetsTotal) = assetsTotalBefore;
1489 sleVault->at(sfAssetsAvailable) = Number(0);
1490 ov.rawReplace(sleVault);
1491
1492 auto const sharesKeylet = keylet::mptokenIssuance(sleVaultRead->at(sfShareMPTID));
1493 auto const sleSharesRead = ov.read(sharesKeylet);
1494 if (!BEAST_EXPECT(sleSharesRead))
1495 return;
1496 auto const sleShares = std::make_shared<SLE>(*sleSharesRead);
1497 sleShares->at(sfOutstandingAmount) = 1;
1498 ov.rawReplace(sleShares);
1499 }
1500 {
1501 auto const sleBrokerRead = ov.read(brokerKeylet);
1502 if (!BEAST_EXPECT(sleBrokerRead))
1503 return;
1504 auto const sleBroker = std::make_shared<SLE>(*sleBrokerRead);
1505 sleBroker->at(sfDebtTotal) = loanOwed;
1506 ov.rawReplace(sleBroker);
1507 }
1508 auto const loanKeylet = keylet::loan(brokerKeylet.key, SeqProxy::rawSequence(1));
1509 {
1510 auto const sleLoan = makeLoanSle(brokerKeylet.key, 1, borrower.id());
1511 sleLoan->at(sfPrincipalOutstanding) = loanOwed;
1512 sleLoan->at(sfTotalValueOutstanding) = loanOwed;
1513 sleLoan->setFieldU32(sfPaymentRemaining, 1);
1514 ov.rawInsert(sleLoan);
1515 }
1516
1517 STTx const tx{
1518 ttLOAN_MANAGE, [](STObject& t) { t.setFieldU32(sfFlags, tfLoanDefault); }};
1519 test::StreamSink sink{beast::Severity::Warning};
1520 beast::Journal const jlog{sink};
1521 ApplyContext ac{
1522 env.app(), ov, tx, tesSUCCESS, env.current()->fees().base, TapNone, jlog};
1523 CurrentTransactionRulesGuard const rulesGuard(ov.rules());
1524
1525 {
1526 auto const sleVault = ac.view().peek(vaultKeylet);
1527 if (!BEAST_EXPECT(sleVault))
1528 return;
1529 sleVault->at(sfAssetsTotal) = assetsTotalAfter;
1530 ac.view().update(sleVault);
1531 }
1532 {
1533 auto const sleBroker = ac.view().peek(brokerKeylet);
1534 if (!BEAST_EXPECT(sleBroker))
1535 return;
1536 sleBroker->at(sfDebtTotal) = Number(0);
1537 ac.view().update(sleBroker);
1538 }
1539 {
1540 auto const sleLoan = ac.view().peek(loanKeylet);
1541 if (!BEAST_EXPECT(sleLoan))
1542 return;
1543 sleLoan->at(sfPrincipalOutstanding) = Number(0);
1544 sleLoan->at(sfTotalValueOutstanding) = Number(0);
1545 sleLoan->setFieldU32(sfPaymentRemaining, 0);
1546 sleLoan->setFieldU32(sfFlags, lsfLoanDefault);
1547 ac.view().update(sleLoan);
1548 }
1549
1550 auto transactor = makeTransactor(ac);
1551 if (!BEAST_EXPECT(transactor))
1552 return;
1553 TER const result = transactor->checkInvariants(
1554 tesSUCCESS, XRPAmount{}, Transactor::InvariantScope::Full);
1555 BEAST_EXPECT(result == tesSUCCESS);
1556 }
1557
1558 // A loan may only be deleted by a LoanDelete transaction, and only once
1559 // it is fully paid off. Both branches are exercised by creating a real
1560 // loan in the Preclose (so it exists in the base ledger with outstanding
1561 // principal) and then erasing it in the Precheck.
1562 {
1563 Keylet loanKeylet = keylet::amendments();
1564 auto const precloseLoan = [&loanKeylet, this](
1565 Account const& a1, Account const& a2, Env& env) -> bool {
1566 PrettyAsset const xrpAsset{xrpIssue(), 1'000'000};
1567 auto const brokerKeylet = createLoanBroker(a1, env, xrpAsset);
1568 auto const brokerSle = env.le(brokerKeylet);
1569 if (!BEAST_EXPECT(brokerSle))
1570 return false;
1571 auto const vaultKeylet = keylet::vault(brokerSle->at(sfVaultID));
1572 Vault const vault{env};
1573 env(vault.deposit(
1574 {.depositor = a1, .id = vaultKeylet.key, .amount = xrpAsset(100)}));
1575 env.close(std::chrono::seconds{61});
1576
1577 loanKeylet = keylet::loan(
1578 brokerKeylet.key, SeqProxy::rawSequence(brokerSle->at(sfLoanSequence)));
1579 env(loan::set(a2, brokerKeylet.key, xrpAsset(50).value()),
1580 loan::kCounterparty(a1),
1581 Sig(sfCounterpartySignature, a1),
1582 loan::kPaymentInterval(60),
1583 loan::kPaymentTotal(1),
1584 Fee(env.current()->fees().base * 2));
1585 env.close();
1586 return BEAST_EXPECT(env.le(loanKeylet));
1587 };
1588
1589 auto const eraseLoan = [&loanKeylet](Account const&, Account const&, ApplyContext& ac) {
1590 auto const sle = ac.view().peek(loanKeylet);
1591 if (!sle)
1592 return false;
1593 ac.view().erase(sle);
1594 return true;
1595 };
1596
1597 // Deleting the loan under any transaction type other than LoanDelete
1598 // (here the neutral ttACCOUNT_SET) is a violation, even while the
1599 // loan still has outstanding obligations: the transaction-type check
1600 // fires before the not-fully-paid-off check.
1601 doInvariantCheck(
1602 {"Loan deleted by a transaction other than LoanDelete"},
1603 eraseLoan,
1604 XRPAmount{},
1605 STTx{ttACCOUNT_SET, [](STObject&) {}},
1607 precloseLoan);
1608 }
1609
1610 STTx const loanSetTx{
1611 ttLOAN_SET, [](STObject& tx) { tx.at(sfPrincipalRequested) = Number(0); }};
1612
1613 // Loan interest due (total value less principal and management fee) must
1614 // never be negative. The loan below carries a total value short of its
1615 // principal, while every individual field stays non-negative. A real
1616 // broker over an XRP vault is created in the preclose, both so the
1617 // earlier broker-existence checks pass and so the deficit is measured
1618 // in an integral asset domain, where no rounding tolerance applies.
1619 {
1620 Keylet brokerKeylet = keylet::amendments();
1621 auto const precloseBroker = [&brokerKeylet, this](
1622 Account const& a1, Account const&, Env& env) -> bool {
1623 PrettyAsset const xrpAsset{xrpIssue(), 1'000'000};
1624 brokerKeylet = this->createLoanBroker(a1, env, xrpAsset);
1625 env.close();
1626 return BEAST_EXPECT(env.le(brokerKeylet));
1627 };
1628
1629 doInvariantCheck(
1630 {"Loan interest due is negative"},
1631 [&](Account const&, Account const& a2, ApplyContext& ac) {
1632 auto const sleLoan = makeLoanSle(brokerKeylet.key, 1, a2.id());
1633 sleLoan->at(sfPrincipalOutstanding) = Number(100);
1634 sleLoan->at(sfTotalValueOutstanding) = Number(90);
1635 sleLoan->setFieldU32(sfPaymentRemaining, 1);
1636 ac.view().insert(sleLoan);
1637 return true;
1638 },
1639 XRPAmount{},
1640 loanSetTx,
1642 precloseBroker);
1643 }
1644
1645 // Each of these loan STNumber fields must never be negative. The loan
1646 // is created directly with a single field set negative while the
1647 // paid-off bookkeeping is kept consistent, so that only the "<field>
1648 // is negative" check trips.
1649 for (auto const field : {
1650 &sfLoanServiceFee,
1651 &sfLatePaymentFee,
1652 &sfClosePaymentFee,
1653 &sfPrincipalOutstanding,
1654 &sfTotalValueOutstanding,
1655 &sfManagementFeeOutstanding,
1656 })
1657 {
1658 // The outstanding-balance fields also feed the paid-off checks, so
1659 // a loan carrying one must still have payments remaining; a loan
1660 // with only a negative fee stays fully paid off (zero remaining).
1661 bool const isOutstanding = *field == sfPrincipalOutstanding ||
1662 *field == sfTotalValueOutstanding || *field == sfManagementFeeOutstanding;
1663 doInvariantCheck(
1664 {field->getName() + " is negative"},
1665 [&, field](Account const& a1, Account const& a2, ApplyContext& ac) {
1666 auto const brokerKeylet = keylet::loanBroker(a1.id(), SeqProxy::rawSequence(1));
1667 auto const sleLoan = makeLoanSle(brokerKeylet.key, 1, a2.id());
1668 sleLoan->at(*field) = Number(-10);
1669 sleLoan->setFieldU32(sfPaymentRemaining, isOutstanding ? 1 : 0);
1670 ac.view().insert(sleLoan);
1671 return true;
1672 },
1673 XRPAmount{},
1674 loanSetTx);
1675 }
1676
1677 // Mirror of the loop above for the strictly-positive constraint: a
1678 // loan's sfPeriodicPayment must always be > 0. Cover both boundary
1679 // failure modes (zero and negative).
1680 for (Number const& badValue : {Number(0), Number(-1)})
1681 {
1682 doInvariantCheck(
1683 {std::string{sfPeriodicPayment.getName()} + " is zero or negative"},
1684 [&, badValue](Account const& a1, Account const& a2, ApplyContext& ac) {
1685 auto const brokerKeylet = keylet::loanBroker(a1.id(), SeqProxy::rawSequence(1));
1686 auto const sleLoan = makeLoanSle(brokerKeylet.key, 1, a2.id());
1687 sleLoan->at(sfPeriodicPayment) = badValue;
1688 ac.view().insert(sleLoan);
1689 return true;
1690 },
1691 XRPAmount{},
1692 loanSetTx);
1693 }
1694
1695 // A loan with sfPaymentRemaining == 0 must be fully paid off in every
1696 // outstanding-balance dimension. Insert a bare loan that reports zero
1697 // payments remaining but still carries a non-zero principal owed; the
1698 // paid-off invariant must reject it before the later broker-existence
1699 // check has a chance to run.
1700 doInvariantCheck(
1701 {"Loan with zero payments remaining has not been paid off"},
1702 [&](Account const& a1, Account const& a2, ApplyContext& ac) {
1703 auto const brokerKeylet = keylet::loanBroker(a1.id(), SeqProxy::rawSequence(1));
1704 auto const sleLoan = makeLoanSle(brokerKeylet.key, 1, a2.id());
1705 sleLoan->at(sfPrincipalOutstanding) = Number(100);
1706 sleLoan->at(sfTotalValueOutstanding) = Number(100);
1707 sleLoan->at(sfPeriodicPayment) = Number(1);
1708 sleLoan->setFieldU32(sfPaymentRemaining, 0);
1709 ac.view().insert(sleLoan);
1710 return true;
1711 },
1712 XRPAmount{},
1713 loanSetTx);
1714
1715 // Converse: a loan whose outstanding balances are all zero has been
1716 // fully paid off and must carry zero payments remaining. Insert a
1717 // fully-zeroed loan with sfPaymentRemaining = 1 to trip the check.
1718 doInvariantCheck(
1719 {"Fully paid off Loan still has payments remaining"},
1720 [&](Account const& a1, Account const& a2, ApplyContext& ac) {
1721 auto const brokerKeylet = keylet::loanBroker(a1.id(), SeqProxy::rawSequence(1));
1722 auto const sleLoan = makeLoanSle(brokerKeylet.key, 1, a2.id());
1723 sleLoan->setFieldU32(sfPaymentRemaining, 1);
1724 ac.view().insert(sleLoan);
1725 return true;
1726 },
1727 XRPAmount{},
1728 loanSetTx);
1729
1730 // A loan must reference a live loan broker. A bare loan SLE is
1731 // inserted with every other loan-level field kept consistent so the
1732 // earlier ValidLoan checks pass; sfLoanBrokerID defaults to zero,
1733 // which resolves to no broker, and the broker-existence check trips.
1734 doInvariantCheck(
1735 {"Loan broker does not exist"},
1736 [&](Account const& a1, Account const& a2, ApplyContext& ac) {
1737 auto const sleLoan = makeLoanSle(UInt256{}, 1, a2.id());
1738 ac.view().insert(sleLoan);
1739 return true;
1740 },
1741 XRPAmount{},
1742 loanSetTx);
1743
1744 // A loan's broker must in turn reference a live vault. A real broker
1745 // is created in the preclose so its sfVaultID points at an existing
1746 // vault; the precheck then erases that vault and inserts a loan
1747 // referencing the broker, so the broker-existence check passes and
1748 // the broker-vault-existence check trips.
1749 {
1750 Keylet brokerKeylet = keylet::amendments();
1751 auto const precloseBroker = [&brokerKeylet, this](
1752 Account const& a1, Account const&, Env& env) -> bool {
1753 PrettyAsset const xrpAsset{xrpIssue(), 1'000'000};
1754 brokerKeylet = this->createLoanBroker(a1, env, xrpAsset);
1755 env.close();
1756 return BEAST_EXPECT(env.le(brokerKeylet));
1757 };
1758
1759 doInvariantCheck(
1760 {"Loan broker vault does not exist"},
1761 [&brokerKeylet](Account const&, Account const&, ApplyContext& ac) {
1762 auto const sleBroker = ac.view().peek(brokerKeylet);
1763 if (!sleBroker)
1764 return false;
1765 auto const sleVault = ac.view().peek(keylet::vault(sleBroker->at(sfVaultID)));
1766 if (!sleVault)
1767 return false;
1768 ac.view().erase(sleVault);
1769
1770 auto const loanKeylet =
1771 keylet::loan(brokerKeylet.key, SeqProxy::rawSequence(1));
1772 auto const sleLoan = std::make_shared<SLE>(loanKeylet);
1773 sleLoan->at(sfLoanBrokerID) = brokerKeylet.key;
1774 sleLoan->at(sfPrincipalOutstanding) = Number(0);
1775 sleLoan->at(sfTotalValueOutstanding) = Number(0);
1776 sleLoan->at(sfManagementFeeOutstanding) = Number(0);
1777 sleLoan->at(sfPeriodicPayment) = Number(1);
1778 sleLoan->setFieldU32(sfPaymentRemaining, 0);
1779 ac.view().insert(sleLoan);
1780 return true;
1781 },
1782 XRPAmount{},
1783 loanSetTx,
1785 precloseBroker);
1786 }
1787
1788 // ttVAULT_SET: owner is immutable (enforced by
1789 // NoModifiedUnmodifiableFields under featureLendingProtocolV1_1.
1790 doInvariantCheck(
1791 {"changed an unchangeable field"},
1792 [&](Account const& a1, Account const& a2, ApplyContext& ac) {
1793 auto const keylet = keylet::vault(a1.id(), SeqProxy::rawSequence(ac.view().seq()));
1794 auto const sleVault = ac.view().peek(keylet);
1795 if (!sleVault)
1796 return false;
1797 sleVault->setAccountID(sfOwner, a2.id());
1798 ac.view().update(sleVault);
1799 return true;
1800 },
1801 XRPAmount{},
1802 STTx{ttVAULT_SET, [](STObject& tx) {}},
1804 precloseXrp);
1805
1806 // ttVAULT_SET: withdrawal policy is immutable
1807 doInvariantCheck(
1808 {"changed an unchangeable field"},
1809 [&](Account const& a1, Account const& a2, ApplyContext& ac) {
1810 auto const keylet = keylet::vault(a1.id(), SeqProxy::rawSequence(ac.view().seq()));
1811 auto const sleVault = ac.view().peek(keylet);
1812 if (!sleVault)
1813 return false;
1814 sleVault->setFieldU8(
1815 sfWithdrawalPolicy,
1816 static_cast<std::uint8_t>(sleVault->getFieldU8(sfWithdrawalPolicy) + 1));
1817 ac.view().update(sleVault);
1818 return true;
1819 },
1820 XRPAmount{},
1821 STTx{ttVAULT_SET, [](STObject& tx) {}},
1823 precloseXrp);
1824
1825 // ttVAULT_SET: scale is immutable
1826 doInvariantCheck(
1827 {"changed an unchangeable field"},
1828 [&](Account const& a1, Account const& a2, ApplyContext& ac) {
1829 auto const keylet = keylet::vault(a1.id(), SeqProxy::rawSequence(ac.view().seq()));
1830 auto const sleVault = ac.view().peek(keylet);
1831 if (!sleVault)
1832 return false;
1833 sleVault->setFieldU8(
1834 sfScale, static_cast<std::uint8_t>(sleVault->getFieldU8(sfScale) + 1));
1835 ac.view().update(sleVault);
1836 return true;
1837 },
1838 XRPAmount{},
1839 STTx{ttVAULT_SET, [](STObject& tx) {}},
1841 precloseXrp);
1842
1843 // featureLendingProtocolV1_1 moves the vault immutability checks from VaultInvariant to
1844 // InvariantCheck.
1845 doInvariantCheck(
1846 makeEnv(all_),
1847 {"changed an unchangeable field"},
1848 [&](Account const& a1, Account const& a2, ApplyContext& ac) {
1849 auto const keylet = keylet::vault(a1.id(), SeqProxy::rawSequence(ac.view().seq()));
1850 auto const sleVault = ac.view().peek(keylet);
1851 if (!sleVault)
1852 return false;
1853 sleVault->setFieldU8(
1854 sfWithdrawalPolicy,
1855 static_cast<std::uint8_t>(sleVault->getFieldU8(sfWithdrawalPolicy) + 1));
1856 ac.view().update(sleVault);
1857 return true;
1858 },
1859 XRPAmount{},
1860 STTx{ttVAULT_SET, [](STObject& tx) {}},
1862 precloseXrp);
1863
1864 testcase << "Vault create";
1865 doInvariantCheck(
1866 {
1867 "created vault must be empty",
1868 "updated zero sized vault must have no assets outstanding",
1869 "create operation must not have updated a vault",
1870 },
1871 [&](Account const& a1, Account const& a2, ApplyContext& ac) {
1872 auto const keylet = keylet::vault(a1.id(), SeqProxy::rawSequence(ac.view().seq()));
1873 auto const sleVault = ac.view().peek(keylet);
1874 if (!sleVault)
1875 return false;
1876 (*sleVault)[sfAssetsTotal] = 9;
1877 ac.view().update(sleVault);
1878 return true;
1879 },
1880 XRPAmount{},
1881 STTx{ttVAULT_CREATE, [](STObject&) {}},
1883 [&](Account const& a1, Account const& a2, Env& env) {
1884 Vault const vault{env};
1885 auto [tx, keylet] = vault.create({.owner = a1, .asset = xrpIssue()});
1886 env(tx);
1887 return true;
1888 });
1889
1890 doInvariantCheck(
1891 {
1892 "created vault must be empty",
1893 "updated zero sized vault must have no assets available",
1894 "assets available must not be greater than assets outstanding",
1895 "create operation must not have updated a vault",
1896 },
1897 [&](Account const& a1, Account const& a2, ApplyContext& ac) {
1898 auto const keylet = keylet::vault(a1.id(), SeqProxy::rawSequence(ac.view().seq()));
1899 auto const sleVault = ac.view().peek(keylet);
1900 if (!sleVault)
1901 return false;
1902 (*sleVault)[sfAssetsAvailable] = 9;
1903 ac.view().update(sleVault);
1904 return true;
1905 },
1906 XRPAmount{},
1907 STTx{ttVAULT_CREATE, [](STObject&) {}},
1909 [&](Account const& a1, Account const& a2, Env& env) {
1910 Vault const vault{env};
1911 auto [tx, keylet] = vault.create({.owner = a1, .asset = xrpIssue()});
1912 env(tx);
1913 return true;
1914 });
1915
1916 doInvariantCheck(
1917 {
1918 "created vault must be empty",
1919 "loss unrealized must not exceed the difference between assets "
1920 "outstanding and available",
1921 "vault transaction must not change loss unrealized",
1922 "create operation must not have updated a vault",
1923 },
1924 [&](Account const& a1, Account const& a2, ApplyContext& ac) {
1925 auto const keylet = keylet::vault(a1.id(), SeqProxy::rawSequence(ac.view().seq()));
1926 auto const sleVault = ac.view().peek(keylet);
1927 if (!sleVault)
1928 return false;
1929 (*sleVault)[sfLossUnrealized] = 1;
1930 ac.view().update(sleVault);
1931 return true;
1932 },
1933 XRPAmount{},
1934 STTx{ttVAULT_CREATE, [](STObject&) {}},
1936 [&](Account const& a1, Account const& a2, Env& env) {
1937 Vault const vault{env};
1938 auto [tx, keylet] = vault.create({.owner = a1, .asset = xrpIssue()});
1939 env(tx);
1940 return true;
1941 });
1942
1943 // FixedPrecision-only: a new vault must have AssetsDeployed == 0.
1944 doInvariantCheck(
1945 {
1946 "created vault must be empty",
1947 "updated zero sized vault must have no AssetsDeployed",
1948 "create operation must not have updated a vault",
1949 },
1950 [&](Account const& a1, Account const& a2, ApplyContext& ac) {
1951 auto const keylet = keylet::vault(a1.id(), SeqProxy::rawSequence(ac.view().seq()));
1952 auto const sleVault = ac.view().peek(keylet);
1953 if (!sleVault)
1954 return false;
1955 (*sleVault)[sfAssetsDeployed] = Number{1};
1956 ac.view().update(sleVault);
1957 return true;
1958 },
1959 XRPAmount{},
1960 STTx{ttVAULT_CREATE, [](STObject&) {}},
1962 [&](Account const& a1, Account const& a2, Env& env) {
1963 Vault const vault{env};
1964 auto [tx, keylet] = vault.create({.owner = a1, .asset = xrpIssue()});
1965 env(tx);
1966 return true;
1967 });
1968
1969 // FixedPrecision-only: a new vault must have YieldUnrealized == 0.
1970 doInvariantCheck(
1971 {
1972 "created vault must be empty",
1973 "create operation must not have updated a vault",
1974 },
1975 [&](Account const& a1, Account const& a2, ApplyContext& ac) {
1976 auto const keylet = keylet::vault(a1.id(), SeqProxy::rawSequence(ac.view().seq()));
1977 auto const sleVault = ac.view().peek(keylet);
1978 if (!sleVault)
1979 return false;
1980 (*sleVault)[sfYieldUnrealized] = Number{1};
1981 ac.view().update(sleVault);
1982 return true;
1983 },
1984 XRPAmount{},
1985 STTx{ttVAULT_CREATE, [](STObject&) {}},
1987 [&](Account const& a1, Account const& a2, Env& env) {
1988 Vault const vault{env};
1989 auto [tx, keylet] = vault.create({.owner = a1, .asset = xrpIssue()});
1990 env(tx);
1991 return true;
1992 });
1993
1994 doInvariantCheck(
1995 {
1996 "created vault must be empty",
1997 "create operation must not have updated a vault",
1998 "invalid OutstandingAmount balance 0 9 0",
1999 },
2000 [&](Account const& a1, Account const& a2, ApplyContext& ac) {
2001 auto const keylet = keylet::vault(a1.id(), SeqProxy::rawSequence(ac.view().seq()));
2002 auto const sleVault = ac.view().peek(keylet);
2003 if (!sleVault)
2004 return false;
2005 auto const sleShares =
2006 ac.view().peek(keylet::mptokenIssuance((*sleVault)[sfShareMPTID]));
2007 if (!sleShares)
2008 return false;
2009 ac.view().update(sleVault);
2010 (*sleShares)[sfOutstandingAmount] = 9;
2011 ac.view().update(sleShares);
2012 return true;
2013 },
2014 XRPAmount{},
2015 STTx{ttVAULT_CREATE, [](STObject&) {}},
2017 [&](Account const& a1, Account const& a2, Env& env) {
2018 Vault const vault{env};
2019 auto [tx, keylet] = vault.create({.owner = a1, .asset = xrpIssue()});
2020 env(tx);
2021 return true;
2022 });
2023
2024 doInvariantCheck(
2025 {
2026 "assets maximum must not be negative",
2027 "create operation must not have updated a vault",
2028 },
2029 [&](Account const& a1, Account const& a2, ApplyContext& ac) {
2030 auto const keylet = keylet::vault(a1.id(), SeqProxy::rawSequence(ac.view().seq()));
2031 auto const sleVault = ac.view().peek(keylet);
2032 if (!sleVault)
2033 return false;
2034 (*sleVault)[sfAssetsMaximum] = Number(-1);
2035 ac.view().update(sleVault);
2036 return true;
2037 },
2038 XRPAmount{},
2039 STTx{ttVAULT_CREATE, [](STObject&) {}},
2041 [&](Account const& a1, Account const& a2, Env& env) {
2042 Vault const vault{env};
2043 auto [tx, keylet] = vault.create({.owner = a1, .asset = xrpIssue()});
2044 env(tx);
2045 return true;
2046 });
2047
2048 doInvariantCheck(
2049 {
2050 "create operation must not have updated a vault",
2051 "shares issuer and vault pseudo-account must be the same",
2052 "shares issuer must be a pseudo-account",
2053 "shares issuer pseudo-account must point back to the vault",
2054 },
2055 [&](Account const& a1, Account const& a2, ApplyContext& ac) {
2056 auto const keylet = keylet::vault(a1.id(), SeqProxy::rawSequence(ac.view().seq()));
2057 auto const sleVault = ac.view().peek(keylet);
2058 if (!sleVault)
2059 return false;
2060 auto const sleShares =
2061 ac.view().peek(keylet::mptokenIssuance((*sleVault)[sfShareMPTID]));
2062 if (!sleShares)
2063 return false;
2064 ac.view().update(sleVault);
2065 (*sleShares)[sfIssuer] = a1.id();
2066 ac.view().update(sleShares);
2067 return true;
2068 },
2069 XRPAmount{},
2070 STTx{ttVAULT_CREATE, [](STObject&) {}},
2072 [&](Account const& a1, Account const& a2, Env& env) {
2073 Vault const vault{env};
2074 auto [tx, keylet] = vault.create({.owner = a1, .asset = xrpIssue()});
2075 env(tx);
2076 return true;
2077 });
2078
2079 doInvariantCheck(
2080 {"vault created by a wrong transaction type", "account root created illegally"},
2081 [&](Account const& a1, Account const& a2, ApplyContext& ac) {
2082 // The code below will create a valid vault with (almost) all
2083 // the invariants holding. Except one: it is created by the
2084 // wrong transaction type.
2085 auto const sequence = ac.view().seq();
2086 auto const vaultKeylet = keylet::vault(a1.id(), SeqProxy::rawSequence(sequence));
2087 auto const sleVault = std::make_shared<SLE>(vaultKeylet);
2088 auto const vaultPage = ac.view().dirInsert(
2089 keylet::ownerDir(a1.id()), sleVault->key(), describeOwnerDir(a1.id()));
2090 sleVault->setFieldU64(sfOwnerNode, *vaultPage);
2091
2092 auto const pseudoId = pseudoAccountAddress(ac.view(), vaultKeylet.key);
2093 // Create pseudo-account.
2094 auto const sleAccount = std::make_shared<SLE>(keylet::account(pseudoId));
2095 sleAccount->setAccountID(sfAccount, pseudoId);
2096 sleAccount->setFieldAmount(sfBalance, STAmount{});
2097 std::uint32_t const seqno = //
2098 ac.view().rules().enabled(featureSingleAssetVault) //
2099 ? 0 //
2100 : sequence;
2101 sleAccount->setFieldU32(sfSequence, seqno);
2102 sleAccount->setFieldU32(
2103 sfFlags, lsfDisableMaster | lsfDefaultRipple | lsfDepositAuth);
2104 sleAccount->setFieldH256(sfVaultID, vaultKeylet.key);
2105 ac.view().insert(sleAccount);
2106
2107 auto const sharesMptId = makeMptID(sequence, pseudoId);
2108 auto const sharesKeylet = keylet::mptokenIssuance(sharesMptId);
2109 auto const sleShares = std::make_shared<SLE>(sharesKeylet);
2110 auto const sharesPage = ac.view().dirInsert(
2111 keylet::ownerDir(pseudoId), sharesKeylet, describeOwnerDir(pseudoId));
2112 sleShares->setFieldU64(sfOwnerNode, *sharesPage);
2113
2114 sleShares->at(sfFlags) = 0;
2115 sleShares->at(sfIssuer) = pseudoId;
2116 sleShares->at(sfOutstandingAmount) = 0;
2117 sleShares->at(sfSequence) = sequence;
2118
2119 sleVault->at(sfAccount) = pseudoId;
2120 sleVault->at(sfFlags) = 0;
2121 sleVault->at(sfSequence) = sequence;
2122 sleVault->at(sfOwner) = a1.id();
2123 sleVault->at(sfAssetsTotal) = Number(0);
2124 sleVault->at(sfAssetsAvailable) = Number(0);
2125 sleVault->at(sfLossUnrealized) = Number(0);
2126 sleVault->at(sfShareMPTID) = sharesMptId;
2127 sleVault->at(sfWithdrawalPolicy) = kVaultStrategyFirstComeFirstServe;
2128
2129 ac.view().insert(sleVault);
2130 ac.view().insert(sleShares);
2131 return true;
2132 },
2133 XRPAmount{},
2134 STTx{ttVAULT_SET, [](STObject&) {}},
2136
2137 doInvariantCheck(
2138 {
2139 "shares issuer and vault pseudo-account must be the same",
2140 "shares issuer pseudo-account must point back to the vault",
2141 },
2142 [&](Account const& a1, Account const& a2, ApplyContext& ac) {
2143 auto const sequence = ac.view().seq();
2144 auto const vaultKeylet = keylet::vault(a1.id(), SeqProxy::rawSequence(sequence));
2145 auto const sleVault = std::make_shared<SLE>(vaultKeylet);
2146 auto const vaultPage = ac.view().dirInsert(
2147 keylet::ownerDir(a1.id()), sleVault->key(), describeOwnerDir(a1.id()));
2148 sleVault->setFieldU64(sfOwnerNode, *vaultPage);
2149
2150 auto const pseudoId = pseudoAccountAddress(ac.view(), vaultKeylet.key);
2151 // Create pseudo-account.
2152 auto const sleAccount = std::make_shared<SLE>(keylet::account(pseudoId));
2153 sleAccount->setAccountID(sfAccount, pseudoId);
2154 sleAccount->setFieldAmount(sfBalance, STAmount{});
2155 std::uint32_t const seqno = //
2156 ac.view().rules().enabled(featureSingleAssetVault) //
2157 ? 0 //
2158 : sequence;
2159 sleAccount->setFieldU32(sfSequence, seqno);
2160 sleAccount->setFieldU32(
2161 sfFlags, lsfDisableMaster | lsfDefaultRipple | lsfDepositAuth);
2162 // sleAccount->setFieldH256(sfVaultID, vaultKeylet.key);
2163 // Setting wrong vault key
2164 sleAccount->setFieldH256(sfVaultID, UInt256(42));
2165 ac.view().insert(sleAccount);
2166
2167 auto const sharesMptId = makeMptID(sequence, pseudoId);
2168 auto const sharesKeylet = keylet::mptokenIssuance(sharesMptId);
2169 auto const sleShares = std::make_shared<SLE>(sharesKeylet);
2170 auto const sharesPage = ac.view().dirInsert(
2171 keylet::ownerDir(pseudoId), sharesKeylet, describeOwnerDir(pseudoId));
2172 sleShares->setFieldU64(sfOwnerNode, *sharesPage);
2173
2174 sleShares->at(sfFlags) = 0;
2175 sleShares->at(sfIssuer) = pseudoId;
2176 sleShares->at(sfOutstandingAmount) = 0;
2177 sleShares->at(sfSequence) = sequence;
2178
2179 // sleVault->at(sfAccount) = pseudoId;
2180 // Setting wrong pseudo account ID
2181 sleVault->at(sfAccount) = a2.id();
2182 sleVault->at(sfFlags) = 0;
2183 sleVault->at(sfSequence) = sequence;
2184 sleVault->at(sfOwner) = a1.id();
2185 sleVault->at(sfAssetsTotal) = Number(0);
2186 sleVault->at(sfAssetsAvailable) = Number(0);
2187 sleVault->at(sfLossUnrealized) = Number(0);
2188 sleVault->at(sfShareMPTID) = sharesMptId;
2189 sleVault->at(sfWithdrawalPolicy) = kVaultStrategyFirstComeFirstServe;
2190
2191 ac.view().insert(sleVault);
2192 ac.view().insert(sleShares);
2193 return true;
2194 },
2195 XRPAmount{},
2196 STTx{ttVAULT_CREATE, [](STObject&) {}},
2198
2199 doInvariantCheck(
2200 {"shares issuer and vault pseudo-account must be the same", "shares issuer must exist"},
2201 [&](Account const& a1, Account const& a2, ApplyContext& ac) {
2202 auto const sequence = ac.view().seq();
2203 auto const vaultKeylet = keylet::vault(a1.id(), SeqProxy::rawSequence(sequence));
2204 auto const sleVault = std::make_shared<SLE>(vaultKeylet);
2205 auto const vaultPage = ac.view().dirInsert(
2206 keylet::ownerDir(a1.id()), sleVault->key(), describeOwnerDir(a1.id()));
2207 sleVault->setFieldU64(sfOwnerNode, *vaultPage);
2208
2209 auto const sharesMptId = makeMptID(sequence, a2.id());
2210 auto const sharesKeylet = keylet::mptokenIssuance(sharesMptId);
2211 auto const sleShares = std::make_shared<SLE>(sharesKeylet);
2212 auto const sharesPage = ac.view().dirInsert(
2213 keylet::ownerDir(a2.id()), sharesKeylet, describeOwnerDir(a2.id()));
2214 sleShares->setFieldU64(sfOwnerNode, *sharesPage);
2215
2216 sleShares->at(sfFlags) = 0;
2217 // Setting wrong pseudo account ID
2218 sleShares->at(sfIssuer) = AccountID(42);
2219 sleShares->at(sfOutstandingAmount) = 0;
2220 sleShares->at(sfSequence) = sequence;
2221
2222 sleVault->at(sfAccount) = a2.id();
2223 sleVault->at(sfFlags) = 0;
2224 sleVault->at(sfSequence) = sequence;
2225 sleVault->at(sfOwner) = a1.id();
2226 sleVault->at(sfAssetsTotal) = Number(0);
2227 sleVault->at(sfAssetsAvailable) = Number(0);
2228 sleVault->at(sfLossUnrealized) = Number(0);
2229 sleVault->at(sfShareMPTID) = sharesMptId;
2230 sleVault->at(sfWithdrawalPolicy) = kVaultStrategyFirstComeFirstServe;
2231
2232 ac.view().insert(sleVault);
2233 ac.view().insert(sleShares);
2234 return true;
2235 },
2236 XRPAmount{},
2237 STTx{ttVAULT_CREATE, [](STObject&) {}},
2239
2240 testcase << "Vault deposit";
2241 doInvariantCheck(
2242 {"deposit must change vault balance"},
2243 [&](Account const& a1, Account const& a2, ApplyContext& ac) {
2244 auto const keylet = keylet::vault(a1.id(), SeqProxy::rawSequence(ac.view().seq()));
2245 return kAdjust(ac.view(), keylet, kArgs(a2.id(), 0, [](Adjustments& sample) {
2246 sample.vaultAssets.reset();
2247 }));
2248 },
2249 XRPAmount{},
2250 STTx{ttVAULT_DEPOSIT, [](STObject&) {}},
2252 precloseXrp);
2253
2254 doInvariantCheck(
2255 {"deposit assets outstanding must not exceed assets maximum"},
2256 [&](Account const& a1, Account const& a2, ApplyContext& ac) {
2257 auto const keylet = keylet::vault(a1.id(), SeqProxy::rawSequence(ac.view().seq()));
2258 return kAdjust(ac.view(), keylet, kArgs(a2.id(), 200, [&](Adjustments& sample) {
2259 sample.assetsMaximum = 1;
2260 }));
2261 },
2262 XRPAmount{},
2263 STTx{
2264 ttVAULT_DEPOSIT, [](STObject& tx) { tx.setFieldAmount(sfAmount, XRPAmount(200)); }},
2266 precloseXrp,
2267 TxAccount::A2);
2268
2269 // This really convoluted unit tests makes the zero balance on the
2270 // depositor, by sending them the same amount as the transaction fee.
2271 // The operation makes no sense, but the defensive check in
2272 // ValidVault::finalize is otherwise impossible to trigger.
2273 doInvariantCheck(
2274 {"deposit must increase vault balance", "deposit must change depositor balance"},
2275 [&](Account const& a1, Account const& a2, ApplyContext& ac) {
2276 auto const keylet = keylet::vault(a1.id(), SeqProxy::rawSequence(ac.view().seq()));
2277
2278 // Move 10 drops to A4 to enforce total XRP balance
2279 auto const sleA4 = ac.view().peek(keylet::account(a4.id()));
2280 if (!sleA4)
2281 return false;
2282 (*sleA4)[sfBalance] = *(*sleA4)[sfBalance] + 10;
2283 ac.view().update(sleA4);
2284
2285 return kAdjust(ac.view(), keylet, kArgs(a3.id(), -10, [&](Adjustments& sample) {
2286 sample.accountAssets->amount = -100;
2287 }));
2288 },
2289 XRPAmount{100},
2290 STTx{
2291 ttVAULT_DEPOSIT,
2292 [&](STObject& tx) {
2293 tx[sfFee] = XRPAmount(100);
2294 tx[sfAccount] = a3.id();
2295 }},
2297 precloseXrp);
2298
2299 doInvariantCheck(
2300 {
2301 "deposit must increase vault balance",
2302 "deposit must decrease depositor balance",
2303 "deposit must change vault and depositor balance by equal amount",
2304 // FixedPrecision: only AssetsAvailable's delta is compared; the
2305 // stored AssetsTotal is a derived cache.
2306 "deposit and assets available must add up",
2307 },
2308 [&](Account const& a1, Account const& a2, ApplyContext& ac) {
2309 auto const keylet = keylet::vault(a1.id(), SeqProxy::rawSequence(ac.view().seq()));
2310
2311 // Move 10 drops from A2 to A3 to enforce total XRP balance
2312 auto const sleA3 = ac.view().peek(keylet::account(a3.id()));
2313 if (!sleA3)
2314 return false;
2315 (*sleA3)[sfBalance] = *(*sleA3)[sfBalance] + 10;
2316 ac.view().update(sleA3);
2317
2318 return kAdjust(ac.view(), keylet, kArgs(a2.id(), 10, [&](Adjustments& sample) {
2319 sample.vaultAssets = -20;
2320 sample.accountAssets->amount = 10;
2321 }));
2322 },
2323 XRPAmount{},
2324 STTx{ttVAULT_DEPOSIT, [](STObject& tx) { tx[sfAmount] = XRPAmount(10); }},
2326 precloseXrp,
2327 TxAccount::A2);
2328
2329 doInvariantCheck(
2330 {"deposit must change depositor balance"},
2331 [&](Account const& a1, Account const& a2, ApplyContext& ac) {
2332 auto const keylet = keylet::vault(a1.id(), SeqProxy::rawSequence(ac.view().seq()));
2333
2334 // Move 10 drops from A3 to vault to enforce total XRP balance
2335 auto const sleA3 = ac.view().peek(keylet::account(a3.id()));
2336 if (!sleA3)
2337 return false;
2338 (*sleA3)[sfBalance] = *(*sleA3)[sfBalance] - 10;
2339 ac.view().update(sleA3);
2340
2341 return kAdjust(ac.view(), keylet, kArgs(a2.id(), 10, [&](Adjustments& sample) {
2342 sample.accountAssets->amount = 0;
2343 }));
2344 },
2345 XRPAmount{},
2346 STTx{ttVAULT_DEPOSIT, [](STObject& tx) { tx[sfAmount] = XRPAmount(10); }},
2348 precloseXrp,
2349 TxAccount::A2);
2350
2351 doInvariantCheck(
2352 {"deposit must change depositor shares"},
2353 [&](Account const& a1, Account const& a2, ApplyContext& ac) {
2354 auto const keylet = keylet::vault(a1.id(), SeqProxy::rawSequence(ac.view().seq()));
2355 return kAdjust(ac.view(), keylet, kArgs(a2.id(), 10, [&](Adjustments& sample) {
2356 sample.accountShares.reset();
2357 }));
2358 },
2359 XRPAmount{},
2360 STTx{ttVAULT_DEPOSIT, [](STObject& tx) { tx[sfAmount] = XRPAmount(10); }},
2362 precloseXrp,
2363 TxAccount::A2);
2364
2365 doInvariantCheck(
2366 {"deposit must change vault shares"},
2367 [&](Account const& a1, Account const& a2, ApplyContext& ac) {
2368 auto const keylet = keylet::vault(a1.id(), SeqProxy::rawSequence(ac.view().seq()));
2369
2370 return kAdjust(ac.view(), keylet, kArgs(a2.id(), 10, [](Adjustments& sample) {
2371 sample.sharesTotal = 0;
2372 }));
2373 },
2374 XRPAmount{},
2375 STTx{ttVAULT_DEPOSIT, [](STObject& tx) { tx[sfAmount] = XRPAmount(10); }},
2377 precloseXrp,
2378 TxAccount::A2);
2379
2380 doInvariantCheck(
2381 {
2382 "deposit must increase depositor shares",
2383 "deposit must change depositor and vault shares by equal amount",
2384 "deposit must not change vault balance by more than deposited "
2385 "amount",
2386 },
2387 [&](Account const& a1, Account const& a2, ApplyContext& ac) {
2388 auto const keylet = keylet::vault(a1.id(), SeqProxy::rawSequence(ac.view().seq()));
2389 return kAdjust(ac.view(), keylet, kArgs(a2.id(), 10, [&](Adjustments& sample) {
2390 sample.accountShares->amount = -5;
2391 sample.sharesTotal = -10;
2392 }));
2393 },
2394 XRPAmount{},
2395 STTx{ttVAULT_DEPOSIT, [](STObject& tx) { tx[sfAmount] = XRPAmount(5); }},
2397 precloseXrp,
2398 TxAccount::A2);
2399
2400 // AssetsTotal alone is wrong. FixedPrecision does not compare it per
2401 // transaction, so this exercises the Legacy/CashBasis path.
2402 doInvariantCheck(
2403 makeEnv(all_ - featureLendingProtocolV1_2),
2404 {"deposit and assets outstanding must add up"},
2405 [&](Account const& a1, Account const& a2, ApplyContext& ac) {
2406 auto const sleA3 = ac.view().peek(keylet::account(a3.id()));
2407 (*sleA3)[sfBalance] = *(*sleA3)[sfBalance] - 2000;
2408 ac.view().update(sleA3);
2409
2410 auto const keylet = keylet::vault(a1.id(), SeqProxy::rawSequence(ac.view().seq()));
2411 return kAdjust(ac.view(), keylet, kArgs(a2.id(), 10, [&](Adjustments& sample) {
2412 sample.assetsTotal = 11;
2413 }));
2414 },
2415 XRPAmount{2000},
2416 STTx{
2417 ttVAULT_DEPOSIT,
2418 [&](STObject& tx) {
2419 tx[sfAmount] = XRPAmount(10);
2420 tx[sfDelegate] = a3.id();
2421 tx[sfFee] = XRPAmount(2000);
2422 }},
2424 precloseXrp,
2425 TxAccount::A2);
2426
2427 doInvariantCheck(
2428 // FixedPrecision does not compare AssetsTotal's delta.
2429 {
2430 "deposit and assets available must add up",
2431 },
2432 [&](Account const& a1, Account const& a2, ApplyContext& ac) {
2433 auto const keylet = keylet::vault(a1.id(), SeqProxy::rawSequence(ac.view().seq()));
2434 return kAdjust(ac.view(), keylet, kArgs(a2.id(), 10, [&](Adjustments& sample) {
2435 sample.assetsTotal = 7;
2436 sample.assetsAvailable = 7;
2437 }));
2438 },
2439 XRPAmount{},
2440 STTx{ttVAULT_DEPOSIT, [](STObject& tx) { tx[sfAmount] = XRPAmount(10); }},
2442 precloseXrp,
2443 TxAccount::A2);
2444
2445 testcase << "Vault withdrawal";
2446 doInvariantCheck(
2447 {"withdrawal must change vault balance"},
2448 [&](Account const& a1, Account const& a2, ApplyContext& ac) {
2449 auto const keylet = keylet::vault(a1.id(), SeqProxy::rawSequence(ac.view().seq()));
2450 return kAdjust(ac.view(), keylet, kArgs(a2.id(), 0, [](Adjustments& sample) {
2451 sample.vaultAssets.reset();
2452 }));
2453 },
2454 XRPAmount{},
2455 STTx{ttVAULT_WITHDRAW, [](STObject&) {}},
2457 precloseXrp);
2458
2459 // Almost identical to the really convoluted test for deposit, where the
2460 // depositor spends only the transaction fee. In case of withdrawal,
2461 // this test is almost the same as normal withdrawal where the
2462 // sfDestination would have been A4, but has been omitted.
2463 doInvariantCheck(
2464 {"withdrawal must change one destination balance"},
2465 [&](Account const& a1, Account const& a2, ApplyContext& ac) {
2466 auto const keylet = keylet::vault(a1.id(), SeqProxy::rawSequence(ac.view().seq()));
2467
2468 // Move 10 drops to A4 to enforce total XRP balance
2469 auto const sleA4 = ac.view().peek(keylet::account(a4.id()));
2470 if (!sleA4)
2471 return false;
2472 (*sleA4)[sfBalance] = *(*sleA4)[sfBalance] + 10;
2473 ac.view().update(sleA4);
2474
2475 return kAdjust(ac.view(), keylet, kArgs(a3.id(), -10, [&](Adjustments& sample) {
2476 sample.accountAssets->amount = -100;
2477 }));
2478 },
2479 XRPAmount{100},
2480 STTx{
2481 ttVAULT_WITHDRAW,
2482 [&](STObject& tx) {
2483 tx[sfFee] = XRPAmount(100);
2484 tx[sfAccount] = a3.id();
2485 // This commented out line causes the invariant violation.
2486 // tx[sfDestination] = A4.id();
2487 }},
2489 precloseXrp);
2490
2491 doInvariantCheck(
2492 {
2493 "withdrawal must change vault and destination balance by equal amount",
2494 "withdrawal must decrease vault balance",
2495 "withdrawal must increase destination balance",
2496 // FixedPrecision does not compare AssetsTotal's delta.
2497 "withdrawal and assets available must add up",
2498 },
2499 [&](Account const& a1, Account const& a2, ApplyContext& ac) {
2500 auto const keylet = keylet::vault(a1.id(), SeqProxy::rawSequence(ac.view().seq()));
2501
2502 // Move 10 drops from A2 to A3 to enforce total XRP balance
2503 auto const sleA3 = ac.view().peek(keylet::account(a3.id()));
2504 if (!sleA3)
2505 return false;
2506 (*sleA3)[sfBalance] = *(*sleA3)[sfBalance] + 10;
2507 ac.view().update(sleA3);
2508
2509 return kAdjust(ac.view(), keylet, kArgs(a2.id(), -10, [&](Adjustments& sample) {
2510 sample.vaultAssets = 10;
2511 sample.accountAssets->amount = -20;
2512 }));
2513 },
2514 XRPAmount{},
2515 STTx{ttVAULT_WITHDRAW, [](STObject&) {}},
2517 precloseXrp,
2518 TxAccount::A2);
2519
2520 doInvariantCheck(
2521 {"withdrawal must change one destination balance"},
2522 [&](Account const& a1, Account const& a2, ApplyContext& ac) {
2523 auto const keylet = keylet::vault(a1.id(), SeqProxy::rawSequence(ac.view().seq()));
2524 if (!kAdjust(ac.view(), keylet, kArgs(a2.id(), -10, [&](Adjustments& sample) {
2525 *sample.vaultAssets -= 5;
2526 })))
2527 return false;
2528 auto const sleA3 = ac.view().peek(keylet::account(a3.id()));
2529 if (!sleA3)
2530 return false;
2531 (*sleA3)[sfBalance] = *(*sleA3)[sfBalance] + 5;
2532 ac.view().update(sleA3);
2533 return true;
2534 },
2535 XRPAmount{},
2536 STTx{ttVAULT_WITHDRAW, [&](STObject& tx) { tx.setAccountID(sfDestination, a3.id()); }},
2538 precloseXrp,
2539 TxAccount::A2);
2540
2541 doInvariantCheck(
2542 {"withdrawal must change depositor shares"},
2543 [&](Account const& a1, Account const& a2, ApplyContext& ac) {
2544 auto const keylet = keylet::vault(a1.id(), SeqProxy::rawSequence(ac.view().seq()));
2545 return kAdjust(ac.view(), keylet, kArgs(a2.id(), -10, [&](Adjustments& sample) {
2546 sample.accountShares.reset();
2547 }));
2548 },
2549 XRPAmount{},
2550 STTx{ttVAULT_WITHDRAW, [](STObject&) {}},
2552 precloseXrp,
2553 TxAccount::A2);
2554
2555 doInvariantCheck(
2556 {"withdrawal must change vault shares"},
2557 [&](Account const& a1, Account const& a2, ApplyContext& ac) {
2558 auto const keylet = keylet::vault(a1.id(), SeqProxy::rawSequence(ac.view().seq()));
2559 return kAdjust(ac.view(), keylet, kArgs(a2.id(), -10, [](Adjustments& sample) {
2560 sample.sharesTotal = 0;
2561 }));
2562 },
2563 XRPAmount{},
2564 STTx{ttVAULT_WITHDRAW, [](STObject&) {}},
2566 precloseXrp,
2567 TxAccount::A2);
2568
2569 doInvariantCheck(
2570 {
2571 "withdrawal must decrease depositor shares",
2572 "withdrawal must change depositor and vault shares by equal "
2573 "amount",
2574 },
2575 [&](Account const& a1, Account const& a2, ApplyContext& ac) {
2576 auto const keylet = keylet::vault(a1.id(), SeqProxy::rawSequence(ac.view().seq()));
2577 return kAdjust(ac.view(), keylet, kArgs(a2.id(), -10, [&](Adjustments& sample) {
2578 sample.accountShares->amount = 5;
2579 sample.sharesTotal = 10;
2580 }));
2581 },
2582 XRPAmount{},
2583 STTx{ttVAULT_WITHDRAW, [](STObject&) {}},
2585 precloseXrp,
2586 TxAccount::A2);
2587
2588 doInvariantCheck(
2589 // FixedPrecision does not compare AssetsTotal's delta.
2590 {
2591 "withdrawal and assets available must add up",
2592 },
2593 [&](Account const& a1, Account const& a2, ApplyContext& ac) {
2594 auto const keylet = keylet::vault(a1.id(), SeqProxy::rawSequence(ac.view().seq()));
2595 return kAdjust(ac.view(), keylet, kArgs(a2.id(), -10, [&](Adjustments& sample) {
2596 sample.assetsTotal = -15;
2597 sample.assetsAvailable = -15;
2598 }));
2599 },
2600 XRPAmount{},
2601 STTx{ttVAULT_WITHDRAW, [](STObject&) {}},
2603 precloseXrp,
2604 TxAccount::A2);
2605
2606 // AssetsTotal alone is wrong. FixedPrecision does not compare it per
2607 // transaction, so this exercises the Legacy/CashBasis path.
2608 doInvariantCheck(
2609 makeEnv(all_ - featureLendingProtocolV1_2),
2610 {"withdrawal and assets outstanding must add up"},
2611 [&](Account const& a1, Account const& a2, ApplyContext& ac) {
2612 auto const sleA3 = ac.view().peek(keylet::account(a3.id()));
2613 (*sleA3)[sfBalance] = *(*sleA3)[sfBalance] - 2000;
2614 ac.view().update(sleA3);
2615
2616 auto const keylet = keylet::vault(a1.id(), SeqProxy::rawSequence(ac.view().seq()));
2617 return kAdjust(ac.view(), keylet, kArgs(a2.id(), -10, [&](Adjustments& sample) {
2618 sample.assetsTotal = -7;
2619 }));
2620 },
2621 XRPAmount{2000},
2622 STTx{
2623 ttVAULT_WITHDRAW,
2624 [&](STObject& tx) {
2625 tx[sfAmount] = XRPAmount(10);
2626 tx[sfDelegate] = a3.id();
2627 tx[sfFee] = XRPAmount(2000);
2628 }},
2630 precloseXrp,
2631 TxAccount::A2);
2632
2633 auto const precloseMpt = [&](Account const& a1, Account const& a2, Env& env) -> bool {
2634 env.fund(XRP(1000), a3, a4);
2635
2636 // Create MPT asset
2637 {
2638 json::Value jv;
2639 jv[sfAccount] = a3.human();
2640 jv[sfTransactionType] = jss::MPTokenIssuanceCreate;
2641 jv[sfFlags] = tfMPTCanTransfer;
2642 env(jv);
2643 env.close();
2644 }
2645
2646 auto const mptID = makeMptID(env.seq(a3) - 1, a3);
2647 Asset const asset = MPTIssue(mptID);
2648 // Authorize A1 A2 A4
2649 {
2650 json::Value jv;
2651 jv[sfAccount] = a1.human();
2652 jv[sfTransactionType] = jss::MPTokenAuthorize;
2653 jv[sfMPTokenIssuanceID] = to_string(mptID);
2654 env(jv);
2655 jv[sfAccount] = a2.human();
2656 env(jv);
2657 jv[sfAccount] = a4.human();
2658 env(jv);
2659
2660 env.close();
2661 }
2662 // Send tokens to A1 A2 A4
2663 {
2664 env(pay(a3, a1, asset(1000)));
2665 env(pay(a3, a2, asset(1000)));
2666 env(pay(a3, a4, asset(1000)));
2667 env.close();
2668 }
2669
2670 Vault const vault{env};
2671 auto [tx, keylet] = vault.create({.owner = a1, .asset = asset});
2672 env(tx);
2673 env(vault.deposit({.depositor = a1, .id = keylet.key, .amount = asset(10)}));
2674 env(vault.deposit({.depositor = a2, .id = keylet.key, .amount = asset(10)}));
2675 env(vault.deposit({.depositor = a4, .id = keylet.key, .amount = asset(10)}));
2676 return true;
2677 };
2678
2679 doInvariantCheck(
2680 {
2681 "withdrawal must decrease depositor shares",
2682 "withdrawal must change depositor and vault shares by equal "
2683 "amount",
2684 },
2685 [&](Account const& a1, Account const& a2, ApplyContext& ac) {
2686 auto const keylet =
2687 keylet::vault(a1.id(), SeqProxy::rawSequence(ac.view().seq() - 2));
2688 return kAdjust(ac.view(), keylet, kArgs(a2.id(), -10, [&](Adjustments& sample) {
2689 sample.accountShares->amount = 5;
2690 }));
2691 },
2692 XRPAmount{},
2693 STTx{ttVAULT_WITHDRAW, [&](STObject& tx) { tx[sfAccount] = a3.id(); }},
2695 precloseMpt,
2696 TxAccount::A2);
2697
2698 testcase << "Vault clawback";
2699 doInvariantCheck(
2700 {"clawback must change vault balance"},
2701 [&](Account const& a1, Account const& a2, ApplyContext& ac) {
2702 auto const keylet =
2703 keylet::vault(a1.id(), SeqProxy::rawSequence(ac.view().seq() - 2));
2704 return kAdjust(ac.view(), keylet, kArgs(a2.id(), -1, [&](Adjustments& sample) {
2705 sample.vaultAssets.reset();
2706 }));
2707 },
2708 XRPAmount{},
2709 STTx{ttVAULT_CLAWBACK, [&](STObject& tx) { tx[sfAccount] = a3.id(); }},
2711 precloseMpt);
2712
2713 // Not the same as below check: attempt to clawback XRP
2714 doInvariantCheck(
2715 {"clawback may only be performed by the asset issuer"},
2716 [&](Account const& a1, Account const& a2, ApplyContext& ac) {
2717 auto const keylet = keylet::vault(a1.id(), SeqProxy::rawSequence(ac.view().seq()));
2718 return kAdjust(ac.view(), keylet, kArgs(a2.id(), 0, [&](Adjustments& sample) {}));
2719 },
2720 XRPAmount{},
2721 STTx{ttVAULT_CLAWBACK, [](STObject&) {}},
2723 precloseXrp);
2724
2725 // Not the same as above check: attempt to clawback MPT by bad account
2726 doInvariantCheck(
2727 {"clawback may only be performed by the asset issuer"},
2728 [&](Account const& a1, Account const& a2, ApplyContext& ac) {
2729 auto const keylet =
2730 keylet::vault(a1.id(), SeqProxy::rawSequence(ac.view().seq() - 2));
2731 return kAdjust(ac.view(), keylet, kArgs(a2.id(), 0, [&](Adjustments& sample) {}));
2732 },
2733 XRPAmount{},
2734 STTx{ttVAULT_CLAWBACK, [&](STObject& tx) { tx[sfAccount] = a4.id(); }},
2736 precloseMpt);
2737
2738 doInvariantCheck(
2739 {
2740 "clawback must decrease vault balance",
2741 "clawback must decrease holder shares",
2742 "clawback must change vault shares",
2743 },
2744 [&](Account const& a1, Account const& a2, ApplyContext& ac) {
2745 auto const keylet =
2746 keylet::vault(a1.id(), SeqProxy::rawSequence(ac.view().seq() - 2));
2747 return kAdjust(ac.view(), keylet, kArgs(a4.id(), 10, [&](Adjustments& sample) {
2748 sample.sharesTotal = 0;
2749 }));
2750 },
2751 XRPAmount{},
2752 STTx{
2753 ttVAULT_CLAWBACK,
2754 [&](STObject& tx) {
2755 tx[sfAccount] = a3.id();
2756 tx[sfHolder] = a4.id();
2757 }},
2759 precloseMpt);
2760
2761 doInvariantCheck(
2762 {"clawback must change holder shares"},
2763 [&](Account const& a1, Account const& a2, ApplyContext& ac) {
2764 auto const keylet =
2765 keylet::vault(a1.id(), SeqProxy::rawSequence(ac.view().seq() - 2));
2766 return kAdjust(ac.view(), keylet, kArgs(a4.id(), -10, [&](Adjustments& sample) {
2767 sample.accountShares.reset();
2768 }));
2769 },
2770 XRPAmount{},
2771 STTx{
2772 ttVAULT_CLAWBACK,
2773 [&](STObject& tx) {
2774 tx[sfAccount] = a3.id();
2775 tx[sfHolder] = a4.id();
2776 }},
2778 precloseMpt);
2779
2780 doInvariantCheck(
2781 {
2782 "clawback must change holder and vault shares by equal amount",
2783 // FixedPrecision does not compare AssetsTotal's delta.
2784 "clawback and assets available must add up",
2785 },
2786 [&](Account const& a1, Account const& a2, ApplyContext& ac) {
2787 auto const keylet =
2788 keylet::vault(a1.id(), SeqProxy::rawSequence(ac.view().seq() - 2));
2789 return kAdjust(ac.view(), keylet, kArgs(a4.id(), -10, [&](Adjustments& sample) {
2790 sample.accountShares->amount = -8;
2791 sample.assetsTotal = -7;
2792 sample.assetsAvailable = -7;
2793 }));
2794 },
2795 XRPAmount{},
2796 STTx{
2797 ttVAULT_CLAWBACK,
2798 [&](STObject& tx) {
2799 tx[sfAccount] = a3.id();
2800 tx[sfHolder] = a4.id();
2801 }},
2803 precloseMpt);
2804
2805 // ─────────────────────────────────────────────────────────────
2806 // Closed-ended vault invariants added in ValidVault::finalize (create must supply both
2807 // dates and satisfy the redemption-buffer gap), deposit only in Subscription / NoPhase,
2808 // withdraw not in Investment, loan origination only in Investment.
2809
2810 using D = NetClock::duration;
2811 using Tp = NetClock::time_point;
2812
2813 auto const closedEnded = std::to_underlying(VaultKind::ClosedEnded);
2814
2815 // Vault keylet captured by precloseClosedEnded so precheck does not have to rederive it
2816 // from ac.view().seq(), which depends on how many env.close() calls preclose issued.
2817 Keylet closedEndedKeylet = keylet::amendments();
2818
2819 // Preclose that creates a closed-ended vault (in Subscription), optionally seeds it with
2820 // three deposits (so a1/a2/a3 hold a share MPToken that kAdjust can then adjust), and
2821 // optionally advances parent close time past SubscriptionDate. A negative @p advanceBySub
2822 // leaves the vault in Subscription.
2823 auto const precloseClosedEnded = [&](std::int32_t advanceBySub, bool doDeposit) {
2824 return [&, advanceBySub, doDeposit](
2825 Account const& a1, Account const& a2, Env& env) -> bool {
2826 env.fund(XRP(1000), a3, a4);
2827 auto const sub = env.now().time_since_epoch().count() + 60;
2828 auto const red = sub + kMinInvestmentPeriod + 1'000'000;
2829 Vault const vault{env};
2830 auto [tx, keylet] = vault.create({
2831 .owner = a1,
2832 .asset = xrpIssue(),
2833 .vaultKind = closedEnded,
2834 .subscriptionDate = sub,
2835 .redemptionDate = red,
2836 });
2837 env(tx);
2838 closedEndedKeylet = keylet;
2839 if (doDeposit)
2840 {
2841 env(vault.deposit({.depositor = a1, .id = keylet.key, .amount = XRP(10)}));
2842 env(vault.deposit({.depositor = a2, .id = keylet.key, .amount = XRP(10)}));
2843 env(vault.deposit({.depositor = a3, .id = keylet.key, .amount = XRP(10)}));
2844 }
2845 if (advanceBySub >= 0)
2846 env.close(Tp{D{sub + advanceBySub}});
2847 return true;
2848 };
2849 };
2850
2851 // Manually insert a bare closed-ended vault (+ pseudo-account + share MPTokenIssuance)
2852 // directly into the view, bypassing the transactor path. Used to synthesize ttVAULT_CREATE
2853 // states no legitimate transactor would produce.
2854 auto const insertBareClosedEndedVault =
2855 [closedEnded](
2856 ApplyContext& ac,
2857 Account const& owner,
2858 std::optional<std::uint32_t> subscriptionDate,
2859 std::optional<std::uint32_t> redemptionDate) -> bool {
2860 auto const sequence = ac.view().seq();
2861 auto const vaultKeylet = keylet::vault(owner.id(), SeqProxy::rawSequence(sequence));
2862 auto const sleVault = std::make_shared<SLE>(vaultKeylet);
2863 auto const vaultPage = ac.view().dirInsert(
2864 keylet::ownerDir(owner.id()), sleVault->key(), describeOwnerDir(owner.id()));
2865 if (!vaultPage)
2866 return false;
2867 sleVault->setFieldU64(sfOwnerNode, *vaultPage);
2868
2869 auto const pseudoId = pseudoAccountAddress(ac.view(), vaultKeylet.key);
2870 auto const sleAccount = std::make_shared<SLE>(keylet::account(pseudoId));
2871 sleAccount->setAccountID(sfAccount, pseudoId);
2872 sleAccount->setFieldAmount(sfBalance, STAmount{});
2873 sleAccount->setFieldU32(sfSequence, 0);
2874 sleAccount->setFieldU32(sfFlags, lsfDisableMaster | lsfDefaultRipple | lsfDepositAuth);
2875 sleAccount->setFieldH256(sfVaultID, vaultKeylet.key);
2876 ac.view().insert(sleAccount);
2877
2878 auto const sharesMptId = makeMptID(sequence, pseudoId);
2879 auto const sharesKeylet = keylet::mptokenIssuance(sharesMptId);
2880 auto const sleShares = std::make_shared<SLE>(sharesKeylet);
2881 auto const sharesPage = ac.view().dirInsert(
2882 keylet::ownerDir(pseudoId), sharesKeylet, describeOwnerDir(pseudoId));
2883 if (!sharesPage)
2884 return false;
2885 sleShares->setFieldU64(sfOwnerNode, *sharesPage);
2886 sleShares->at(sfFlags) = 0;
2887 sleShares->at(sfIssuer) = pseudoId;
2888 sleShares->at(sfOutstandingAmount) = 0;
2889 sleShares->at(sfSequence) = sequence;
2890
2891 sleVault->at(sfAccount) = pseudoId;
2892 sleVault->at(sfFlags) = 0;
2893 sleVault->at(sfSequence) = sequence;
2894 sleVault->at(sfOwner) = owner.id();
2895 sleVault->setFieldIssue(sfAsset, STIssue{sfAsset, Asset{xrpIssue()}});
2896 sleVault->at(sfAssetsTotal) = Number(0);
2897 sleVault->at(sfAssetsAvailable) = Number(0);
2898 sleVault->at(sfLossUnrealized) = Number(0);
2899 sleVault->at(sfShareMPTID) = sharesMptId;
2900 sleVault->at(sfWithdrawalPolicy) = kVaultStrategyFirstComeFirstServe;
2901 sleVault->at(sfVaultKind) = closedEnded;
2902 if (subscriptionDate)
2903 sleVault->at(sfSubscriptionDate) = *subscriptionDate;
2904 if (redemptionDate)
2905 sleVault->at(sfRedemptionDate) = *redemptionDate;
2906
2907 ac.view().insert(sleVault);
2908 ac.view().insert(sleShares);
2909 return true;
2910 };
2911
2912 testcase << "Vault create closed-ended";
2913
2914 // A fresh closed-ended vault must carry both SubscriptionDate and RedemptionDate.
2915 doInvariantCheck(
2916 {"closed-ended vault must have SubscriptionDate and RedemptionDate"},
2917 [&](Account const& a1, Account const&, ApplyContext& ac) {
2918 return insertBareClosedEndedVault(ac, a1, std::nullopt, std::nullopt);
2919 },
2920 XRPAmount{},
2921 STTx{ttVAULT_CREATE, [](STObject&) {}},
2923
2924 // Gap smaller than MIN_INVESTMENT_PERIOD but with RedemptionDate > SubscriptionDate;
2925 // exercises the sub-minimum branch of the gap check.
2926 doInvariantCheck(
2927 {
2928 "closed-ended vault RedemptionDate - SubscriptionDate must be "
2929 "within [MIN_INVESTMENT_PERIOD, MAX_INVESTMENT_PERIOD)",
2930 },
2931 [&](Account const& a1, Account const&, ApplyContext& ac) {
2932 std::uint32_t const sub = 1'000'000'000;
2933 std::uint32_t const red = sub + kMinInvestmentPeriod - 1;
2934 return insertBareClosedEndedVault(ac, a1, sub, red);
2935 },
2936 XRPAmount{},
2937 STTx{ttVAULT_CREATE, [](STObject&) {}},
2939
2940 // RedemptionDate strictly before SubscriptionDate; the signed int64 gap is negative and
2941 // is caught by the sub-minimum branch of the gap check.
2942 doInvariantCheck(
2943 {
2944 "closed-ended vault RedemptionDate - SubscriptionDate must be "
2945 "within [MIN_INVESTMENT_PERIOD, MAX_INVESTMENT_PERIOD)",
2946 },
2947 [&](Account const& a1, Account const&, ApplyContext& ac) {
2948 std::uint32_t const sub = 1'000'000'000;
2949 std::uint32_t const red = sub - 1;
2950 return insertBareClosedEndedVault(ac, a1, sub, red);
2951 },
2952 XRPAmount{},
2953 STTx{ttVAULT_CREATE, [](STObject&) {}},
2955
2956 // Gap exactly MAX_INVESTMENT_PERIOD is out of range (bound is half-open on the right).
2957 doInvariantCheck(
2958 {
2959 "closed-ended vault RedemptionDate - SubscriptionDate must be "
2960 "within [MIN_INVESTMENT_PERIOD, MAX_INVESTMENT_PERIOD)",
2961 },
2962 [&](Account const& a1, Account const&, ApplyContext& ac) {
2963 std::uint32_t const sub = 1'000'000'000;
2964 std::uint32_t const red = sub + kMaxInvestmentPeriod;
2965 return insertBareClosedEndedVault(ac, a1, sub, red);
2966 },
2967 XRPAmount{},
2968 STTx{ttVAULT_CREATE, [](STObject&) {}},
2970
2971 testcase << "Vault deposit closed-ended";
2972
2973 // A deposit into a closed-ended vault that has advanced past SubscriptionDate. kArgs
2974 // simulates an otherwise valid deposit shape so only the phase invariant fires.
2975 doInvariantCheck(
2976 {"deposit only allowed in Subscription or NoPhase"},
2977 [&](Account const&, Account const& a2, ApplyContext& ac) {
2978 return kAdjust(
2979 ac.view(), closedEndedKeylet, kArgs(a2.id(), 10, [](Adjustments&) {}));
2980 },
2981 XRPAmount{},
2982 STTx{ttVAULT_DEPOSIT, [](STObject& tx) { tx[sfAmount] = XRPAmount(10); }},
2984 precloseClosedEnded(/*advanceBySub=*/1, /*doDeposit=*/true),
2985 TxAccount::A2);
2986
2987 testcase << "Vault withdrawal closed-ended";
2988
2989 // A withdrawal from a closed-ended vault in the Investment phase.
2990 doInvariantCheck(
2991 {"withdrawal not allowed during Investment phase"},
2992 [&](Account const&, Account const& a2, ApplyContext& ac) {
2993 return kAdjust(
2994 ac.view(), closedEndedKeylet, kArgs(a2.id(), -10, [](Adjustments&) {}));
2995 },
2996 XRPAmount{},
2997 STTx{ttVAULT_WITHDRAW, [](STObject&) {}},
2999 precloseClosedEnded(/*advanceBySub=*/1, /*doDeposit=*/true),
3000 TxAccount::A2);
3001
3002 testcase << "Vault loan set";
3003
3004 // ttLOAN_SET against a closed-ended vault that is not in Investment. finalizeLoanSet fires
3005 // on any vault mutation; touching the vault SLE with no field change is sufficient.
3006 doInvariantCheck(
3007 {"loan origination only allowed in Investment phase"},
3008 [&](Account const&, Account const&, ApplyContext& ac) {
3009 auto const sleVault = ac.view().peek(closedEndedKeylet);
3010 if (!sleVault)
3011 return false;
3012 ac.view().update(sleVault);
3013 return true;
3014 },
3015 XRPAmount{},
3016 STTx{ttLOAN_SET, [](STObject&) {}},
3018 precloseClosedEnded(/*advanceBySub=*/-1, /*doDeposit=*/false));
3019
3020 testcase << "Vault loan set - closed-ended final payment past "
3021 "RedemptionDate";
3022
3023 // A newly-created loan against a closed-ended vault must satisfy StartDate +
3024 // PaymentInterval * PaymentRemaining + kLoanRedemptionBuffer <= RedemptionDate.
3025 // LoanSet::preclaim enforces the same bound; this test synthesises a loan whose
3026 // final payment is still before RedemptionDate (so the old unbuffered check would
3027 // pass) but inside the buffer zone.
3028 Keylet closedEndedBrokerKeylet = keylet::amendments();
3029 std::uint32_t closedEndedRed = 0;
3030 doInvariantCheck(
3031 {
3032 "closed-ended loan final payment must precede RedemptionDate by at least "
3033 "kLoanRedemptionBuffer",
3034 },
3035 [&](Account const& a1, Account const&, ApplyContext& ac) {
3036 // Touch the vault so ValidVault::finalizeLoanSet sees an
3037 // entry in afterVault_; the vault is in Investment, so
3038 // finalizeLoanSet itself passes.
3039 auto const sleVault = ac.view().peek(closedEndedKeylet);
3040 if (!sleVault)
3041 return false;
3042 ac.view().update(sleVault);
3043
3044 // Read the broker's next loan sequence to build the loan
3045 // keylet the same way LoanSet::doApply would.
3046 auto const sleBroker = ac.view().peek(closedEndedBrokerKeylet);
3047 if (!sleBroker)
3048 return false;
3049 std::uint32_t const loanSeq = sleBroker->at(sfLoanSequence);
3050
3051 // Final payment at RedemptionDate - (kLoanRedemptionBuffer - 1): still
3052 // strictly before RedemptionDate, but inside the buffer.
3053 auto const sleLoan = makeLoanSle(closedEndedBrokerKeylet.key, loanSeq, a1.id());
3054 sleLoan->at(sfLoanBrokerID) = closedEndedBrokerKeylet.key;
3055 sleLoan->at(sfLoanSequence) = loanSeq;
3056 sleLoan->at(sfBorrower) = a1.id();
3057 sleLoan->at(sfStartDate) = closedEndedRed - kLoanRedemptionBuffer;
3058 sleLoan->at(sfPaymentInterval) = 1;
3059 sleLoan->at(sfPaymentRemaining) = 1;
3060 sleLoan->at(sfTotalValueOutstanding) = Number(100);
3061 sleLoan->at(sfPeriodicPayment) = Number(1);
3062 ac.view().insert(sleLoan);
3063 return true;
3064 },
3065 XRPAmount{},
3066 STTx{ttLOAN_SET, [](STObject&) {}},
3068 [&](Account const& a1, Account const&, Env& env) -> bool {
3069 auto const sub = env.now().time_since_epoch().count() + 60;
3070 auto const red = sub + kMinInvestmentPeriod + 1'000'000;
3071 closedEndedRed = red;
3072
3073 Vault const vault{env};
3074 auto [tx, keylet] = vault.create({
3075 .owner = a1,
3076 .asset = xrpIssue(),
3077 .vaultKind = closedEnded,
3078 .subscriptionDate = sub,
3079 .redemptionDate = red,
3080 });
3081 env(tx);
3082 closedEndedKeylet = keylet;
3083
3084 // Create the loan broker; LoanBrokerSet has no phase gate.
3085 closedEndedBrokerKeylet =
3086 keylet::loanBroker(a1.id(), SeqProxy::rawSequence(env.seq(a1)));
3087 env(loan_broker::set(a1, keylet.key));
3088
3089 // Advance parent close time into Investment so
3090 // ValidVault::finalizeLoanSet is satisfied.
3091 env.close(Tp{D{sub + 1}});
3092 return true;
3093 });
3094 }
3095
3096 // Minimal impaired-loan setup for testVaultLossExceedsGap. Kept
3097 // inline here so this file has no dependency on LoanTestBase.
3098 Keylet
3100 test::jtx::Account const& owner,
3101 test::jtx::Account const& borrower,
3102 test::jtx::Account const& issuer,
3103 test::jtx::Env& env)
3104 {
3105 using namespace test::jtx;
3106
3107 env.fund(XRP(1'000'000), issuer, borrower);
3108 env.close();
3109
3110 PrettyAsset const usd = issuer["USD"];
3111 STAmount const trustLimit{usd.raw(), Number{9'999'999'999'999'999LL}};
3112 env(trust(owner, trustLimit));
3113 env(trust(borrower, trustLimit));
3114 env.close();
3115
3116 env(pay(issuer, owner, usd(100'000)));
3117 env(pay(issuer, borrower, usd(1'000)));
3118 env.close();
3119
3120 // Under featureLendingProtocolV1_1 LoanBrokerSet::preclaim only
3121 // accepts closed-ended vaults. The 10-year investment window
3122 // covers this helper's 120 monthly payments so LoanSet's
3123 // RedemptionDate bound is satisfied.
3124 Vault const vault{env};
3125 auto [vaultTx, vaultKeylet, subscriptionDate] = vault.createClosedEnded({
3126 .owner = owner,
3127 .asset = usd,
3128 .subscriptionOffset = std::chrono::seconds{60},
3129 .investmentWindow = std::chrono::seconds{10ull * 365ull * 24ull * 60ull * 60ull},
3130 });
3131 env(vaultTx);
3132 env.close();
3133
3134 env(vault.deposit(
3135 {.depositor = owner, .id = vaultKeylet.key, .amount = usd(1'000).value()}));
3136 env.close();
3137
3138 auto const brokerKeylet =
3139 keylet::loanBroker(owner.id(), SeqProxy::rawSequence(env.seq(owner)));
3140
3141 {
3142 using namespace loan_broker;
3143 env(set(owner, vaultKeylet.key),
3144 kCoverRateMinimum(percentageToTenthBips(1)),
3145 kCoverRateLiquidation(xrpl::lending::kMaxCoverRate),
3146 Fee(env.current()->fees().base * 2));
3147 env.close();
3148
3149 env(coverDeposit(owner, brokerKeylet.key, usd(10'000).value()),
3150 Fee(env.current()->fees().base * 2));
3151 env.close();
3152 }
3153
3154 // LoanSet is gated on Investment; advance out of Subscription.
3155 vault.closePastSubscription(subscriptionDate);
3156
3157 auto const brokerSle = env.le(brokerKeylet);
3158 if (!BEAST_EXPECT(brokerSle))
3159 return vaultKeylet;
3160
3161 auto const loanKeylet =
3162 keylet::loan(brokerKeylet.key, SeqProxy::rawSequence(brokerSle->at(sfLoanSequence)));
3163
3164 {
3165 using namespace loan;
3166 env(set(borrower, brokerKeylet.key, usd(100).value()),
3167 kCounterparty(owner),
3168 kInterestRate(TenthBips32{1000}),
3169 kPaymentTotal(120),
3170 kPaymentInterval(86400u * 30u),
3171 kGracePeriod(86400u * 30u),
3172 Sig(sfCounterpartySignature, owner),
3173 Fee(env.current()->fees().base * 200));
3174 env.close();
3175
3176 // Under fixCleanup3_4_0 impair requires the payment to already
3177 // be late, so advance past the loan's due date first.
3178 if (env.current()->rules().enabled(fixCleanup3_4_0))
3179 {
3180 auto const loanSle = env.le(loanKeylet);
3181 if (!BEAST_EXPECT(loanSle))
3182 return vaultKeylet;
3183 std::uint32_t const dueDate = loanSle->at(sfNextPaymentDueDate);
3184 env.close(
3186 }
3187
3188 env(manage(owner, loanKeylet.key, tfLoanImpair));
3189 env.close();
3190 }
3191
3192 return vaultKeylet;
3193 }
3194
3195 // Regression test for the loss-vs-gap invariant relaxation introduced
3196 // by fixCleanup3_4_0. Even with the one-unit tolerance, a loss value
3197 // exceeding (T - A) by more than one ULP must still fire. Two
3198 // mutations exercise this:
3199 // 1. L = (T - A) * 2 — fires under both amendment settings.
3200 // 2. L = (T - A) + 2 * oneUnit — fires post-amendment, catching
3201 // any accidental widening of the tolerance beyond one unit.
3202 void
3204 {
3205 testcase("vault loss exceeds gap (fixCleanup3_4_0 tolerance)");
3206 using namespace test::jtx;
3207
3208 auto const kExpectedLog = std::vector<std::string>{
3209 "loss unrealized must not exceed the difference between assets "
3210 "outstanding and available",
3211 };
3212
3213 for (auto const withFix : {false, true})
3214 {
3215 FeatureBitset amendments = all_;
3216 if (!withFix)
3217 amendments = amendments - fixCleanup3_4_0;
3218
3219 // Variant 1: L = (T - A) * 2. Fires under both settings.
3220 {
3221 Keylet vaultKeylet = keylet::vault(UInt256{});
3222 Account const issuer{"issuer_loss_gap"};
3223 Account const borrower{"borrower_loss_gap"};
3224
3225 auto const preclose = [&, this](
3226 Account const& owner, Account const&, Env& env) -> bool {
3227 vaultKeylet = this->makeImpairedVault(owner, borrower, issuer, env);
3228 return BEAST_EXPECT(env.le(vaultKeylet));
3229 };
3230
3232 makeEnv(amendments),
3233 kExpectedLog,
3234 [&vaultKeylet](Account const&, Account const&, ApplyContext& ac) -> bool {
3235 auto const sle = ac.view().peek(vaultKeylet);
3236 if (!sle)
3237 return false;
3238 Number const total = sle->at(sfAssetsTotal);
3239 Number const available = sle->at(sfAssetsAvailable);
3240 (*sle)[sfLossUnrealized] = (total - available) * 2;
3241 ac.view().update(sle);
3242 return true;
3243 },
3244 XRPAmount{},
3245 STTx{
3246 ttVAULT_DEPOSIT,
3247 [&vaultKeylet](STObject& tx) {
3248 tx.setFieldH256(sfVaultID, vaultKeylet.key);
3249 }},
3251 preclose,
3253 }
3254
3255 // Variant 2: L = (T - A) + 2 * oneUnit at scale(T). Must fire
3256 // post-fix because the tolerance is exactly one unit. A
3257 // regression that widened it to two units would silently accept
3258 // this state.
3259 {
3260 Keylet vaultKeylet = keylet::vault(UInt256{});
3261 Account const issuer{"issuer_loss_gap2"};
3262 Account const borrower{"borrower_loss_gap2"};
3263
3264 auto const preclose = [&, this](
3265 Account const& owner, Account const&, Env& env) -> bool {
3266 vaultKeylet = this->makeImpairedVault(owner, borrower, issuer, env);
3267 return BEAST_EXPECT(env.le(vaultKeylet));
3268 };
3269
3271 makeEnv(amendments),
3272 kExpectedLog,
3273 [&vaultKeylet](Account const&, Account const&, ApplyContext& ac) -> bool {
3274 auto const sle = ac.view().peek(vaultKeylet);
3275 if (!sle)
3276 return false;
3277 Number const total = sle->at(sfAssetsTotal);
3278 Number const available = sle->at(sfAssetsAvailable);
3279 Asset const asset = sle->at(sfAsset);
3280 Number const oneUnit{1, scale(total, asset)};
3281 (*sle)[sfLossUnrealized] = (total - available) + oneUnit * 2;
3282 ac.view().update(sle);
3283 return true;
3284 },
3285 XRPAmount{},
3286 STTx{
3287 ttVAULT_DEPOSIT,
3288 [&vaultKeylet](STObject& tx) {
3289 tx.setFieldH256(sfVaultID, vaultKeylet.key);
3290 }},
3292 preclose,
3294 }
3295 }
3296 }
3297
3298 void
3300 {
3301 using namespace jtx;
3302
3303 Account const issuer{"issuer"};
3304 PrettyAsset const vaultAsset = issuer["IOU"];
3305
3306 struct TestCase
3307 {
3308 std::string name;
3309 std::int32_t expectedMinScale;
3311 };
3312
3313 for (auto const mantissaScale : MantissaRange::getAllScales())
3314 {
3315 if (mantissaScale == MantissaRange::MantissaScale::Small)
3316 continue;
3317 NumberMantissaScaleGuard const g{mantissaScale};
3318
3319 auto const makeDelta = [&vaultAsset](Number const& n) -> ValidVault::DeltaInfo {
3320 return {.delta = n, .scale = scale(n, vaultAsset.raw())};
3321 };
3322
3323 auto const testCases = std::vector<TestCase>{
3324 {
3325 .name = "No values",
3326 .expectedMinScale = 0,
3327 .values = {},
3328 },
3329 {
3330 .name = "Mixed integer and Number values",
3331 .expectedMinScale = -15,
3332 .values = {makeDelta(1), makeDelta(-1), makeDelta(Number{10, -1})},
3333 },
3334 {
3335 .name = "Mixed scales",
3336 .expectedMinScale = -17,
3337 .values =
3338 {
3339 makeDelta(Number{1, -2}),
3340 makeDelta(Number{5, -3}),
3341 makeDelta(Number{3, -2}),
3342 },
3343 },
3344 {
3345 .name = "Equal scales",
3346 .expectedMinScale = -16,
3347 .values =
3348 {
3349 makeDelta(Number{1, -1}),
3350 makeDelta(Number{5, -1}),
3351 makeDelta(Number{1, -1}),
3352 },
3353 },
3354 {
3355 .name = "Mixed mantissa sizes",
3356 .expectedMinScale = -12,
3357 .values =
3358 {
3359 makeDelta(Number{1}),
3360 makeDelta(Number{1234, -3}),
3361 makeDelta(Number{12345, -6}),
3362 makeDelta(Number{123, 1}),
3363 },
3364 },
3365 };
3366
3367 for (auto const& tc : testCases)
3368 {
3369 testcase("vault computeCoarsestScale: " + tc.name);
3370
3371 auto const actualScale = ValidVault::computeCoarsestScale(tc.values);
3372
3373 BEAST_EXPECTS(
3374 actualScale == tc.expectedMinScale,
3375 "expected: " + std::to_string(tc.expectedMinScale) +
3376 ", actual: " + std::to_string(actualScale));
3377 for (auto const& num : tc.values)
3378 {
3379 // None of these scales are far enough apart that rounding the
3380 // values would lose information, so check that the rounded
3381 // value matches the original.
3382 auto const actualRounded = roundToAsset(vaultAsset, num.delta, actualScale);
3383 BEAST_EXPECTS(
3384 actualRounded == num.delta,
3385 "number " + to_string(num.delta) + " rounded to scale " +
3386 std::to_string(actualScale) + " is " + to_string(actualRounded));
3387 }
3388 }
3389
3390 auto const testCases2 = std::vector<TestCase>{
3391 {
3392 .name = "False equivalence",
3393 .expectedMinScale = -15,
3394 .values =
3395 {
3396 makeDelta(Number{1234567890123456789, -18}),
3397 makeDelta(Number{12345, -4}),
3398 makeDelta(Number{1}),
3399 },
3400 },
3401 };
3402
3403 // Unlike the first set of test cases, the values in these test could
3404 // look equivalent if using the wrong scale.
3405 for (auto const& tc : testCases2)
3406 {
3407 testcase("vault computeCoarsestScale: " + tc.name);
3408
3409 auto const actualScale = ValidVault::computeCoarsestScale(tc.values);
3410
3411 BEAST_EXPECTS(
3412 actualScale == tc.expectedMinScale,
3413 "expected: " + std::to_string(tc.expectedMinScale) +
3414 ", actual: " + std::to_string(actualScale));
3416 Number firstRounded;
3417 for (auto const& num : tc.values)
3418 {
3419 if (!first)
3420 {
3421 first = num.delta;
3422 firstRounded = roundToAsset(vaultAsset, num.delta, actualScale);
3423 continue;
3424 }
3425 auto const numRounded = roundToAsset(vaultAsset, num.delta, actualScale);
3426 BEAST_EXPECTS(
3427 numRounded != firstRounded,
3428 "at a scale of " + std::to_string(actualScale) + " " +
3429 to_string(num.delta) + " == " + to_string(*first));
3430 }
3431 }
3432 }
3433 }
3434
3435 // Closed-ended FixedPrecision vault with one open loan. Closed-ended
3436 // because LoanBrokerSet::preclaim only accepts those under
3437 // featureLendingProtocolV1_1.
3438 static Keylet
3440 test::jtx::Account const& owner,
3441 test::jtx::Account const& borrower,
3442 test::jtx::Account const& issuer,
3443 test::jtx::Env& env)
3444 {
3445 using namespace test::jtx;
3446
3447 env.fund(XRP(1'000'000), issuer, borrower);
3448 env.close();
3449
3450 PrettyAsset const usd = issuer["USD"];
3451 env(trust(owner, usd(1'000'000)));
3452 env(trust(borrower, usd(1'000'000)));
3453 env.close();
3454
3455 env(pay(issuer, owner, usd(100'000)));
3456 env(pay(issuer, borrower, usd(1'000)));
3457 env.close();
3458
3459 Vault const vault{env};
3460 auto [vaultTx, vaultKeylet, subscriptionDate] = vault.createClosedEnded({
3461 .owner = owner,
3462 .asset = usd,
3463 .subscriptionOffset = std::chrono::seconds{60},
3464 .investmentWindow = std::chrono::seconds{10ull * 365ull * 24ull * 60ull * 60ull},
3465 });
3466 env(vaultTx);
3467 env.close();
3468
3469 env(vault.deposit(
3470 {.depositor = owner, .id = vaultKeylet.key, .amount = usd(1'000).value()}));
3471 env.close();
3472
3473 auto const brokerKeylet =
3474 keylet::loanBroker(owner.id(), SeqProxy::rawSequence(env.seq(owner)));
3475 {
3476 using namespace loan_broker;
3477 env(set(owner, vaultKeylet.key), Fee(env.current()->fees().base * 2));
3478 env.close();
3479 }
3480
3481 // LoanSet is gated on Investment; advance out of Subscription.
3482 vault.closePastSubscription(subscriptionDate);
3483
3484 {
3485 using namespace loan;
3486 env(set(borrower, brokerKeylet.key, usd(100).value()),
3487 kCounterparty(owner),
3488 kInterestRate(TenthBips32{0}),
3489 kPaymentTotal(3),
3490 kPaymentInterval(86400u),
3491 kGracePeriod(3600u),
3492 Sig(sfCounterpartySignature, owner),
3493 Fee(env.current()->fees().base * 2));
3494 env.close();
3495 }
3496
3497 return vaultKeylet;
3498 }
3499
3500 static void
3501 addToVaultField(std::shared_ptr<SLE> const& sle, SF_NUMBER const& field, Number const& delta)
3502 {
3503 (*sle)[field] = Number(sle->at(field)) + delta;
3504 }
3505
3506 // Corrupts a vault SLE. The runner updates the SLE afterwards.
3508
3510 {
3511 char const* name = nullptr;
3514 TxType txType = ttVAULT_SET;
3515 // Set sfVaultID on the mock tx.
3516 bool withVaultId = false;
3518 };
3519
3520 void
3522 {
3523 using namespace test::jtx;
3524
3525 testcase(row.name);
3526
3527 // Create the vault before building the transaction, so the transaction
3528 // carries the real VaultID.
3529 auto env = makeEnv(all_);
3530 Account const owner{"A1"};
3531 Account const other{"A2"};
3532 Account const issuer{"issuer"};
3533 Account const borrower{"borrower"};
3534 env.fund(XRP(1000), owner, other);
3535 auto const vaultKeylet = makeFixedPrecisionVaultWithLoan(owner, borrower, issuer, env);
3536 if (!BEAST_EXPECT(env.le(vaultKeylet)))
3537 return;
3538 env.close();
3539
3540 STTx tx{row.txType, [&](STObject& obj) {
3541 if (row.withVaultId)
3542 {
3543 obj.setFieldH256(sfVaultID, vaultKeylet.key);
3544 }
3545 }};
3546 tx.setAccountID(sfAccount, owner.id());
3547
3549 std::move(env),
3550 owner,
3551 other,
3552 row.logs,
3553 [&](Account const&, Account const&, ApplyContext& ac) -> bool {
3554 auto const sle = ac.view().peek(vaultKeylet);
3555 if (!sle || !row.mutate(ac, sle))
3556 {
3557 return false;
3558 }
3559 ac.view().update(sle);
3560 return true;
3561 },
3562 XRPAmount{},
3563 tx,
3564 {tecINVARIANT_FAILED, row.secondTer});
3565 }
3566
3567 void
3569 {
3570 using namespace test::jtx;
3571
3572 testcase(row.name);
3573
3574 Account const a3{"A3"};
3575 auto const preclose = [&](Account const& a1, Account const& a2, Env& env) -> bool {
3576 env.fund(XRP(1000), a3);
3577 Vault const vault{env};
3578 auto [tx, keylet] = vault.create({.owner = a1, .asset = xrpIssue()});
3579 env(tx);
3580 for (auto const* depositor : {&a1, &a2, &a3})
3581 {
3582 env(vault.deposit({.depositor = *depositor, .id = keylet.key, .amount = XRP(10)}));
3583 }
3584 return true;
3585 };
3586
3588 makeEnv(all_),
3589 row.logs,
3590 [&](Account const& a1, Account const&, ApplyContext& ac) {
3591 auto const sle =
3592 ac.view().peek(keylet::vault(a1.id(), SeqProxy::rawSequence(ac.view().seq())));
3593 if (!sle || !row.mutate(ac, sle))
3594 {
3595 return false;
3596 }
3597 ac.view().update(sle);
3598 return true;
3599 },
3600 XRPAmount{},
3601 STTx{row.txType, [](STObject&) {}},
3602 {tecINVARIANT_FAILED, row.secondTer},
3603 preclose,
3604 TxAccount::A2);
3605 }
3606
3607 void
3609 {
3610 // ttLOAN_PAY and ttLOAN_MANAGE may change AssetsDeployed and LossUnrealized
3611 // respectively, which isolates each check from the "vault transaction
3612 // must not change ..." checks.
3613 AssetsDeployedRow const loanRows[] = {
3614 {
3615 .name = "FixedPrecision vault: AssetsDeployed drift from AssetsTotal",
3616 .logs =
3617 {
3618 "stored AssetsTotal must equal AssetsAvailable plus AssetsDeployed, "
3619 "rounded "
3620 "Downward",
3621 },
3622 .mutate =
3623 [](ApplyContext&, std::shared_ptr<SLE> const& sle) {
3624 addToVaultField(sle, sfAssetsDeployed, Number{1});
3625 return true;
3626 },
3627 .txType = ttLOAN_PAY,
3628 },
3629 {
3630 .name = "FixedPrecision vault: stored AssetsTotal != Downward16(AA + AD)",
3631 .logs =
3632 {
3633 "stored AssetsTotal must equal AssetsAvailable plus AssetsDeployed, "
3634 "rounded "
3635 "Downward",
3636 },
3637 .mutate =
3638 [](ApplyContext&, std::shared_ptr<SLE> const& sle) {
3639 addToVaultField(sle, sfAssetsTotal, Number{1});
3640 return true;
3641 },
3642 .txType = ttLOAN_PAY,
3643 },
3644 // FixedPrecision compares LU with AssetsDeployed directly; the message
3645 // is shared with the Legacy/CashBasis "LU <= AT - AA" check.
3646 {
3647 .name = "FixedPrecision vault: LossUnrealized exceeds AssetsDeployed",
3648 .logs =
3649 {
3650 "loss unrealized must not exceed the difference between assets "
3651 "outstanding and available",
3652 },
3653 .mutate =
3654 [](ApplyContext&, std::shared_ptr<SLE> const& sle) {
3655 Number const assetsDeployed = sle->at(sfAssetsDeployed);
3656 (*sle)[sfLossUnrealized] = assetsDeployed + Number{1};
3657 return true;
3658 },
3659 .txType = ttLOAN_MANAGE,
3660 },
3661 // AssetsTotal moves too so the sync check stays quiet.
3662 {
3663 .name = "FixedPrecision vault: AssetsDeployed changed by a non-lending transaction",
3664 .logs = {"vault transaction must not change AssetsDeployed"},
3665 .mutate =
3666 [](ApplyContext&, std::shared_ptr<SLE> const& sle) {
3667 addToVaultField(sle, sfAssetsDeployed, Number{1});
3668 addToVaultField(sle, sfAssetsTotal, Number{1});
3669 return true;
3670 },
3671 .withVaultId = true,
3672 },
3673 // On-ledger mirror of VaultWithdraw's tecHAS_OBLIGATIONS guard.
3674 {
3675 .name = "FixedPrecision vault: non-zero AssetsDeployed after shares return to zero",
3676 .logs = {"updated zero sized vault must have no AssetsDeployed"},
3677 .mutate =
3678 [](ApplyContext& ac, std::shared_ptr<SLE> const& sle) {
3679 auto const issuance =
3680 ac.view().peek(keylet::mptokenIssuance(sle->at(sfShareMPTID)));
3681 if (!issuance)
3682 {
3683 return false;
3684 }
3685 issuance->setFieldU64(sfOutstandingAmount, 0);
3686 ac.view().update(issuance);
3687 return true;
3688 },
3689 .withVaultId = true,
3690 .secondTer = tefINVARIANT_FAILED,
3691 },
3692 };
3693 for (auto const& row : loanRows)
3694 {
3695 checkLoanVaultRow(row);
3696 }
3697
3698 AssetsDeployedRow const xrpRows[] = {
3699 {
3700 .name = "FixedPrecision vault: negative AssetsDeployed",
3701 .logs =
3702 {
3703 "AssetsDeployed must not be negative",
3704 "vault transaction must not change AssetsDeployed",
3705 },
3706 .mutate =
3707 [](ApplyContext&, std::shared_ptr<SLE> const& sle) {
3708 (*sle)[sfAssetsDeployed] = Number{-1};
3709 return true;
3710 },
3711 },
3712 // 1.5 drops is never representable on an XRP vault.
3713 {
3714 .name = "FixedPrecision vault: AssetsDeployed not exactly representable at asset "
3715 "precision",
3716 .logs =
3717 {
3718 "AssetsDeployed must be exactly representable at the vault asset's "
3719 "precision",
3720 "vault transaction must not change AssetsDeployed",
3721 },
3722 .mutate =
3723 [](ApplyContext&, std::shared_ptr<SLE> const& sle) {
3724 (*sle)[sfAssetsDeployed] = Number{15, -1};
3725 return true;
3726 },
3727 },
3728 };
3729 for (auto const& row : xrpRows)
3730 {
3731 checkXrpVaultRow(row);
3732 }
3733 }
3734
3735 // FixedPrecision only: YieldUnrealized must not be negative, and may
3736 // change only for ttLOAN_SET, ttLOAN_PAY and ttLOAN_MANAGE. Both rows use
3737 // a plain (no loan) FixedPrecision vault, mirroring the AssetsDeployed
3738 // vault-only rows above.
3739 void
3741 {
3742 AssetsDeployedRow const xrpRows[] = {
3743 {
3744 .name = "FixedPrecision vault: negative YieldUnrealized",
3745 .logs =
3746 {
3747 "YieldUnrealized must not be negative",
3748 "vault transaction must not change yield unrealized",
3749 },
3750 .mutate =
3751 [](ApplyContext&, std::shared_ptr<SLE> const& sle) {
3752 (*sle)[sfYieldUnrealized] = Number{-1};
3753 return true;
3754 },
3755 },
3756 {
3757 .name =
3758 "FixedPrecision vault: YieldUnrealized changed by a non-lending transaction",
3759 .logs = {"vault transaction must not change yield unrealized"},
3760 .mutate =
3761 [](ApplyContext&, std::shared_ptr<SLE> const& sle) {
3762 addToVaultField(sle, sfYieldUnrealized, Number{1});
3763 return true;
3764 },
3765 },
3766 };
3767 for (auto const& row : xrpRows)
3768 {
3769 checkXrpVaultRow(row);
3770 }
3771 }
3772
3773 // A FixedPrecision vault's AssetsAvailable is the exact balance; its delta
3774 // must equal the real pseudo-account transfer with no rounding tolerance.
3775 // The stored AssetsTotal is a derived cache and is not compared per
3776 // transaction. Move AssetsAvailable by one drop more than the real
3777 // transfer and expect a rejection.
3778 void
3780 {
3781 testcase(
3782 "FixedPrecision vault: AssetsAvailable off by one sub-unit from the pseudo balance "
3783 "is rejected");
3784 using namespace test::jtx;
3785
3786 Keylet vaultKeylet = keylet::vault(uint256{});
3787
3788 auto const preclose = [&](Account const& a1, Account const&, Env& env) -> bool {
3789 Vault const vault{env};
3790 auto [tx, keylet] = vault.create({.owner = a1, .asset = xrpIssue()});
3791 env(tx);
3792 env(vault.deposit({.depositor = a1, .id = keylet.key, .amount = XRP(10)}));
3793 vaultKeylet = keylet;
3794 auto const sle = env.le(vaultKeylet);
3795 return BEAST_EXPECT(sle) && BEAST_EXPECT(sle->isFieldPresent(sfLEVersion));
3796 };
3797
3799 makeEnv(all_),
3800 {"withdrawal and assets available must add up"},
3801 [&vaultKeylet](Account const& a1, Account const&, ApplyContext& ac) -> bool {
3802 auto const sleVault = ac.view().peek(vaultKeylet);
3803 if (!sleVault)
3804 {
3805 return false;
3806 }
3807
3808 // Real transfer: pseudo account loses 10 drops, depositor gains 10.
3809 auto const slePseudo = ac.view().peek(keylet::account(sleVault->at(sfAccount)));
3810 auto const sleA1 = ac.view().peek(keylet::account(a1.id()));
3811 if (!slePseudo || !sleA1)
3812 {
3813 return false;
3814 }
3815 (*slePseudo)[sfBalance] = *(*slePseudo)[sfBalance] - XRPAmount{10};
3816 (*sleA1)[sfBalance] = *(*sleA1)[sfBalance] + XRPAmount{10};
3817 ac.view().update(slePseudo);
3818 ac.view().update(sleA1);
3819
3820 // Burn 10 shares (1:1 initial price) from depositor and pool.
3821 auto const mptIssuanceID = sleVault->at(sfShareMPTID);
3822 auto const sleShares = ac.view().peek(keylet::mptokenIssuance(mptIssuanceID));
3823 auto const sleA1Token = ac.view().peek(keylet::mptoken(mptIssuanceID, a1.id()));
3824 if (!sleShares || !sleA1Token)
3825 {
3826 return false;
3827 }
3828 sleShares->setFieldU64(
3829 sfOutstandingAmount, sleShares->getFieldU64(sfOutstandingAmount) - 10);
3830 sleA1Token->setFieldU64(sfMPTAmount, sleA1Token->getFieldU64(sfMPTAmount) - 10);
3831 ac.view().update(sleShares);
3832 ac.view().update(sleA1Token);
3833
3834 // 11 drops: one more than the real transfer. AssetsTotal
3835 // follows to keep the sync invariant quiet.
3836 addToVaultField(sleVault, sfAssetsAvailable, Number{-11});
3837 addToVaultField(sleVault, sfAssetsTotal, Number{-11});
3838 ac.view().update(sleVault);
3839 return true;
3840 },
3841 XRPAmount{},
3842 STTx{ttVAULT_WITHDRAW, [](STObject&) {}},
3844 preclose,
3846 }
3847
3848 void
3858};
3859
3860BEAST_DEFINE_TESTSUITE(InvariantsVault, app, xrpl);
3861
3862} // namespace xrpl::test
A generic endpoint for log messages.
Definition Journal.h:44
TestcaseT testcase
Memberspace for declaring test cases.
Definition suite.h:155
Represents a JSON value.
Definition json_value.h:121
State information when applying a tx.
ApplyView & view()
Writeable view to a ledger, for applying a transaction.
Definition ApplyView.h:141
virtual SLE::pointer peek(Keylet const &k)=0
Prepare to modify the SLE associated with key.
virtual void insert(SLE::Ref sle)=0
Insert a new state SLE.
std::optional< std::uint64_t > dirInsert(Keylet const &directory, UInt256 const &key, std::function< void(SLE::Ref)> const &describe)
Insert an entry to a directory.
Definition ApplyView.h:373
virtual void erase(SLE::Ref sle)=0
Remove a peeked SLE.
virtual void update(SLE::Ref sle)=0
Indicate changes to a peeked SLE.
std::chrono::time_point< NetClock > time_point
Definition chrono.h:48
std::chrono::duration< rep, period > duration
Definition chrono.h:47
Sets the new scale and restores the old scale when it leaves scope.
Definition Number.h:967
Number is a floating point type that can represent a wide range of values.
Definition Number.h:351
LedgerIndex seq() const
Returns the sequence number of the base ledger.
Definition ReadView.h:115
void setAccountID(SField const &field, AccountID const &)
Definition STObject.cpp:785
static constexpr SeqProxy rawSequence(std::uint32_t v)
Factory function to return a sequence-based SeqProxy.
Definition SeqProxy.h:62
static std::int32_t computeCoarsestScale(std::vector< DeltaInfo > const &numbers)
Keylet createLoanBroker(jtx::Account const &a, jtx::Env &env, jtx::PrettyAsset const &asset)
test::jtx::Env makeEnv(FeatureBitset features)
void doInvariantCheck(std::vector< std::string > const &expectLogs, Precheck const &precheck, XRPAmount fee=XRPAmount{}, STTx tx=STTx{ttACCOUNT_SET, [](STObject &) {}}, std::initializer_list< TER > ters={tecINVARIANT_FAILED, tefINVARIANT_FAILED}, Preclose const &preclose={}, TxAccount setTxAccount=TxAccount::None, std::source_location const &loc=std::source_location::current(), TER initialResult=tesSUCCESS)
Run a specific test case to put the ledger into a state that will be detected by an invariant.
static SLE::pointer makeLoanSle(UInt256 const &loanBrokerID, std::uint32_t loanSeq, AccountID const &borrower)
std::function< bool(ApplyContext &, std::shared_ptr< SLE > const &)> VaultMutation
static void addToVaultField(std::shared_ptr< SLE > const &sle, SF_NUMBER const &field, Number const &delta)
Keylet makeImpairedVault(test::jtx::Account const &owner, test::jtx::Account const &borrower, test::jtx::Account const &issuer, test::jtx::Env &env)
void run() override
Runs the suite.
void checkXrpVaultRow(AssetsDeployedRow const &row)
void checkLoanVaultRow(AssetsDeployedRow const &row)
static Keylet makeFixedPrecisionVaultWithLoan(test::jtx::Account const &owner, test::jtx::Account const &borrower, test::jtx::Account const &issuer, test::jtx::Env &env)
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
SLE::const_pointer le(Account const &account) const
Return an account root.
Definition Env.cpp:311
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
std::shared_ptr< OpenView const > current() const
Returns the current ledger.
Definition Env.h:377
Set the fee on a JTx.
Definition fee.h:20
Set the regular signature on a JTx.
Definition sig.h:19
T make_shared(T... args)
constexpr Zero kZero
Definition Zero.h:30
Keylet computation functions.
Definition Indexes.h:39
Keylet ownerDir(AccountID const &id) noexcept
The root page of an account's directory.
Definition Indexes.cpp:415
Keylet vault(AccountID const &owner, SeqProxy const &seq) noexcept
Definition Indexes.cpp:565
Keylet mptoken(MPTID const &issuanceID, AccountID const &holder) noexcept
Definition Indexes.cpp:547
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
Keylet mptokenIssuance(MPTID const &issuanceID) noexcept
Definition Indexes.cpp:541
constexpr TenthBips32 kMaxCoverRate
The maximum coverage rate required of a loan broker in 1/10 bips.
Definition Protocol.h:159
Keylet keylet(test::jtx::Account const &subject, test::jtx::Account const &issuer, std::string_view credType)
Definition credentials.h:21
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
FeatureBitset testableAmendments()
Definition Env.h:92
json::Value trust(Account const &account, STAmount const &amount, std::uint32_t flags)
Modify a trust line.
Definition trust.cpp:18
BEAST_DEFINE_TESTSUITE(AMMClawback, app, xrpl)
constexpr XRPAmount
Convert XRP to drops (integral types).
Definition TxTest.h:53
Use hash_* containers for keys that do not need a cryptographically secure hashing algorithm.
Definition algorithm.h:5
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
TxType
Transaction type identifiers.
Definition TxFormats.h:45
constexpr TenthBips32 percentageToTenthBips(std::uint32_t percentage)
Definition Protocol.h:127
int scale(Number const &number, Asset const &asset)
Get the scale of a Number for a given asset.
Definition STAmount.h:819
@ tefINVARIANT_FAILED
Definition TER.h:177
constexpr std::uint32_t kMaxInvestmentPeriod
Definition Protocol.h:393
TenthBips< std::uint32_t > TenthBips32
Definition Units.h:454
std::string to_string(BaseUInt< Bits, Tag > const &a)
Definition base_uint.h:658
BaseUInt< 256 > UInt256
Definition base_uint.h:581
VaultVersion
Vault ledger-entry schema versions, persisted as sfLEVersion.
Definition Protocol.h:342
std::unique_ptr< Transactor > makeTransactor(ApplyContext &ctx)
BaseUInt< 192 > MPTID
MPTID is a 192-bit value representing MPT Issuance ID, which is a concatenation of a 32-bit sequence ...
Definition UintTypes.h:54
bool after(NetClock::time_point now, std::uint32_t mark)
Has the specified time passed?
Definition View.cpp:668
AccountID pseudoAccountAddress(ReadView const &view, UInt256 const &pseudoOwnerKey)
Generate a pseudo-account address from a pseudo owner key.
MPTID makeMptID(std::uint32_t const sequence, AccountID const &account)
Definition Indexes.cpp:219
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
@ TapNone
Definition ApplyView.h:28
TypedField< STNumber > SF_NUMBER
Definition SField.h:360
BaseUInt< 160, detail::AccountIDTag > AccountID
A 160-bit unsigned that uniquely identifies an account.
Definition AccountID.h:34
constexpr std::uint8_t kVaultStrategyFirstComeFirstServe
Vault withdrawal policies.
Definition Protocol.h:308
TERSubset< CanCvtToTER > TER
Definition TER.h:657
@ tecINVARIANT_FAILED
Definition TER.h:324
constexpr std::uint32_t kLoanRedemptionBuffer
Minimum gap between a closed-ended loan's final scheduled payment and the vault's RedemptionDate.
Definition Protocol.h:379
std::function< void(SLE::Ref)> describeOwnerDir(AccountID const &account)
Returns a function that sets the owner on a directory SLE.
constexpr std::uint64_t kMaxMpTokenAmount
The maximum amount of MPTokenIssuance.
Definition Protocol.h:297
constexpr std::uint32_t kMinInvestmentPeriod
Bounds on the length of a closed-ended vault's Investment phase (RedemptionDate - SubscriptionDate).
Definition Protocol.h:391
@ tesSUCCESS
Definition TER.h:253
UInt256 uint256
Definition base_uint.h:587
A pair of SHAMap key and LedgerEntryType.
Definition Keylet.h:20
UInt256 key
Definition Keylet.h:21
static std::set< MantissaScale > const & getAllScales()
Definition Number.h:178
T to_string(T... args)