xrpld
Loading...
Searching...
No Matches
VaultClawback_test.cpp
1#include <test/app/vault/VaultTestBase.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/escrow.h>
7#include <test/jtx/fee.h>
8#include <test/jtx/flags.h>
9#include <test/jtx/mpt.h>
10#include <test/jtx/pay.h>
11#include <test/jtx/sig.h>
12#include <test/jtx/ter.h>
13#include <test/jtx/vault.h>
14
15#include <xrpl/basics/Number.h>
16#include <xrpl/basics/base_uint.h>
17#include <xrpl/beast/unit_test/suite.h>
18#include <xrpl/beast/utility/Journal.h>
19#include <xrpl/json/json_forwards.h>
20#include <xrpl/json/json_value.h>
21#include <xrpl/protocol/Asset.h>
22#include <xrpl/protocol/Feature.h>
23#include <xrpl/protocol/Indexes.h>
24#include <xrpl/protocol/Issue.h>
25#include <xrpl/protocol/Keylet.h>
26#include <xrpl/protocol/MPTIssue.h>
27#include <xrpl/protocol/SField.h>
28#include <xrpl/protocol/STAmount.h>
29#include <xrpl/protocol/SeqProxy.h>
30#include <xrpl/protocol/TER.h>
31#include <xrpl/protocol/TxFlags.h>
32#include <xrpl/protocol/Units.h>
33#include <xrpl/protocol/XRPAmount.h>
34#include <xrpl/protocol/jss.h>
35
36#include <chrono>
37#include <string>
38#include <tuple>
39#include <utility>
40#include <vector>
41
42namespace xrpl {
43
45{
46private:
47 void
49 {
50 using namespace test::jtx;
51 using namespace loan_broker;
52 using namespace loan;
53 Env env(*this, beast::Severity::Warning);
54
55 auto const vaultAssetBalance = [&](Keylet const& vaultKeylet) {
56 auto const sleVault = env.le(vaultKeylet);
57 BEAST_EXPECT(sleVault != nullptr);
58
59 return std::make_pair(sleVault->at(sfAssetsAvailable), sleVault->at(sfAssetsTotal));
60 };
61
62 auto const vaultShareBalance = [&](Keylet const& vaultKeylet) {
63 auto const sleVault = env.le(vaultKeylet);
64 BEAST_EXPECT(sleVault != nullptr);
65
66 auto const sleIssuance = env.le(keylet::mptokenIssuance(sleVault->at(sfShareMPTID)));
67 BEAST_EXPECT(sleIssuance != nullptr);
68
69 return sleIssuance->at(sfOutstandingAmount);
70 };
71
72 // Under featureLendingProtocolV1_1 LoanBrokerSet::preclaim only
73 // accepts closed-ended vaults, so build vaults in this suite as
74 // closed-ended and advance past SubscriptionDate before creating
75 // brokers/loans. VaultClawback itself is not phase-gated. The
76 // subscription offset must be large enough that the deposit
77 // ledger close does not accidentally push us past SubscriptionDate
78 // (which would land the deposit in Investment phase and fail).
79 auto const setupVault = [&](PrettyAsset const& asset,
80 Account const& owner,
81 Account const& depositor) -> std::pair<Vault, Keylet> {
82 Vault const vault{env};
83
84 auto const& [tx, vaultKeylet, subscriptionDate] = vault.createClosedEnded(
85 {.owner = owner, .asset = asset, .subscriptionOffset = std::chrono::seconds{60}});
86 env(tx, Ter(tesSUCCESS));
87 env.close();
88
89 auto const& vaultSle = env.le(vaultKeylet);
90 BEAST_EXPECT(vaultSle != nullptr);
91
92 Asset const share = vaultSle->at(sfShareMPTID);
93
94 env(vault.deposit(
95 {.depositor = depositor, .id = vaultKeylet.key, .amount = asset(100)}),
96 Ter(tesSUCCESS));
97 env.close();
98
99 // Move past SubscriptionDate so LoanBrokerSet/LoanSet run in
100 // the Investment phase.
101 vault.closePastSubscription(subscriptionDate);
102
103 auto const& [availablePreDefault, totalPreDefault] = vaultAssetBalance(vaultKeylet);
104 BEAST_EXPECT(availablePreDefault == totalPreDefault);
105 BEAST_EXPECT(availablePreDefault == asset(100).value());
106
107 // attempt to clawback shares while there are assets fails
108 env(vault.clawback({
109 .issuer = owner,
110 .id = vaultKeylet.key,
111 .holder = depositor,
112 .amount = share(0).value(),
113 }),
114 Ter(tecNO_PERMISSION));
115 env.close();
116
117 auto const& sharesAvailable = vaultShareBalance(vaultKeylet);
118 auto const& brokerKeylet =
119 keylet::loanBroker(owner.id(), SeqProxy::rawSequence(env.seq(owner)));
120
121 env(set(owner, vaultKeylet.key));
122 env.close();
123
124 auto const& loanKeylet = keylet::loan(brokerKeylet.key, SeqProxy::rawSequence(1));
125
126 // Create a simple Loan for the full amount of Vault assets
127 env(set(depositor, brokerKeylet.key, asset(100).value()),
128 loan::kInterestRate(TenthBips32(0)),
129 kGracePeriod(60),
130 kPaymentInterval(120),
131 kPaymentTotal(10),
132 Sig(sfCounterpartySignature, owner),
133 Fee(env.current()->fees().base * 2),
134 Ter(tesSUCCESS));
135 env.close();
136
137 // attempt to clawback shares while there assetsAvailable == 0 and
138 // assetsTotal > 0 fails
139 env(vault.clawback({
140 .issuer = owner,
141 .id = vaultKeylet.key,
142 .holder = depositor,
143 .amount = share(0).value(),
144 }),
145 Ter(tecNO_PERMISSION));
146 env.close();
147
148 env.close(std::chrono::seconds{120 + 60});
149
150 env(manage(owner, loanKeylet.key, tfLoanDefault), Ter(tesSUCCESS));
151
152 auto const& [availablePostDefault, totalPostDefault] = vaultAssetBalance(vaultKeylet);
153
154 BEAST_EXPECT(availablePostDefault == totalPostDefault);
155 BEAST_EXPECT(availablePostDefault == asset(0).value());
156 BEAST_EXPECT(vaultShareBalance(vaultKeylet) == sharesAvailable);
157
158 return std::make_pair(vault, vaultKeylet);
159 };
160
161 auto const testCase = [&](PrettyAsset const& asset,
162 std::string const& prefix,
163 Account const& owner,
164 Account const& depositor) {
165 {
166 testcase("VaultClawback (share) - " + prefix + " owner asset clawback fails");
167 auto [vault, vaultKeylet] = setupVault(asset, owner, depositor);
168 // when asset is XRP or owner is not issuer clawback fail
169 // when owner is issuer precision loss occurs as vault is
170 // empty
171 auto const expectedTer = [&] {
172 if (asset.native())
173 return Ter(temMALFORMED);
174 if (asset.raw().getIssuer() != owner.id())
175 return Ter(tecNO_PERMISSION);
176 return Ter(tecPRECISION_LOSS);
177 }();
178 env(vault.clawback({
179 .issuer = owner,
180 .id = vaultKeylet.key,
181 .holder = depositor,
182 .amount = asset(100).value(),
183 }),
184 expectedTer);
185 env.close();
186 }
187
188 {
189 testcase(
190 "VaultClawback (share) - " + prefix + " owner incomplete share clawback fails");
191 auto [vault, vaultKeylet] = setupVault(asset, owner, depositor);
192 auto const& vaultSle = env.le(vaultKeylet);
193 if (!BEAST_EXPECT(vaultSle))
194 return;
195 Asset const share = vaultSle->at(sfShareMPTID);
196 env(vault.clawback({
197 .issuer = owner,
198 .id = vaultKeylet.key,
199 .holder = depositor,
200 .amount = share(1).value(),
201 }),
202 Ter(tecLIMIT_EXCEEDED));
203 env.close();
204 }
205
206 {
207 testcase(
208 "VaultClawback (share) - " + prefix +
209 " owner implicit complete share clawback");
210 auto [vault, vaultKeylet] = setupVault(asset, owner, depositor);
211 env(vault.clawback({
212 .issuer = owner,
213 .id = vaultKeylet.key,
214 .holder = depositor,
215 }),
216 // when owner is issuer implicit clawback fails
217 asset.native() || asset.raw().getIssuer() != owner.id() ? Ter(tesSUCCESS)
218 : Ter(tecWRONG_ASSET));
219 env.close();
220 }
221
222 {
223 testcase(
224 "VaultClawback (share) - " + prefix +
225 " owner explicit complete share clawback succeeds");
226 auto [vault, vaultKeylet] = setupVault(asset, owner, depositor);
227 auto const& vaultSle = env.le(vaultKeylet);
228 if (!BEAST_EXPECT(vaultSle))
229 return;
230 Asset const share = vaultSle->at(sfShareMPTID);
231 env(vault.clawback({
232 .issuer = owner,
233 .id = vaultKeylet.key,
234 .holder = depositor,
235 .amount = share(vaultShareBalance(vaultKeylet)).value(),
236 }),
237 Ter(tesSUCCESS));
238 env.close();
239 }
240 {
241 testcase("VaultClawback (share) - " + prefix + " owner can clawback own shares");
242 auto [vault, vaultKeylet] = setupVault(asset, owner, owner);
243 auto const& vaultSle = env.le(vaultKeylet);
244 if (!BEAST_EXPECT(vaultSle))
245 return;
246 Asset const share = vaultSle->at(sfShareMPTID);
247 env(vault.clawback({
248 .issuer = owner,
249 .id = vaultKeylet.key,
250 .holder = owner,
251 .amount = share(vaultShareBalance(vaultKeylet)).value(),
252 }),
253 Ter(tesSUCCESS));
254 env.close();
255 }
256
257 {
258 testcase("VaultClawback (share) - " + prefix + " empty vault share clawback fails");
259 auto [vault, vaultKeylet] = setupVault(asset, owner, owner);
260 auto const& vaultSle = env.le(vaultKeylet);
261 if (!BEAST_EXPECT(vaultSle))
262 return;
263 Asset const share = vaultSle->at(sfShareMPTID);
264 env(vault.clawback({
265 .issuer = owner,
266 .id = vaultKeylet.key,
267 .holder = owner,
268 .amount = share(vaultShareBalance(vaultKeylet)).value(),
269 }),
270 Ter(tesSUCCESS));
271
272 // Now the vault is empty, clawback again fails
273 env(vault.clawback({
274 .issuer = owner,
275 .id = vaultKeylet.key,
276 .holder = owner,
277 .amount = share(vaultShareBalance(vaultKeylet)).value(),
278 }),
279 Ter(tecNO_PERMISSION));
280 env.close();
281 }
282 };
283
284 Account const owner{"alice"};
285 Account const depositor{"bob"};
286 Account const issuer{"issuer"};
287
288 env.fund(XRP(10000), issuer, owner, depositor);
289 env.close();
290
291 // Test XRP
292 PrettyAsset const xrp = xrpIssue();
293 testCase(xrp, "XRP", owner, depositor);
294 testCase(xrp, "XRP (depositor is owner)", owner, owner);
295
296 // Test IOU
297 PrettyAsset const iou = issuer["IOU"];
298 env(fset(issuer, asfAllowTrustLineClawback));
299 env.close();
300
301 env.trust(iou(1000), owner);
302 env.trust(iou(1000), depositor);
303 env(pay(issuer, owner, iou(100)));
304 env(pay(issuer, depositor, iou(100)));
305 env.close();
306 testCase(iou, "IOU", owner, depositor);
307 testCase(iou, "IOU (owner is issuer)", issuer, depositor);
308
309 // Test MPT
310 MPTTester mptt{env, issuer, kMptInitNoFund};
311 mptt.create({.flags = tfMPTCanClawback | tfMPTCanTransfer | tfMPTCanLock});
312 PrettyAsset const mpt = mptt.issuanceID();
313 mptt.authorize({.account = owner});
314 mptt.authorize({.account = depositor});
315 env(pay(issuer, owner, mpt(1000)));
316 env(pay(issuer, depositor, mpt(1000)));
317 env.close();
318 testCase(mpt, "MPT", owner, depositor);
319 testCase(mpt, "MPT (owner is issuer)", issuer, depositor);
320 }
321
322 void
324 {
325 using namespace test::jtx;
326 using namespace loan_broker;
327 using namespace loan;
328 Env env(*this);
329 env.enableFeature(fixCleanup3_1_3);
330
331 // Under featureLendingProtocolV1_1 LoanBrokerSet::preclaim only
332 // accepts closed-ended vaults; some tests using this helper later
333 // attach loan brokers to the vault. Build it as closed-ended and
334 // advance past SubscriptionDate so subsequent broker/loan setup
335 // runs in the Investment phase. VaultClawback itself is not
336 // phase-gated. See the other setupVault (share tests) for why the
337 // subscription offset must be generous.
338 auto const setupVault = [&](PrettyAsset const& asset,
339 Account const& owner,
340 Account const& depositor,
341 Account const& issuer) -> std::pair<Vault, Keylet> {
342 Vault const vault{env};
343
344 auto const& [tx, vaultKeylet, subscriptionDate] = vault.createClosedEnded(
345 {.owner = owner, .asset = asset, .subscriptionOffset = std::chrono::seconds{60}});
346 env(tx, Ter(tesSUCCESS));
347 env.close();
348
349 auto const& vaultSle = env.le(vaultKeylet);
350 BEAST_EXPECT(vaultSle != nullptr);
351 env.memoize(Account("vault", vaultSle->at(sfAccount)));
352 env(vault.deposit(
353 {.depositor = depositor, .id = vaultKeylet.key, .amount = asset(100)}),
354 Ter(tesSUCCESS));
355 env.close();
356
357 vault.closePastSubscription(subscriptionDate);
358
359 return std::make_pair(vault, vaultKeylet);
360 };
361
362 auto const testCase = [&](PrettyAsset const& asset,
363 std::string const& prefix,
364 Account const& owner,
365 Account const& depositor,
366 Account const& issuer) {
367 if (asset.native())
368 {
369 testcase("VaultClawback (asset) - " + prefix + " issuer XRP clawback fails");
370 auto [vault, vaultKeylet] = setupVault(asset, owner, depositor, issuer);
371 // If the asset is XRP, clawback with amount fails as malformed
372 // when asset is specified.
373 env(vault.clawback({
374 .issuer = issuer,
375 .id = vaultKeylet.key,
376 .holder = issuer,
377 .amount = asset(1).value(),
378 }),
379 Ter(temMALFORMED));
380 // When asset is implicit, clawback fails as no permission.
381 env(vault.clawback({
382 .issuer = issuer,
383 .id = vaultKeylet.key,
384 .holder = issuer,
385 }),
386 Ter(tecNO_PERMISSION));
387 return;
388 }
389
390 {
391 testcase(
392 "VaultClawback (asset) - " + prefix + " clawback for different asset fails");
393 auto [vault, vaultKeylet] = setupVault(asset, owner, depositor, issuer);
394
395 Account const issuer2{"issuer2"};
396 PrettyAsset const asset2 = issuer2["FOO"];
397 env(vault.clawback({
398 .issuer = issuer,
399 .id = vaultKeylet.key,
400 .holder = depositor,
401 .amount = asset2(1).value(),
402 }),
403 Ter(tecWRONG_ASSET));
404 }
405
406 {
407 testcase(
408 "VaultClawback (asset) - " + prefix +
409 " ambiguous owner/issuer asset clawback fails");
410 auto [vault, vaultKeylet] = setupVault(asset, issuer, depositor, issuer);
411 env(vault.clawback({
412 .issuer = issuer,
413 .id = vaultKeylet.key,
414 .holder = issuer,
415 }),
416 Ter(tecWRONG_ASSET));
417 }
418
419 {
420 testcase("VaultClawback (asset) - " + prefix + " non-issuer asset clawback fails");
421 auto [vault, vaultKeylet] = setupVault(asset, owner, depositor, issuer);
422
423 env(vault.clawback({
424 .issuer = owner,
425 .id = vaultKeylet.key,
426 .holder = depositor,
427 }),
428 Ter(tecNO_PERMISSION));
429
430 env(vault.clawback({
431 .issuer = owner,
432 .id = vaultKeylet.key,
433 .holder = depositor,
434 .amount = asset(1).value(),
435 }),
436 Ter(tecNO_PERMISSION));
437 }
438
439 {
440 testcase("VaultClawback (asset) - " + prefix + " issuer clawback from self fails");
441 auto [vault, vaultKeylet] = setupVault(asset, owner, issuer, issuer);
442 env(vault.clawback({
443 .issuer = issuer,
444 .id = vaultKeylet.key,
445 .holder = issuer,
446 }),
447 Ter(tecNO_PERMISSION));
448 }
449
450 {
451 testcase("VaultClawback (asset) - " + prefix + " issuer share clawback fails");
452 auto [vault, vaultKeylet] = setupVault(asset, owner, depositor, issuer);
453 auto const& vaultSle = env.le(vaultKeylet);
454 if (!BEAST_EXPECT(vaultSle))
455 return;
456 Asset const share = vaultSle->at(sfShareMPTID);
457
458 env(vault.clawback({
459 .issuer = issuer,
460 .id = vaultKeylet.key,
461 .holder = depositor,
462 .amount = share(1).value(),
463 }),
464 Ter(tecNO_PERMISSION));
465 }
466
467 {
468 testcase(
469 "VaultClawback (asset) - " + prefix +
470 " partial issuer asset clawback succeeds");
471 auto [vault, vaultKeylet] = setupVault(asset, owner, depositor, issuer);
472
473 env(vault.clawback({
474 .issuer = issuer,
475 .id = vaultKeylet.key,
476 .holder = depositor,
477 .amount = asset(1).value(),
478 }),
479 Ter(tesSUCCESS));
480 }
481
482 {
483 testcase(
484 "VaultClawback (asset) - " + prefix + " full issuer asset clawback succeeds");
485 auto [vault, vaultKeylet] = setupVault(asset, owner, depositor, issuer);
486
487 env(vault.clawback({
488 .issuer = issuer,
489 .id = vaultKeylet.key,
490 .holder = depositor,
491 .amount = asset(100).value(),
492 }),
493 Ter(tesSUCCESS));
494 }
495
496 {
497 testcase(
498 "VaultClawback (asset) - " + prefix +
499 " implicit full issuer asset clawback succeeds");
500 auto [vault, vaultKeylet] = setupVault(asset, owner, depositor, issuer);
501
502 env(vault.clawback({
503 .issuer = issuer,
504 .id = vaultKeylet.key,
505 .holder = depositor,
506 }),
507 Ter(tesSUCCESS));
508 }
509
510 {
511 testcase(
512 "VaultClawback (asset) - " + prefix +
513 " zero-amount clawback clamped with outstanding loan");
514 auto [vault, vaultKeylet] = setupVault(asset, owner, depositor, issuer);
515
516 auto const vaultSle = env.le(vaultKeylet);
517 if (!BEAST_EXPECT(vaultSle))
518 return;
519
520 PrettyAsset const shares = MPTIssue(vaultSle->at(sfShareMPTID));
521
522 // Create a loan broker backed by this vault
523 auto const brokerKeylet =
524 keylet::loanBroker(owner.id(), SeqProxy::rawSequence(env.seq(owner)));
525 env(set(owner, vaultKeylet.key));
526 env.close();
527
528 // Depositor borrows 40 units, reducing assetsAvailable to 60
529 // while assetsTotal stays at 100
530 env(set(depositor, brokerKeylet.key, asset(40).value()),
531 loan::kInterestRate(TenthBips32(0)),
532 kGracePeriod(60),
533 kPaymentInterval(120),
534 kPaymentTotal(10),
535 Sig(sfCounterpartySignature, owner),
536 Fee(env.current()->fees().base * 2),
537 Ter(tesSUCCESS));
538 env.close();
539
540 {
541 auto const sle = env.le(vaultKeylet);
542 BEAST_EXPECT(sle->at(sfAssetsAvailable) == asset(60).value());
543 BEAST_EXPECT(sle->at(sfAssetsTotal) == asset(100).value());
544 }
545
546 // Zero-amount clawback (= "clawback all") should succeed,
547 // clamped to assetsAvailable (60) rather than the full
548 // share value (100).
549 env(vault.clawback({
550 .issuer = issuer,
551 .id = vaultKeylet.key,
552 .holder = depositor,
553 }),
554 Ter(tesSUCCESS));
555 env.close();
556
557 // Only 60 assets clawed back; loan's 40 still outstanding
558 {
559 auto const sle = env.le(vaultKeylet);
560 BEAST_EXPECT(sle != nullptr);
561 BEAST_EXPECT(sle->at(sfAssetsAvailable) == asset(0).value());
562 BEAST_EXPECT(sle->at(sfAssetsTotal) == asset(40).value());
563
564 // 60 of 100 shares destroyed (1:1 ratio), 40 remain
565 auto const sharesAfter = env.balance(depositor, shares);
566 BEAST_EXPECT(sharesAfter == shares(Number{4, sle->at(sfScale) + 1}));
567 }
568 }
569
570 {
571 testcase(
572 "VaultClawback (asset) - " + prefix +
573 " non-zero clawback clamped with outstanding loan");
574 auto [vault, vaultKeylet] = setupVault(asset, owner, depositor, issuer);
575
576 auto const vaultSle = env.le(vaultKeylet);
577 if (!BEAST_EXPECT(vaultSle))
578 return;
579 PrettyAsset const shares = MPTIssue(vaultSle->at(sfShareMPTID));
580
581 // Create a loan broker backed by this vault
582 auto const brokerKeylet =
583 keylet::loanBroker(owner.id(), SeqProxy::rawSequence(env.seq(owner)));
584 env(set(owner, vaultKeylet.key));
585 env.close();
586
587 // Depositor borrows 40 units
588 env(set(depositor, brokerKeylet.key, asset(40).value()),
589 loan::kInterestRate(TenthBips32(0)),
590 kGracePeriod(60),
591 kPaymentInterval(120),
592 kPaymentTotal(10),
593 Sig(sfCounterpartySignature, owner),
594 Fee(env.current()->fees().base * 2),
595 Ter(tesSUCCESS));
596 env.close();
597
598 {
599 auto const sle = env.le(vaultKeylet);
600 BEAST_EXPECT(sle->at(sfAssetsAvailable) == asset(60).value());
601 BEAST_EXPECT(sle->at(sfAssetsTotal) == asset(100).value());
602 }
603
604 // Request 100 but only 60 available — clamped to 60
605 env(vault.clawback({
606 .issuer = issuer,
607 .id = vaultKeylet.key,
608 .holder = depositor,
609 .amount = asset(100).value(),
610 }),
611 Ter(tesSUCCESS));
612 env.close();
613
614 {
615 auto const sle = env.le(vaultKeylet);
616 BEAST_EXPECT(sle != nullptr);
617 BEAST_EXPECT(sle->at(sfAssetsAvailable) == asset(0).value());
618 BEAST_EXPECT(sle->at(sfAssetsTotal) == asset(40).value());
619
620 // 60 of 100 shares destroyed (1:1 ratio), 40 remain
621 auto const sharesAfter = env.balance(depositor, shares);
622 BEAST_EXPECT(sharesAfter == shares(Number{4, sle->at(sfScale) + 1}));
623 }
624 }
625
626 {
627 testcase(
628 "VaultClawback (asset) - " + prefix +
629 " partial clawback below available with outstanding loan");
630 auto [vault, vaultKeylet] = setupVault(asset, owner, depositor, issuer);
631
632 auto const vaultSle = env.le(vaultKeylet);
633 if (!BEAST_EXPECT(vaultSle))
634 return;
635 PrettyAsset const shares = MPTIssue(vaultSle->at(sfShareMPTID));
636
637 // Create a loan broker backed by this vault
638 auto const brokerKeylet =
639 keylet::loanBroker(owner.id(), SeqProxy::rawSequence(env.seq(owner)));
640 env(set(owner, vaultKeylet.key));
641 env.close();
642
643 // Depositor borrows 40 units: assetsAvailable=60, assetsTotal=100
644 env(set(depositor, brokerKeylet.key, asset(40).value()),
645 loan::kInterestRate(TenthBips32(0)),
646 kGracePeriod(60),
647 kPaymentInterval(120),
648 kPaymentTotal(10),
649 Sig(sfCounterpartySignature, owner),
650 Fee(env.current()->fees().base * 2),
651 Ter(tesSUCCESS));
652 env.close();
653
654 {
655 auto const sle = env.le(vaultKeylet);
656 BEAST_EXPECT(sle->at(sfAssetsAvailable) == asset(60).value());
657 BEAST_EXPECT(sle->at(sfAssetsTotal) == asset(100).value());
658 }
659
660 // Clawback 30 — well under available (60), no clamping needed
661 env(vault.clawback({
662 .issuer = issuer,
663 .id = vaultKeylet.key,
664 .holder = depositor,
665 .amount = asset(30).value(),
666 }),
667 Ter(tesSUCCESS));
668 env.close();
669
670 {
671 auto const sle = env.le(vaultKeylet);
672 BEAST_EXPECT(sle != nullptr);
673 BEAST_EXPECT(sle->at(sfAssetsAvailable) == asset(30).value());
674 BEAST_EXPECT(sle->at(sfAssetsTotal) == asset(70).value());
675
676 // 30 of 100 shares destroyed (1:1 ratio), 70 remain
677 auto const sharesAfter = env.balance(depositor, shares);
678 BEAST_EXPECT(sharesAfter == shares(Number{7, sle->at(sfScale) + 1}));
679 }
680 }
681
682 {
683 testcase(
684 "VaultClawback (asset) - " + prefix +
685 " clawback exactly equal to available with outstanding loan");
686 auto [vault, vaultKeylet] = setupVault(asset, owner, depositor, issuer);
687
688 auto const vaultSle = env.le(vaultKeylet);
689 if (!BEAST_EXPECT(vaultSle))
690 return;
691 PrettyAsset const shares = MPTIssue(vaultSle->at(sfShareMPTID));
692
693 auto const brokerKeylet =
694 keylet::loanBroker(owner.id(), SeqProxy::rawSequence(env.seq(owner)));
695 env(set(owner, vaultKeylet.key));
696 env.close();
697
698 // Depositor borrows 40 units: assetsAvailable=60, assetsTotal=100
699 env(set(depositor, brokerKeylet.key, asset(40).value()),
700 loan::kInterestRate(TenthBips32(0)),
701 kGracePeriod(60),
702 kPaymentInterval(120),
703 kPaymentTotal(10),
704 Sig(sfCounterpartySignature, owner),
705 Fee(env.current()->fees().base * 2),
706 Ter(tesSUCCESS));
707 env.close();
708
709 // Clawback exactly 60 — at the boundary, no clamping needed
710 env(vault.clawback({
711 .issuer = issuer,
712 .id = vaultKeylet.key,
713 .holder = depositor,
714 .amount = asset(60).value(),
715 }),
716 Ter(tesSUCCESS));
717 env.close();
718
719 {
720 auto const sle = env.le(vaultKeylet);
721 BEAST_EXPECT(sle != nullptr);
722 BEAST_EXPECT(sle->at(sfAssetsAvailable) == asset(0).value());
723 BEAST_EXPECT(sle->at(sfAssetsTotal) == asset(40).value());
724
725 // 60 of 100 shares destroyed (1:1 ratio), 40 remain
726 auto const sharesAfter = env.balance(depositor, shares);
727 BEAST_EXPECT(sharesAfter == shares(Number{4, sle->at(sfScale) + 1}));
728 }
729 }
730
731 {
732 testcase(
733 "VaultClawback (asset) - " + prefix +
734 " clawback with zero available (fully borrowed)");
735 auto [vault, vaultKeylet] = setupVault(asset, owner, depositor, issuer);
736
737 auto const vaultSle = env.le(vaultKeylet);
738 if (!BEAST_EXPECT(vaultSle))
739 return;
740 PrettyAsset const shares = MPTIssue(vaultSle->at(sfShareMPTID));
741
742 auto const brokerKeylet =
743 keylet::loanBroker(owner.id(), SeqProxy::rawSequence(env.seq(owner)));
744 env(set(owner, vaultKeylet.key));
745 env.close();
746
747 // Depositor borrows all 100 units: assetsAvailable=0, assetsTotal=100
748 env(set(depositor, brokerKeylet.key, asset(100).value()),
749 loan::kInterestRate(TenthBips32(0)),
750 kGracePeriod(60),
751 kPaymentInterval(120),
752 kPaymentTotal(10),
753 Sig(sfCounterpartySignature, owner),
754 Fee(env.current()->fees().base * 2),
755 Ter(tesSUCCESS));
756 env.close();
757
758 {
759 auto const sle = env.le(vaultKeylet);
760 BEAST_EXPECT(sle->at(sfAssetsAvailable) == asset(0).value());
761 BEAST_EXPECT(sle->at(sfAssetsTotal) == asset(100).value());
762 }
763
764 auto const sharesBefore = env.balance(depositor, shares);
765
766 // Zero-amount clawback — nothing available, clamped to 0,
767 // resulting in zero shares destroyed → tecPRECISION_LOSS
768 env(vault.clawback({
769 .issuer = issuer,
770 .id = vaultKeylet.key,
771 .holder = depositor,
772 }),
773 Ter(tecPRECISION_LOSS));
774 env.close();
775
776 // Explicit amount clawback — also nothing available
777 env(vault.clawback({
778 .issuer = issuer,
779 .id = vaultKeylet.key,
780 .holder = depositor,
781 .amount = asset(50).value(),
782 }),
783 Ter(tecPRECISION_LOSS));
784 env.close();
785
786 {
787 // Nothing changed — vault and shares unchanged
788 auto const sle = env.le(vaultKeylet);
789 BEAST_EXPECT(sle != nullptr);
790 BEAST_EXPECT(sle->at(sfAssetsAvailable) == asset(0).value());
791 BEAST_EXPECT(sle->at(sfAssetsTotal) == asset(100).value());
792 auto const sharesAfter = env.balance(depositor, shares);
793 BEAST_EXPECT(sharesAfter == sharesBefore);
794 }
795 }
796 };
797
798 Account const owner{"alice"};
799 Account const depositor{"bob"};
800 Account const issuer{"issuer"};
801
802 env.fund(XRP(10000), issuer, owner, depositor);
803 env.close();
804
805 // Test XRP
806 PrettyAsset const xrp = xrpIssue();
807 testCase(xrp, "XRP", owner, depositor, issuer);
808
809 // Test IOU
810 PrettyAsset const iou = issuer["IOU"];
811 env(fset(issuer, asfAllowTrustLineClawback));
812 env.close();
813 env.trust(iou(2000), owner);
814 env.trust(iou(2000), depositor);
815 env(pay(issuer, owner, iou(2000)));
816 env(pay(issuer, depositor, iou(2000)));
817 env.close();
818 testCase(iou, "IOU", owner, depositor, issuer);
819
820 // Test MPT
821 MPTTester mptt{env, issuer, kMptInitNoFund};
822 mptt.create({.flags = tfMPTCanClawback | tfMPTCanTransfer | tfMPTCanLock});
823
824 PrettyAsset const mpt = mptt.issuanceID();
825 mptt.authorize({.account = owner});
826 mptt.authorize({.account = depositor});
827 env(pay(issuer, depositor, mpt(2000)));
828 env.close();
829 testCase(mpt, "MPT", owner, depositor, issuer);
830
831 // Test pre-fixCleanup3_1_3 legacy path: zero-amount clawback
832 // returns early without clamping to assetsAvailable. This needs a
833 // Legacy/CashBasis Vault, so it runs against its own Env with
834 // featureLendingProtocolV1_2 disabled. The FixedPrecision version of
835 // this scenario is LoanSetFixedPrecision_test's
836 // testLendingFullClawbackClampsInsteadOfHasObligations.
837 {
838 testcase(
839 "VaultClawback (asset) - IOU pre-fixCleanup3_1_3"
840 " zero-amount clawback unclamped with outstanding loan");
841
842 Env legacyEnv(*this, all_);
843 legacyEnv.disableFeature(fixCleanup3_1_3);
844 legacyEnv.disableFeature(featureLendingProtocolV1_2);
845 legacyEnv.fund(XRP(10000), issuer, owner, depositor);
846 legacyEnv.close();
847
848 legacyEnv(fset(issuer, asfAllowTrustLineClawback));
849 legacyEnv.close();
850 legacyEnv.trust(iou(2000), owner);
851 legacyEnv.trust(iou(2000), depositor);
852 legacyEnv(pay(issuer, owner, iou(2000)));
853 legacyEnv(pay(issuer, depositor, iou(2000)));
854 legacyEnv.close();
855
856 Vault const vault{legacyEnv};
857 auto const& [tx, vaultKeylet, subscriptionDate] = vault.createClosedEnded(
858 {.owner = owner, .asset = iou, .subscriptionOffset = std::chrono::seconds{60}});
859 legacyEnv(tx, Ter(tesSUCCESS));
860 legacyEnv.close();
861
862 auto const vaultSleCreate = legacyEnv.le(vaultKeylet);
863 BEAST_EXPECT(vaultSleCreate != nullptr);
864 if (!vaultSleCreate)
865 return;
866 legacyEnv.memoize(Account("vault", vaultSleCreate->at(sfAccount)));
867 legacyEnv(
868 vault.deposit({.depositor = depositor, .id = vaultKeylet.key, .amount = iou(100)}),
869 Ter(tesSUCCESS));
870 legacyEnv.close();
871 vault.closePastSubscription(subscriptionDate);
872
873 auto const vaultSle = legacyEnv.le(vaultKeylet);
874 BEAST_EXPECT(vaultSle != nullptr);
875 if (!vaultSle)
876 return;
877
878 PrettyAsset const shares = MPTIssue(vaultSle->at(sfShareMPTID));
879
880 // Create a loan broker backed by this vault
881 auto const brokerKeylet =
882 keylet::loanBroker(owner.id(), SeqProxy::rawSequence(legacyEnv.seq(owner)));
883 legacyEnv(set(owner, vaultKeylet.key));
884 legacyEnv.close();
885
886 // Depositor borrows 40 units, reducing assetsAvailable to 60
887 // while assetsTotal stays at 100
888 legacyEnv(
889 set(depositor, brokerKeylet.key, iou(40).value()),
890 loan::kInterestRate(TenthBips32(0)),
891 kGracePeriod(60),
892 kPaymentInterval(120),
893 kPaymentTotal(10),
894 Sig(sfCounterpartySignature, owner),
895 Fee(legacyEnv.current()->fees().base * 2),
896 Ter(tesSUCCESS));
897 legacyEnv.close();
898
899 {
900 auto const sle = legacyEnv.le(vaultKeylet);
901 BEAST_EXPECT(sle->at(sfAssetsAvailable) == iou(60).value());
902 BEAST_EXPECT(sle->at(sfAssetsTotal) == iou(100).value());
903 }
904
905 auto const sharesBefore = legacyEnv.balance(depositor, shares);
906
907 // Legacy: zero-amount clawback tries to recover the full share
908 // value (100) without clamping to assetsAvailable (60). This
909 // causes the vault balance to go negative, triggering the
910 // sanity check in doApply -> tefINTERNAL.
911 legacyEnv(
912 vault.clawback({
913 .issuer = issuer,
914 .id = vaultKeylet.key,
915 .holder = depositor,
916 }),
917 Ter(tefINTERNAL));
918 legacyEnv.close();
919
920 {
921 // Transaction rolled back -- vault and shares unchanged
922 auto const sle = legacyEnv.le(vaultKeylet);
923 BEAST_EXPECT(sle != nullptr);
924 BEAST_EXPECT(sle->at(sfAssetsAvailable) == iou(60).value());
925 BEAST_EXPECT(sle->at(sfAssetsTotal) == iou(100).value());
926 auto const sharesAfter = legacyEnv.balance(depositor, shares);
927 BEAST_EXPECT(sharesAfter == sharesBefore);
928 }
929 }
930 }
931
932 void
934 {
935 using namespace test::jtx;
936 using namespace std::literals;
937
938 // Verify vault deposit/withdraw/clawback respect sfLockedAmount.
939 // When MPT tokens are escrowed, sfMPTAmount is reduced and
940 // sfLockedAmount is increased. Vault operations go through
941 // accountSend/accountHolds which read sfMPTAmount, so escrowed
942 // tokens are naturally excluded.
943
944 {
945 testcase("Vault deposit fails when MPT asset is escrowed");
946
947 Env env{*this, testableAmendments()};
948 auto const baseFee = env.current()->fees().base;
949 Account const owner{"owner"};
950 Account const depositor{"depositor"};
951 Account const issuer{"issuer"};
952 Account const bob{"bob"};
953
954 env.fund(XRP(10000), issuer, owner, depositor, bob);
955 env.close();
956
957 MPTTester mptt{env, issuer, kMptInitNoFund};
958 mptt.create(
959 {.flags = tfMPTCanClawback | tfMPTCanTransfer | tfMPTCanLock | tfMPTCanEscrow});
960 mptt.authorize({.account = owner});
961 mptt.authorize({.account = depositor});
962 mptt.authorize({.account = bob});
963 PrettyAsset const asset = mptt.issuanceID();
964 env(pay(issuer, depositor, asset(100)));
965 env.close();
966
967 // Escrow 60 of 100 MPT tokens: sfMPTAmount drops to 40
968 auto const escrowSeq = env.seq(depositor);
969 env(escrow::create(depositor, bob, asset(60)),
970 escrow::kCondition(escrow::kCb1),
971 escrow::kFinishTime(env.now() + 1s),
972 Fee(baseFee * 150),
973 Ter(tesSUCCESS));
974 env.close();
975
976 Vault const vault{env};
977 auto [tx, vaultKeylet] = vault.create({.owner = owner, .asset = asset});
978 env(tx, Ter(tesSUCCESS));
979 env.close();
980
981 // Deposit 100 should fail — only 40 spendable
982 env(vault.deposit(
983 {.depositor = depositor, .id = vaultKeylet.key, .amount = asset(100)}),
985 env.close();
986
987 // Deposit 40 (the unlocked balance) should succeed
988 env(vault.deposit({.depositor = depositor, .id = vaultKeylet.key, .amount = asset(40)}),
989 Ter(tesSUCCESS));
990 env.close();
991
992 {
993 auto const sle = env.le(vaultKeylet);
994 BEAST_EXPECT(sle->at(sfAssetsTotal) == asset(40).value());
995 }
996
997 // Clean up escrow
998 env(escrow::finish(bob, depositor, escrowSeq),
999 escrow::kCondition(escrow::kCb1),
1000 escrow::kFulfillment(escrow::kFb1),
1001 Fee(baseFee * 150),
1002 Ter(tesSUCCESS));
1003 env.close();
1004 }
1005
1006 {
1007 testcase("Vault withdraw respects escrowed shares");
1008
1009 Env env{*this, testableAmendments()};
1010 auto const baseFee = env.current()->fees().base;
1011 Account const owner{"owner"};
1012 Account const depositor{"depositor"};
1013 Account const issuer{"issuer"};
1014 Account const bob{"bob"};
1015
1016 env.fund(XRP(10000), issuer, owner, depositor, bob);
1017 env.close();
1018
1019 MPTTester mptt{env, issuer, kMptInitNoFund};
1020 mptt.create(
1021 {.flags = tfMPTCanClawback | tfMPTCanTransfer | tfMPTCanLock | tfMPTCanEscrow});
1022 mptt.authorize({.account = owner});
1023 mptt.authorize({.account = depositor});
1024 PrettyAsset const asset = mptt.issuanceID();
1025 env(pay(issuer, depositor, asset(100)));
1026 env.close();
1027
1028 Vault const vault{env};
1029 auto [tx, vaultKeylet] = vault.create({.owner = owner, .asset = asset});
1030 env(tx, Ter(tesSUCCESS));
1031 env.close();
1032
1033 // Deposit 100 → get shares
1034 env(vault.deposit(
1035 {.depositor = depositor, .id = vaultKeylet.key, .amount = asset(100)}),
1036 Ter(tesSUCCESS));
1037 env.close();
1038
1039 auto const vaultSle = env.le(vaultKeylet);
1040 if (!BEAST_EXPECT(vaultSle))
1041 return;
1042 env.memoize(Account("vault", vaultSle->at(sfAccount)));
1043 PrettyAsset const shares = MPTIssue(vaultSle->at(sfShareMPTID));
1044
1045 // Authorize bob for share MPT so he can receive escrowed shares
1046 auto const shareMPTID = vaultSle->at(sfShareMPTID);
1047 {
1048 json::Value jv;
1049 jv[jss::Account] = bob.human();
1050 jv[sfMPTokenIssuanceID] = to_string(shareMPTID);
1051 jv[jss::TransactionType] = jss::MPTokenAuthorize;
1052 env(jv, Ter(tesSUCCESS));
1053 env.close();
1054 }
1055
1056 // Escrow 60% of shares
1057 auto const escrowAmount = shares(Number{6, vaultSle->at(sfScale) + 1});
1058 env(escrow::create(depositor, bob, escrowAmount),
1059 escrow::kCondition(escrow::kCb1),
1060 escrow::kFinishTime(env.now() + 1s),
1061 Fee(baseFee * 150),
1062 Ter(tesSUCCESS));
1063 env.close();
1064
1065 // Withdraw all 100 should fail — only 40% of shares are unlocked
1066 env(vault.withdraw(
1067 {.depositor = depositor, .id = vaultKeylet.key, .amount = asset(100)}),
1069 env.close();
1070
1071 // Withdraw 40 (matching unlocked shares) should succeed
1072 env(vault.withdraw(
1073 {.depositor = depositor, .id = vaultKeylet.key, .amount = asset(40)}),
1074 Ter(tesSUCCESS));
1075 env.close();
1076
1077 {
1078 auto const sle = env.le(vaultKeylet);
1079 BEAST_EXPECT(sle->at(sfAssetsTotal) == asset(60).value());
1080 }
1081 }
1082
1083 {
1084 testcase("Vault clawback only recovers unlocked shares");
1085
1086 Env env{*this, testableAmendments() | fixCleanup3_1_3};
1087 auto const baseFee = env.current()->fees().base;
1088 Account const owner{"owner"};
1089 Account const depositor{"depositor"};
1090 Account const issuer{"issuer"};
1091 Account const bob{"bob"};
1092
1093 env.fund(XRP(10000), issuer, owner, depositor, bob);
1094 env.close();
1095
1096 MPTTester mptt{env, issuer, kMptInitNoFund};
1097 mptt.create(
1098 {.flags = tfMPTCanClawback | tfMPTCanTransfer | tfMPTCanLock | tfMPTCanEscrow});
1099 mptt.authorize({.account = owner});
1100 mptt.authorize({.account = depositor});
1101 PrettyAsset const asset = mptt.issuanceID();
1102 env(pay(issuer, depositor, asset(100)));
1103 env.close();
1104
1105 Vault const vault{env};
1106 auto [tx, vaultKeylet] = vault.create({.owner = owner, .asset = asset});
1107 env(tx, Ter(tesSUCCESS));
1108 env.close();
1109
1110 // Deposit 100 → get shares
1111 env(vault.deposit(
1112 {.depositor = depositor, .id = vaultKeylet.key, .amount = asset(100)}),
1113 Ter(tesSUCCESS));
1114 env.close();
1115
1116 auto const vaultSle = env.le(vaultKeylet);
1117 if (!BEAST_EXPECT(vaultSle))
1118 return;
1119 env.memoize(Account("vault", vaultSle->at(sfAccount)));
1120 PrettyAsset const shares = MPTIssue(vaultSle->at(sfShareMPTID));
1121
1122 // Authorize bob for share MPT so he can receive escrowed shares
1123 auto const shareMPTID = vaultSle->at(sfShareMPTID);
1124 {
1125 json::Value jv;
1126 jv[jss::Account] = bob.human();
1127 jv[sfMPTokenIssuanceID] = to_string(shareMPTID);
1128 jv[jss::TransactionType] = jss::MPTokenAuthorize;
1129 env(jv, Ter(tesSUCCESS));
1130 env.close();
1131 }
1132
1133 // Escrow 60% of shares
1134 auto const escrowAmount = shares(Number{6, vaultSle->at(sfScale) + 1});
1135 env(escrow::create(depositor, bob, escrowAmount),
1136 escrow::kCondition(escrow::kCb1),
1137 escrow::kFinishTime(env.now() + 1s),
1138 Fee(baseFee * 150),
1139 Ter(tesSUCCESS));
1140 env.close();
1141
1142 // Zero-amount clawback ("all") — should only recover assets
1143 // corresponding to unlocked shares (40%)
1144 env(vault.clawback({
1145 .issuer = issuer,
1146 .id = vaultKeylet.key,
1147 .holder = depositor,
1148 }),
1149 Ter(tesSUCCESS));
1150 env.close();
1151
1152 {
1153 auto const sle = env.le(vaultKeylet);
1154 BEAST_EXPECT(sle != nullptr);
1155 // Only 40 of 100 assets recovered (matching 40% unlocked shares)
1156 BEAST_EXPECT(sle->at(sfAssetsTotal) == asset(60).value());
1157 BEAST_EXPECT(sle->at(sfAssetsAvailable) == asset(60).value());
1158
1159 // Depositor's unlocked shares are now 0
1160 auto const sharesAfter = env.balance(depositor, shares);
1161 BEAST_EXPECT(sharesAfter == shares(0));
1162 }
1163 }
1164 }
1165
1166 // A clawback naming a holder that cannot hold vault shares must leave the vault untouched,
1167 // whether it is refused in preclaim (with the fix) or fails later (without it).
1168 void
1170 {
1171 using namespace test::jtx;
1172
1173 struct Case
1174 {
1175 std::string name;
1176 bool pseudoAccount; // otherwise the holder has no AccountRoot
1177 uint256 fix;
1178 TER guarded;
1179 TER legacyImplicit;
1180 TER legacyExplicit;
1181 };
1182
1183 // Pre-fixCleanup3_4_0 an explicit amount from a pseudo-account debits the vault and trips
1184 // the "shares must move" invariant. Pre-fixCleanup3_5_0 a missing holder fails in doApply.
1185 std::vector<Case> const cases{
1186 {
1187 .name = "pseudo-account",
1188 .pseudoAccount = true,
1189 .fix = fixCleanup3_4_0,
1190 .guarded = tecPSEUDO_ACCOUNT,
1191 .legacyImplicit = tecPRECISION_LOSS,
1192 .legacyExplicit = tecINVARIANT_FAILED,
1193 },
1194 {
1195 .name = "nonexistent",
1196 .pseudoAccount = false,
1197 .fix = fixCleanup3_5_0,
1198 .guarded = terNO_ACCOUNT,
1199 .legacyImplicit = tecPRECISION_LOSS,
1200 .legacyExplicit = tecNO_AUTH,
1201 },
1202 };
1203
1204 auto const runScenario = [this](
1205 Case const& c,
1206 FeatureBitset features,
1207 std::string const& prefix) {
1208 bool const guarded = features[c.fix];
1209 Env env{*this, features};
1210
1211 Account const owner{"owner"};
1212 Account const depositor{"depositor"};
1213 Account const issuer{"issuer"};
1214
1215 env.fund(XRP(1'000), owner, depositor, issuer);
1216 env.close();
1217
1218 env(fset(issuer, asfAllowTrustLineClawback));
1219 env.close();
1220
1221 PrettyAsset const asset = issuer["IOU"];
1222 env.trust(asset(1'000), owner);
1223 env.trust(asset(1'000), depositor);
1224 env(pay(issuer, depositor, asset(200)));
1225 env.close();
1226
1227 Vault const vault{env};
1228 auto [tx, keylet] = vault.create({.owner = owner, .asset = asset});
1229 env(tx);
1230 env.close();
1231
1232 auto const vaultSle = env.le(keylet);
1233 if (!BEAST_EXPECT(vaultSle))
1234 return;
1235 Account const holder = c.pseudoAccount
1236 ? Account{"vault pseudo-account", vaultSle->at(sfAccount)}
1237 : Account{"ghost"};
1238 env.memoize(holder);
1239
1240 env(vault.deposit({.depositor = depositor, .id = keylet.key, .amount = asset(100)}));
1241 env.close();
1242
1243 auto const assetsBefore = [&] -> Number {
1244 auto const sle = env.le(keylet);
1245 if (!BEAST_EXPECT(sle))
1246 return Number{};
1247 return sle->at(sfAssetsTotal);
1248 }();
1249
1250 {
1251 testcase("VaultClawback - " + prefix + " " + c.name + " holder, implicit amount");
1252 env(vault.clawback({
1253 .issuer = issuer,
1254 .id = keylet.key,
1255 .holder = holder,
1256 }),
1257 Ter(guarded ? c.guarded : c.legacyImplicit));
1258 env.close();
1259 }
1260
1261 {
1262 testcase("VaultClawback - " + prefix + " " + c.name + " holder, explicit amount");
1263 env(vault.clawback({
1264 .issuer = issuer,
1265 .id = keylet.key,
1266 .holder = holder,
1267 .amount = asset(10).value(),
1268 }),
1269 Ter(guarded ? c.guarded : c.legacyExplicit));
1270 env.close();
1271 }
1272
1273 // Neither attempt may touch the vault, whichever way it was refused.
1274 auto const sleAfter = env.le(keylet);
1275 BEAST_EXPECT(sleAfter && sleAfter->at(sfAssetsTotal) == assetsBefore);
1276 };
1277
1278 for (auto const& c : cases)
1279 {
1280 runScenario(c, all_, "post-rule");
1281 runScenario(c, all_ - c.fix, "pre-rule");
1282 }
1283 }
1284
1285public:
1286 void
1294};
1295
1297
1298} // namespace xrpl
TestcaseT testcase
Memberspace for declaring test cases.
Definition suite.h:155
Represents a JSON value.
Definition json_value.h:121
AccountID const & getIssuer() const
Definition Asset.cpp:21
Number is a floating point type that can represent a wide range of values.
Definition Number.h:351
static constexpr SeqProxy rawSequence(std::uint32_t v)
Factory function to return a sequence-based SeqProxy.
Definition SeqProxy.h:62
void run() override
Runs the suite.
Shared base for the Vault*_test family under src/test/app/vault/.
FeatureBitset const all_
test::jtx::PrettyAsset PrettyAsset
T make_pair(T... args)
Keylet computation functions.
Definition Indexes.h:39
Keylet loanBroker(AccountID const &owner, SeqProxy const &seq) noexcept
Definition Indexes.cpp:571
Keylet loan(UInt256 const &loanBrokerID, SeqProxy const &loanSeq) noexcept
Definition Indexes.cpp:577
Keylet mptokenIssuance(MPTID const &issuanceID) noexcept
Definition Indexes.cpp:541
Use hash_* containers for keys that do not need a cryptographically secure hashing algorithm.
Definition algorithm.h:5
@ terNO_ACCOUNT
Definition TER.h:219
bool set(T &target, std::string const &name, Section const &section)
Set a value from a configuration Section If the named value is not found or doesn't parse as a T,...
Issue const & xrpIssue()
Returns an asset specifier that represents XRP.
Definition Issue.h:108
@ tefINTERNAL
Definition TER.h:167
TenthBips< std::uint32_t > TenthBips32
Definition Units.h:454
std::string to_string(BaseUInt< Bits, Tag > const &a)
Definition base_uint.h:658
BEAST_DEFINE_TESTSUITE_PRIO(NFTokenBaseUtil, app, xrpl, 2)
@ temMALFORMED
Definition TER.h:75
TERSubset< CanCvtToTER > TER
Definition TER.h:657
@ tecWRONG_ASSET
Definition TER.h:371
@ tecPSEUDO_ACCOUNT
Definition TER.h:373
@ tecNO_AUTH
Definition TER.h:311
@ tecINVARIANT_FAILED
Definition TER.h:324
@ tecINSUFFICIENT_FUNDS
Definition TER.h:336
@ tecPRECISION_LOSS
Definition TER.h:374
@ tecLIMIT_EXCEEDED
Definition TER.h:372
@ tecNO_PERMISSION
Definition TER.h:316
@ tesSUCCESS
Definition TER.h:253
UInt256 uint256
Definition base_uint.h:587
A pair of SHAMap key and LedgerEntryType.
Definition Keylet.h:20