xrpld
Loading...
Searching...
No Matches
VaultLifecycle_test.cpp
1#include <test/app/vault/VaultTestBase.h>
2#include <test/jtx/AMM.h>
3#include <test/jtx/AMMTest.h>
4#include <test/jtx/Account.h>
5#include <test/jtx/Env.h>
6#include <test/jtx/TestHelpers.h>
7#include <test/jtx/amount.h>
8#include <test/jtx/flags.h>
9#include <test/jtx/mpt.h>
10#include <test/jtx/offer.h>
11#include <test/jtx/paths.h>
12#include <test/jtx/pay.h>
13#include <test/jtx/rate.h>
14#include <test/jtx/sendmax.h>
15#include <test/jtx/ter.h>
16#include <test/jtx/ticket.h>
17#include <test/jtx/trust.h>
18#include <test/jtx/txflags.h>
19#include <test/jtx/vault.h>
20
21#include <xrpl/basics/Number.h>
22#include <xrpl/basics/base_uint.h>
23#include <xrpl/beast/unit_test/suite.h>
24#include <xrpl/beast/utility/Zero.h>
25#include <xrpl/json/json_forwards.h>
26#include <xrpl/json/json_value.h>
27#include <xrpl/protocol/AccountID.h>
28#include <xrpl/protocol/Asset.h>
29#include <xrpl/protocol/Feature.h>
30#include <xrpl/protocol/Indexes.h>
31#include <xrpl/protocol/Issue.h>
32#include <xrpl/protocol/Keylet.h>
33#include <xrpl/protocol/LedgerFormats.h>
34#include <xrpl/protocol/MPTIssue.h>
35#include <xrpl/protocol/SField.h>
36#include <xrpl/protocol/STAmount.h>
37#include <xrpl/protocol/TER.h>
38#include <xrpl/protocol/TxFlags.h>
39#include <xrpl/protocol/UintTypes.h>
40#include <xrpl/protocol/XRPAmount.h>
41#include <xrpl/protocol/jss.h>
42
43#include <cstdint>
44#include <functional>
45#include <string>
46#include <tuple>
47#include <utility>
48
49namespace xrpl {
50
52{
53private:
60
64 static FundedVault
66 test::jtx::Env& env,
67 test::jtx::Vault& vault,
68 test::jtx::Account const& owner,
69 test::jtx::Account const& depositor,
70 STAmount const& amount)
71 {
72 auto [tx, keylet] = vault.create({.owner = owner, .asset = amount.asset()});
73 env(tx);
74 env.close();
75 env(vault.deposit({.depositor = depositor, .id = keylet.key, .amount = amount}));
76 env.close();
77
78 auto const sle = env.le(keylet);
79 test::jtx::Account const account{"vault", sle->at(sfAccount)};
80 env.memoize(account);
81 return {
82 .keylet = keylet,
83 .account = account,
84 .shares = test::jtx::PrettyAsset{MPTIssue{sle->at(sfShareMPTID)}},
85 };
86 }
87 void
89 {
90 using namespace test::jtx;
91 Account const issuer{"issuer"};
92 Account const owner{"owner"};
93 Account const depositor{"depositor"};
94 Account const charlie{"charlie"}; // authorized 3rd party
95 Account const dave{"dave"};
96
97 auto const testSequence = [&, this](
98 std::string const& prefix,
99 Env& env,
100 Vault& vault,
101 PrettyAsset const& asset) {
102 auto [tx, keylet] = vault.create({.owner = owner, .asset = asset});
103 tx[sfData] = "AFEED00E";
104 tx[sfAssetsMaximum] = asset(100).number();
105 env(tx);
106 env.close();
107 BEAST_EXPECT(env.le(keylet));
108 std::uint64_t const scale = asset.raw().holds<MPTIssue>() ? 1 : 1e6;
109
110 auto const [share, vaultAccount] =
111 [&env, keylet = keylet, asset, this] -> std::tuple<PrettyAsset, Account> {
112 auto const vault = env.le(keylet);
113 BEAST_EXPECT(vault != nullptr);
114 if (!asset.integral())
115 {
116 BEAST_EXPECT(vault->at(sfScale) == 6);
117 }
118 else
119 {
120 BEAST_EXPECT(vault->at(sfScale) == 0);
121 }
122 auto const shares = env.le(keylet::mptokenIssuance(vault->at(sfShareMPTID)));
123 BEAST_EXPECT(shares != nullptr);
124 if (!asset.integral())
125 {
126 BEAST_EXPECT(shares->at(sfAssetScale) == 6);
127 }
128 else
129 {
130 BEAST_EXPECT(shares->at(sfAssetScale) == 0);
131 }
132 return {MPTIssue(vault->at(sfShareMPTID)), Account("vault", vault->at(sfAccount))};
133 }();
134 auto const shares = share.raw().get<MPTIssue>();
135 env.memoize(vaultAccount);
136
137 // Several 3rd party accounts which cannot receive funds
138 Account const alice{"alice"};
139 Account const erin{"erin"}; // not authorized by issuer
140 env.fund(XRP(1000), alice, erin);
141 env(fset(alice, asfDepositAuth));
142 env.close();
143
144 {
145 testcase(prefix + " fail to deposit more than assets held");
146 auto const tx = vault.deposit(
147 {.depositor = depositor, .id = keylet.key, .amount = asset(10000)});
148 env(tx, Ter(tecINSUFFICIENT_FUNDS));
149 env.close();
150 }
151
152 {
153 testcase(prefix + " deposit non-zero amount");
154 auto const tx =
155 vault.deposit({.depositor = depositor, .id = keylet.key, .amount = asset(50)});
156 env(tx);
157 env.close();
158 BEAST_EXPECT(env.balance(depositor, shares) == share(50 * scale));
159 }
160
161 {
162 testcase(prefix + " deposit non-zero amount again");
163 auto const tx =
164 vault.deposit({.depositor = depositor, .id = keylet.key, .amount = asset(50)});
165 env(tx);
166 env.close();
167 BEAST_EXPECT(env.balance(depositor, shares) == share(100 * scale));
168 }
169
170 {
171 testcase(prefix + " fail to delete non-empty vault");
172 auto const tx = vault.del({.owner = owner, .id = keylet.key});
173 env(tx, Ter(tecHAS_OBLIGATIONS));
174 env.close();
175 }
176
177 {
178 testcase(prefix + " fail to update because wrong owner");
179 auto tx = vault.set({.owner = issuer, .id = keylet.key});
180 tx[sfAssetsMaximum] = asset(50).number();
181 env(tx, Ter(tecNO_PERMISSION));
182 env.close();
183 }
184
185 {
186 testcase(prefix + " fail to set maximum lower than current amount");
187 auto tx = vault.set({.owner = owner, .id = keylet.key});
188 tx[sfAssetsMaximum] = asset(50).number();
189 env(tx, Ter(tecLIMIT_EXCEEDED));
190 env.close();
191 }
192
193 {
194 testcase(prefix + " set maximum higher than current amount");
195 auto tx = vault.set({.owner = owner, .id = keylet.key});
196 tx[sfAssetsMaximum] = asset(150).number();
197 env(tx);
198 env.close();
199 }
200
201 {
202 testcase(prefix + " set maximum is idempotent, set it again");
203 auto tx = vault.set({.owner = owner, .id = keylet.key});
204 tx[sfAssetsMaximum] = asset(150).number();
205 env(tx);
206 env.close();
207 }
208
209 {
210 testcase(prefix + " set data");
211 auto tx = vault.set({.owner = owner, .id = keylet.key});
212 tx[sfData] = "0";
213 env(tx);
214 env.close();
215 }
216
217 {
218 testcase(prefix + " fail to set domain on public vault");
219 auto tx = vault.set({.owner = owner, .id = keylet.key});
220 tx[sfDomainID] = to_string(BaseUInt<256>(42ul));
221 env(tx, Ter{tecNO_PERMISSION});
222 env.close();
223 }
224
225 {
226 testcase(prefix + " fail to deposit more than maximum");
227 auto const tx =
228 vault.deposit({.depositor = depositor, .id = keylet.key, .amount = asset(100)});
229 env(tx, Ter(tecLIMIT_EXCEEDED));
230 env.close();
231 }
232
233 {
234 testcase(prefix + " reset maximum to zero i.e. not enforced");
235 auto tx = vault.set({.owner = owner, .id = keylet.key});
236 tx[sfAssetsMaximum] = asset(0).number();
237 env(tx);
238 env.close();
239 }
240
241 {
242 testcase(prefix + " fail to withdraw more than assets held");
243 auto const tx = vault.withdraw(
244 {.depositor = depositor, .id = keylet.key, .amount = asset(1000)});
245 env(tx, Ter(tecINSUFFICIENT_FUNDS));
246 env.close();
247 }
248
249 {
250 testcase(prefix + " deposit some more");
251 auto const tx =
252 vault.deposit({.depositor = depositor, .id = keylet.key, .amount = asset(100)});
253 env(tx);
254 env.close();
255 BEAST_EXPECT(env.balance(depositor, shares) == share(200 * scale));
256 }
257
258 {
259 testcase(prefix + " clawback some");
260 auto const code = asset.raw().native() ? Ter(temMALFORMED) : Ter(tesSUCCESS);
261 auto const tx = vault.clawback(
262 {.issuer = issuer, .id = keylet.key, .holder = depositor, .amount = asset(10)});
263 env(tx, code);
264 env.close();
265 if (!asset.raw().native())
266 {
267 BEAST_EXPECT(env.balance(depositor, shares) == share(190 * scale));
268 }
269 }
270
271 {
272 testcase(prefix + " clawback all");
273 auto const code = asset.raw().native() ? Ter(tecNO_PERMISSION) : Ter(tesSUCCESS);
274 auto const tx =
275 vault.clawback({.issuer = issuer, .id = keylet.key, .holder = depositor});
276 env(tx, code);
277 env.close();
278 if (!asset.raw().native())
279 {
280 BEAST_EXPECT(env.balance(depositor, shares) == share(0));
281
282 {
283 auto const tx = vault.clawback({
284 .issuer = issuer,
285 .id = keylet.key,
286 .holder = depositor,
287 .amount = asset(10),
288 });
289 env(tx, Ter{tecPRECISION_LOSS});
290 env.close();
291 }
292
293 {
294 auto const tx = vault.withdraw(
295 {.depositor = depositor, .id = keylet.key, .amount = asset(10)});
296 env(tx, Ter{tecPRECISION_LOSS});
297 env.close();
298 }
299 }
300 }
301
302 if (!asset.raw().native())
303 {
304 testcase(prefix + " deposit again");
305 auto const tx =
306 vault.deposit({.depositor = depositor, .id = keylet.key, .amount = asset(200)});
307 env(tx);
308 env.close();
309 BEAST_EXPECT(env.balance(depositor, shares) == share(200 * scale));
310 }
311 else
312 {
313 testcase(prefix + " deposit/withdrawal same or less than fee");
314 auto const amount = env.current()->fees().base;
315
316 auto tx =
317 vault.deposit({.depositor = depositor, .id = keylet.key, .amount = amount});
318 env(tx);
319 env.close();
320
321 tx = vault.withdraw({.depositor = depositor, .id = keylet.key, .amount = amount});
322 env(tx);
323 env.close();
324
325 tx = vault.deposit({.depositor = depositor, .id = keylet.key, .amount = amount});
326 env(tx);
327 env.close();
328
329 // Withdraw to 3rd party
330 tx = vault.withdraw({.depositor = depositor, .id = keylet.key, .amount = amount});
331 tx[sfDestination] = charlie.human();
332 env(tx);
333 env.close();
334
335 tx =
336 vault.deposit({.depositor = depositor, .id = keylet.key, .amount = amount - 1});
337 env(tx);
338 env.close();
339
340 tx = vault.withdraw(
341 {.depositor = depositor, .id = keylet.key, .amount = amount - 1});
342 env(tx);
343 env.close();
344 }
345
346 {
347 testcase(prefix + " fail to withdraw to 3rd party lsfDepositAuth");
348 auto tx = vault.withdraw(
349 {.depositor = depositor, .id = keylet.key, .amount = asset(100)});
350 tx[sfDestination] = alice.human();
351 env(tx, Ter{tecNO_PERMISSION});
352 env.close();
353 }
354
355 {
356 testcase(prefix + " fail to withdraw to zero destination");
357 auto tx = vault.withdraw(
358 {.depositor = depositor, .id = keylet.key, .amount = asset(1000)});
359 tx[sfDestination] = "0";
360 env(tx, Ter(temMALFORMED));
361 env.close();
362 }
363
364 if (!asset.raw().native())
365 {
366 testcase(prefix + " fail to withdraw to 3rd party no authorization");
367 auto tx = vault.withdraw(
368 {.depositor = depositor, .id = keylet.key, .amount = asset(100)});
369 tx[sfDestination] = erin.human();
370 env(tx, Ter{asset.raw().holds<Issue>() ? tecNO_LINE : tecNO_AUTH});
371 env.close();
372 }
373
374 {
375 testcase(prefix + " fail to withdraw to 3rd party lsfRequireDestTag");
376 auto tx = vault.withdraw(
377 {.depositor = depositor, .id = keylet.key, .amount = asset(100)});
378 tx[sfDestination] = dave.human();
379 env(tx, Ter{tecDST_TAG_NEEDED});
380 env.close();
381 }
382
383 {
384 testcase(prefix + " withdraw to 3rd party lsfRequireDestTag");
385 auto tx =
386 vault.withdraw({.depositor = depositor, .id = keylet.key, .amount = asset(50)});
387 tx[sfDestination] = dave.human();
388 tx[sfDestinationTag] = "0";
389 env(tx);
390 env.close();
391 }
392
393 {
394 testcase(prefix + " deposit again");
395 auto const tx =
396 vault.deposit({.depositor = dave, .id = keylet.key, .amount = asset(50)});
397 env(tx);
398 env.close();
399 }
400
401 {
402 testcase(prefix + " fail to withdraw lsfRequireDestTag");
403 auto const tx =
404 vault.withdraw({.depositor = dave, .id = keylet.key, .amount = asset(50)});
405 env(tx, Ter{tecDST_TAG_NEEDED});
406 env.close();
407 }
408
409 {
410 testcase(prefix + " withdraw with tag");
411 auto tx =
412 vault.withdraw({.depositor = dave, .id = keylet.key, .amount = asset(50)});
413 tx[sfDestinationTag] = "0";
414 env(tx);
415 env.close();
416 }
417
418 {
419 testcase(prefix + " withdraw to authorized 3rd party");
420 auto tx =
421 vault.withdraw({.depositor = depositor, .id = keylet.key, .amount = asset(50)});
422 tx[sfDestination] = charlie.human();
423 env(tx);
424 env.close();
425 BEAST_EXPECT(env.balance(depositor, shares) == share(100 * scale));
426 }
427
428 {
429 testcase(prefix + " withdraw to issuer");
430 auto tx =
431 vault.withdraw({.depositor = depositor, .id = keylet.key, .amount = asset(50)});
432 tx[sfDestination] = issuer.human();
433 env(tx);
434 env.close();
435 BEAST_EXPECT(env.balance(depositor, shares) == share(50 * scale));
436 }
437
438 if (!asset.raw().native())
439 {
440 testcase(prefix + " issuer deposits");
441 auto tx =
442 vault.deposit({.depositor = issuer, .id = keylet.key, .amount = asset(10)});
443 env(tx);
444 env.close();
445 BEAST_EXPECT(env.balance(issuer, shares) == share(10 * scale));
446
447 testcase(prefix + " issuer withdraws");
448 tx = vault.withdraw(
449 {.depositor = issuer, .id = keylet.key, .amount = share(10 * scale)});
450 env(tx);
451 env.close();
452 BEAST_EXPECT(env.balance(issuer, shares) == share(0 * scale));
453 }
454
455 {
456 testcase(prefix + " withdraw remaining assets");
457 auto const tx =
458 vault.withdraw({.depositor = depositor, .id = keylet.key, .amount = asset(50)});
459 env(tx);
460 env.close();
461 BEAST_EXPECT(env.balance(depositor, shares) == share(0));
462
463 if (!asset.raw().native())
464 {
465 auto const tx = vault.clawback({
466 .issuer = issuer,
467 .id = keylet.key,
468 .holder = depositor,
469 .amount = asset(0),
470 });
471 env(tx, Ter{tecPRECISION_LOSS});
472 env.close();
473 }
474
475 {
476 auto const tx = vault.withdraw(
477 {.depositor = depositor, .id = keylet.key, .amount = share(10)});
478 env(tx, Ter{tecINSUFFICIENT_FUNDS});
479 env.close();
480 }
481 }
482
483 if (!asset.integral())
484 {
485 testcase(prefix + " temporary authorization for 3rd party");
486 env(trust(erin, asset(1000)));
487 env(trust(issuer, asset(0), erin, tfSetfAuth));
488 env(pay(issuer, erin, asset(10)));
489
490 // Erin deposits all in vault, then sends shares to depositor
491 auto tx = vault.deposit({.depositor = erin, .id = keylet.key, .amount = asset(10)});
492 env(tx);
493 env.close();
494 {
495 auto const tx = pay(erin, depositor, share(10 * scale));
496
497 // depositor no longer has MPToken for shares
498 env(tx, Ter{tecNO_AUTH});
499 env.close();
500
501 // depositor will gain MPToken for shares again
502 env(vault.deposit(
503 {.depositor = depositor, .id = keylet.key, .amount = asset(1)}));
504 env.close();
505
506 env(tx);
507 env.close();
508 }
509
510 testcase(prefix + " withdraw to authorized 3rd party");
511 // Depositor withdraws assets, destined to Erin
512 tx =
513 vault.withdraw({.depositor = depositor, .id = keylet.key, .amount = asset(10)});
514 tx[sfDestination] = erin.human();
515 env(tx);
516 env.close();
517
518 // Erin returns assets to issuer
519 env(pay(erin, issuer, asset(10)));
520 env.close();
521
522 testcase(prefix + " fail to pay to unauthorized 3rd party");
523 env(trust(erin, asset(0)));
524 env.close();
525
526 // Erin has MPToken but is no longer authorized to hold assets
527 env(pay(depositor, erin, share(1)), Ter{tecNO_LINE});
528 env.close();
529
530 // Depositor withdraws remaining single asset
531 tx = vault.withdraw({.depositor = depositor, .id = keylet.key, .amount = asset(1)});
532 env(tx);
533 env.close();
534 }
535
536 {
537 testcase(prefix + " fail to delete because wrong owner");
538 auto const tx = vault.del({.owner = issuer, .id = keylet.key});
539 env(tx, Ter(tecNO_PERMISSION));
540 env.close();
541 }
542
543 {
544 testcase(prefix + " delete empty vault");
545 auto const tx = vault.del({.owner = owner, .id = keylet.key});
546 env(tx);
547 env.close();
548 BEAST_EXPECT(!env.le(keylet));
549 }
550 };
551
552 auto const testCases =
553 [&, this](std::string prefix, std::function<PrettyAsset(Env & env)> setup) {
554 Env env{*this, testableAmendments()};
555
556 Vault vault{env};
557 env.fund(XRP(1000), issuer, owner, depositor, charlie, dave);
558 env.close();
559 env(fset(issuer, asfAllowTrustLineClawback));
560 env(fset(issuer, asfRequireAuth));
561 env(fset(dave, asfRequireDest));
562 env.close();
563 env.require(Flags(issuer, asfAllowTrustLineClawback));
564 env.require(Flags(issuer, asfRequireAuth));
565
566 PrettyAsset const asset = setup(env);
567 testSequence(prefix, env, vault, asset);
568 };
569
570 testCases("XRP", [&](Env& env) -> PrettyAsset { return {xrpIssue(), 1'000'000}; });
571
572 testCases("IOU", [&](Env& env) -> Asset {
573 PrettyAsset const asset = issuer["IOU"];
574 env(trust(owner, asset(1000)));
575 env(trust(depositor, asset(1000)));
576 env(trust(charlie, asset(1000)));
577 env(trust(dave, asset(1000)));
578 env(trust(issuer, asset(0), owner, tfSetfAuth));
579 env(trust(issuer, asset(0), depositor, tfSetfAuth));
580 env(trust(issuer, asset(0), charlie, tfSetfAuth));
581 env(trust(issuer, asset(0), dave, tfSetfAuth));
582 env(pay(issuer, depositor, asset(1000)));
583 env.close();
584 return asset;
585 });
586
587 testCases("MPT", [&](Env& env) -> Asset {
588 MPTTester mptt{env, issuer, kMptInitNoFund};
589 mptt.create({.flags = tfMPTCanClawback | tfMPTCanTransfer | tfMPTCanLock});
590 PrettyAsset const asset = mptt.issuanceID();
591 mptt.authorize({.account = depositor});
592 mptt.authorize({.account = charlie});
593 mptt.authorize({.account = dave});
594 env(pay(issuer, depositor, asset(1000)));
595 env.close();
596 return asset;
597 });
598 }
599
600 void
602 {
603 using namespace test::jtx;
604
605 struct CaseArgs
606 {
607 bool enableClawback = true;
608 bool requireAuth = true;
609 int initialXRP = 1000;
610 std::uint16_t transferFee = 0;
611 FeatureBitset features = testableAmendments();
612 };
613
614 auto const testCase = [this](
615 std::function<void(
616 Env & env,
617 Account const& issuer,
618 Account const& owner,
619 Account const& depositor,
620 Asset const& asset,
621 Vault& vault,
622 MPTTester& mptt)> test,
623 CaseArgs args = {}) {
624 Env env{*this, args.features};
625 Account const issuer{"issuer"};
626 Account const owner{"owner"};
627 Account const depositor{"depositor"};
628 env.fund(XRP(args.initialXRP), issuer, owner, depositor);
629 env.close();
630 Vault vault{env};
631
632 MPTTester mptt{env, issuer, kMptInitNoFund};
633 auto const kNone = LedgerSpecificFlags(0);
634 mptt.create({
635 .transferFee = args.transferFee,
636 .flags = tfMPTCanTransfer | tfMPTCanLock |
637 (args.enableClawback ? tfMPTCanClawback : kNone) |
638 (args.requireAuth ? tfMPTRequireAuth : kNone),
639 });
640 PrettyAsset const asset = mptt.issuanceID();
641 mptt.authorize({.account = owner});
642 mptt.authorize({.account = depositor});
643 if (args.requireAuth)
644 {
645 mptt.authorize({.account = issuer, .holder = owner});
646 mptt.authorize({.account = issuer, .holder = depositor});
647 }
648
649 env(pay(issuer, depositor, asset(1000)));
650 env.close();
651
652 test(env, issuer, owner, depositor, asset, vault, mptt);
653 };
654
655 // The MPT charges a 25% transfer fee, so 100 gross delivers 80 net.
656 auto const feeArgs = CaseArgs{.transferFee = 25'000};
657
658 auto const testTransferFeeGate = [&](FeatureBitset const& features) {
659 testCase(
660 [this, features](
661 Env& env,
662 Account const&,
663 Account const& owner,
664 Account const& depositor,
665 PrettyAsset const& asset,
666 Vault& vault,
667 MPTTester& mptt) {
668 bool const feeCharged = features[fixCleanup3_5_0];
669 testcase(
670 feeCharged ? "MPT transfer fee on third-party withdrawal"
671 : "MPT transfer fee waived pre-fixCleanup3_5_0");
672
673 auto const funded = createFundedVault(env, vault, owner, depositor, asset(100));
674
675 auto tx = vault.withdraw({
676 .depositor = depositor,
677 .id = funded.keylet.key,
678 .amount = funded.shares(100),
679 });
680 tx[sfDestination] = owner.human();
681 env(tx);
682 env.close();
683
684 auto const expected = feeCharged ? 80 : 100;
685 BEAST_EXPECT(mptt.checkMPTokenAmount(depositor, 900));
686 BEAST_EXPECT(mptt.checkMPTokenAmount(owner, expected));
687 BEAST_EXPECT(mptt.checkMPTokenOutstandingAmount(900 + expected));
688 BEAST_EXPECT(
689 env.balance(funded.account, asset.raw().get<MPTIssue>()) == asset(0));
690
691 env(vault.del({.owner = owner, .id = funded.keylet.key}));
692 env.close();
693 },
694 CaseArgs{.transferFee = 25'000, .features = features});
695 };
696 testTransferFeeGate(testableAmendments() - fixCleanup3_5_0);
697 testTransferFeeGate(testableAmendments());
698
699 testCase(
700 [this](
701 Env& env,
702 Account const&,
703 Account const& owner,
704 Account const& depositor,
705 PrettyAsset const& asset,
706 Vault& vault,
707 MPTTester& mptt) {
708 testcase("MPT transfer fee on fixed-asset third-party withdrawal");
709
710 auto const funded = createFundedVault(env, vault, owner, depositor, asset(100));
711 auto const mptIssue = asset.raw().get<MPTIssue>();
712 auto const shareIssue = funded.shares.raw().get<MPTIssue>();
713
714 auto tx = vault.withdraw(
715 {.depositor = depositor, .id = funded.keylet.key, .amount = asset(40)});
716 tx[sfDestination] = owner.human();
717 env(tx);
718 env.close();
719
720 // The destination receives the requested 40; the gross 50 leaves the vault.
721 BEAST_EXPECT(mptt.checkMPTokenAmount(owner, 40));
722 BEAST_EXPECT(env.balance(funded.account, mptIssue) == asset(50));
723 BEAST_EXPECT(env.balance(depositor, shareIssue) == funded.shares(50));
724 BEAST_EXPECT(mptt.checkMPTokenOutstandingAmount(990));
725 },
726 feeArgs);
727
728 testCase(
729 [this](
730 Env& env,
731 Account const&,
732 Account const& owner,
733 Account const& depositor,
734 PrettyAsset const& asset,
735 Vault& vault,
736 MPTTester& mptt) {
737 testcase("MPT transfer fee on fixed-share third-party withdrawal");
738
739 auto const funded = createFundedVault(env, vault, owner, depositor, asset(100));
740 auto const mptIssue = asset.raw().get<MPTIssue>();
741 auto const shareIssue = funded.shares.raw().get<MPTIssue>();
742
743 auto tx = vault.withdraw(
744 {.depositor = depositor, .id = funded.keylet.key, .amount = funded.shares(25)});
745 tx[sfDestination] = owner.human();
746 env(tx);
747 env.close();
748
749 // The 25 shares redeem 25 assets; the destination receives 20 net.
750 BEAST_EXPECT(mptt.checkMPTokenAmount(owner, 20));
751 BEAST_EXPECT(env.balance(funded.account, mptIssue) == asset(75));
752 BEAST_EXPECT(env.balance(depositor, shareIssue) == funded.shares(75));
753 BEAST_EXPECT(mptt.checkMPTokenOutstandingAmount(995));
754 },
755 feeArgs);
756
757 testCase(
758 [this](
759 Env& env,
760 Account const& issuer,
761 Account const& owner,
762 Account const& depositor,
763 PrettyAsset const& asset,
764 Vault& vault,
765 MPTTester& mptt) {
766 testcase("MPT no transfer fee on withdrawal to issuer");
767
768 auto const funded = createFundedVault(env, vault, owner, depositor, asset(100));
769 auto const mptIssue = asset.raw().get<MPTIssue>();
770 auto const shareIssue = funded.shares.raw().get<MPTIssue>();
771
772 auto tx = vault.withdraw(
773 {.depositor = depositor, .id = funded.keylet.key, .amount = asset(10)});
774 tx[sfDestination] = issuer.human();
775 env(tx);
776 env.close();
777
778 BEAST_EXPECT(env.balance(funded.account, mptIssue) == asset(90));
779 BEAST_EXPECT(env.balance(depositor, shareIssue) == funded.shares(90));
780 BEAST_EXPECT(mptt.checkMPTokenOutstandingAmount(990));
781 },
782 feeArgs);
783
784 testCase(
785 [this](
786 Env& env,
787 Account const&,
788 Account const& owner,
789 Account const& depositor,
790 PrettyAsset const& asset,
791 Vault& vault,
792 MPTTester& mptt) {
793 testcase("MPT no transfer fee on self-withdrawal");
794
795 auto const funded = createFundedVault(env, vault, owner, depositor, asset(100));
796 auto const mptIssue = asset.raw().get<MPTIssue>();
797
798 env(vault.withdraw(
799 {.depositor = depositor, .id = funded.keylet.key, .amount = asset(10)}));
800 env.close();
801
802 BEAST_EXPECT(mptt.checkMPTokenAmount(depositor, 910));
803 BEAST_EXPECT(env.balance(funded.account, mptIssue) == asset(90));
804 BEAST_EXPECT(mptt.checkMPTokenOutstandingAmount(1000));
805 },
806 feeArgs);
807
808 testCase(
809 [this](
810 Env& env,
811 Account const&,
812 Account const& owner,
813 Account const& depositor,
814 PrettyAsset const& asset,
815 Vault& vault,
816 MPTTester& mptt) {
817 testcase("MPT transfer fee must fit in the vault position");
818
819 auto const funded = createFundedVault(env, vault, owner, depositor, asset(100));
820 auto const mptIssue = asset.raw().get<MPTIssue>();
821 auto const shareIssue = funded.shares.raw().get<MPTIssue>();
822
823 // Delivering 81 costs 102 gross, more than the 100 shares held.
824 auto tx = vault.withdraw(
825 {.depositor = depositor, .id = funded.keylet.key, .amount = asset(81)});
826 tx[sfDestination] = owner.human();
827 env(tx, Ter{tecINSUFFICIENT_FUNDS});
828 env.close();
829
830 // Delivering 80 costs exactly the 100 shares held.
831 tx = vault.withdraw(
832 {.depositor = depositor, .id = funded.keylet.key, .amount = asset(80)});
833 tx[sfDestination] = owner.human();
834 env(tx);
835 env.close();
836
837 BEAST_EXPECT(mptt.checkMPTokenAmount(owner, 80));
838 BEAST_EXPECT(env.balance(funded.account, mptIssue) == asset(0));
839 BEAST_EXPECT(env.balance(depositor, shareIssue) == funded.shares(0));
840 BEAST_EXPECT(mptt.checkMPTokenOutstandingAmount(980));
841
842 env(vault.del({.owner = owner, .id = funded.keylet.key}));
843 env.close();
844 },
845 feeArgs);
846
847 // The payout rounds down whether or not MPTokensV2 is enabled.
848 auto const testTransferFeeRoundsDown = [&](FeatureBitset const& features) {
849 testCase(
850 [this, features](
851 Env& env,
852 Account const&,
853 Account const& owner,
854 Account const& depositor,
855 PrettyAsset const& asset,
856 Vault& vault,
857 MPTTester& mptt) {
858 testcase(
859 features[featureMPTokensV2]
860 ? "MPT transfer fee rounds the payout down to zero"
861 : "MPT transfer fee rounds the payout down to zero without "
862 "MPTokensV2");
863
864 auto const funded = createFundedVault(env, vault, owner, depositor, asset(1));
865 auto const mptIssue = asset.raw().get<MPTIssue>();
866
867 auto tx = vault.withdraw({
868 .depositor = depositor,
869 .id = funded.keylet.key,
870 .amount = funded.shares(1),
871 });
872 tx[sfDestination] = owner.human();
873 env(tx, Ter{tecPRECISION_LOSS});
874 env.close();
875
876 // A self-withdrawal pays no fee, so the same share still redeems.
877 env(vault.withdraw({
878 .depositor = depositor,
879 .id = funded.keylet.key,
880 .amount = funded.shares(1),
881 }));
882 env.close();
883
884 BEAST_EXPECT(mptt.checkMPTokenAmount(depositor, 1000));
885 BEAST_EXPECT(env.balance(funded.account, mptIssue) == asset(0));
886
887 env(vault.del({.owner = owner, .id = funded.keylet.key}));
888 env.close();
889 },
890 CaseArgs{.transferFee = 25'000, .features = features});
891 };
892 testTransferFeeRoundsDown(testableAmendments());
893 testTransferFeeRoundsDown(testableAmendments() - featureMPTokensV2);
894
895 testCase(
896 [this](
897 Env& env,
898 Account const& issuer,
899 Account const& owner,
900 Account const& depositor,
901 PrettyAsset const& asset,
902 Vault& vault,
903 MPTTester& mptt) {
904 testcase("MPT transfer fee leaves other depositors whole");
905
906 Account const charlie{"charlie"};
907 env.fund(XRP(1000), charlie);
908 env.close();
909 mptt.authorize({.account = charlie});
910 mptt.authorize({.account = issuer, .holder = charlie});
911 env(pay(issuer, owner, asset(100)));
912 env.close();
913
914 auto const funded = createFundedVault(env, vault, owner, depositor, asset(100));
915 env(vault.deposit(
916 {.depositor = owner, .id = funded.keylet.key, .amount = asset(100)}));
917 env.close();
918 auto const shareIssue = funded.shares.raw().get<MPTIssue>();
919
920 auto const vaultBefore = env.le(funded.keylet);
921 Number const assetsTotalBefore = vaultBefore->at(sfAssetsTotal);
922 Number const assetsAvailableBefore = vaultBefore->at(sfAssetsAvailable);
923
924 // Delivering 40 to charlie costs the depositor 50 gross.
925 auto tx = vault.withdraw(
926 {.depositor = depositor, .id = funded.keylet.key, .amount = asset(40)});
927 tx[sfDestination] = charlie.human();
928 env(tx);
929 env.close();
930
931 BEAST_EXPECT(mptt.checkMPTokenAmount(charlie, 40));
932 auto const vaultAfter = env.le(funded.keylet);
933 BEAST_EXPECT(vaultAfter->at(sfAssetsTotal) == assetsTotalBefore - 50);
934 BEAST_EXPECT(vaultAfter->at(sfAssetsAvailable) == assetsAvailableBefore - 50);
935
936 // The owner's 100 shares still redeem for the 100 it deposited.
937 BEAST_EXPECT(env.balance(owner, shareIssue) == funded.shares(100));
938 env(vault.withdraw(
939 {.depositor = owner, .id = funded.keylet.key, .amount = funded.shares(100)}));
940 env.close();
941 BEAST_EXPECT(mptt.checkMPTokenAmount(owner, 100));
942 },
943 feeArgs);
944
945 testCase(
946 [this](
947 Env& env,
948 Account const& issuer,
949 Account const& owner,
950 Account const& depositor,
951 PrettyAsset const& asset,
952 Vault& vault,
953 MPTTester& mptt) {
954 testcase("MPT no transfer fee on issuer withdrawal to a third party");
955
956 auto const funded = createFundedVault(env, vault, owner, issuer, asset(100));
957 auto const mptIssue = asset.raw().get<MPTIssue>();
958 auto const shareIssue = funded.shares.raw().get<MPTIssue>();
959
960 auto tx = vault.withdraw(
961 {.depositor = issuer, .id = funded.keylet.key, .amount = asset(40)});
962 tx[sfDestination] = depositor.human();
963 env(tx);
964 env.close();
965
966 BEAST_EXPECT(mptt.checkMPTokenAmount(depositor, 1040));
967 BEAST_EXPECT(env.balance(funded.account, mptIssue) == asset(60));
968 BEAST_EXPECT(env.balance(issuer, shareIssue) == funded.shares(60));
969 BEAST_EXPECT(mptt.checkMPTokenOutstandingAmount(1100));
970 },
971 feeArgs);
972
973 testCase([this](
974 Env& env,
975 Account const& issuer,
976 Account const& owner,
977 Account const& depositor,
978 PrettyAsset const& asset,
979 Vault& vault,
980 MPTTester& mptt) {
981 testcase("MPT nothing to clawback from");
982 auto const tx = vault.clawback({
983 .issuer = issuer,
984 .id = keylet::skip().key,
985 .holder = depositor,
986 .amount = asset(10),
987 });
988 env(tx, Ter(tecNO_ENTRY));
989 });
990
991 testCase([this](
992 Env& env,
993 Account const& issuer,
994 Account const& owner,
995 Account const& depositor,
996 Asset const& asset,
997 Vault& vault,
998 MPTTester& mptt) {
999 testcase("MPT global lock blocks create");
1000 mptt.set({.account = issuer, .flags = tfMPTLock});
1001 auto [tx, keylet] = vault.create({.owner = owner, .asset = asset});
1002 env(tx, Ter(tecLOCKED));
1003 });
1004
1005 testCase([this](
1006 Env& env,
1007 Account const& issuer,
1008 Account const& owner,
1009 Account const& depositor,
1010 PrettyAsset const& asset,
1011 Vault& vault,
1012 MPTTester& mptt) {
1013 testcase("MPT only issuer can clawback");
1014
1015 auto [tx, keylet] = vault.create({.owner = owner, .asset = asset});
1016 env(tx);
1017 env.close();
1018
1019 tx = vault.deposit({.depositor = depositor, .id = keylet.key, .amount = asset(100)});
1020 env(tx);
1021 env.close();
1022
1023 {
1024 auto const tx = vault.clawback({
1025 .issuer = depositor,
1026 .id = keylet.key,
1027 .holder = depositor,
1028 });
1029 env(tx, Ter(tecNO_PERMISSION));
1030 }
1031
1032 {
1033 auto const tx = vault.clawback({
1034 .issuer = owner,
1035 .id = keylet.key,
1036 .holder = depositor,
1037 });
1038 env(tx, Ter(tecNO_PERMISSION));
1039 }
1040 });
1041
1042 testCase(
1043 [this](
1044 Env& env,
1045 Account const& issuer,
1046 Account const& owner,
1047 Account const& depositor,
1048 PrettyAsset const& asset,
1049 Vault& vault,
1050 MPTTester& mptt) {
1051 testcase("MPT depositor without MPToken, auth required");
1052
1053 auto [tx, keylet] = vault.create({.owner = owner, .asset = asset});
1054 env(tx);
1055 env.close();
1056
1057 tx = vault.deposit(
1058 {.depositor = depositor, .id = keylet.key, .amount = asset(1000)});
1059 env(tx);
1060 env.close();
1061
1062 {
1063 // Remove depositor MPToken and it will not be re-created
1064 mptt.authorize({.account = depositor, .flags = tfMPTUnauthorize});
1065 env.close();
1066
1067 auto const mptoken = keylet::mptoken(mptt.issuanceID(), depositor);
1068 auto const sleMPT1 = env.le(mptoken);
1069 BEAST_EXPECT(sleMPT1 == nullptr);
1070
1071 tx = vault.withdraw(
1072 {.depositor = depositor, .id = keylet.key, .amount = asset(100)});
1073 env(tx, Ter{tecNO_AUTH});
1074 env.close();
1075
1076 auto const sleMPT2 = env.le(mptoken);
1077 BEAST_EXPECT(sleMPT2 == nullptr);
1078 }
1079
1080 {
1081 // Set destination to 3rd party without MPToken
1082 Account const charlie{"charlie"};
1083 env.fund(XRP(1000), charlie);
1084 env.close();
1085
1086 tx = vault.withdraw(
1087 {.depositor = depositor, .id = keylet.key, .amount = asset(100)});
1088 tx[sfDestination] = charlie.human();
1089 env(tx, Ter(tecNO_AUTH));
1090 }
1091 },
1092 {.requireAuth = true});
1093
1094 testCase(
1095 [this](
1096 Env& env,
1097 Account const& issuer,
1098 Account const& owner,
1099 Account const& depositor,
1100 PrettyAsset const& asset,
1101 Vault& vault,
1102 MPTTester& mptt) {
1103 testcase("MPT depositor without MPToken, no auth required");
1104
1105 auto [tx, keylet] = vault.create({.owner = owner, .asset = asset});
1106 env(tx);
1107 env.close();
1108 auto const v = env.le(keylet);
1109 BEAST_EXPECT(v);
1110
1111 tx = vault.deposit({
1112 .depositor = depositor,
1113 .id = keylet.key,
1114 .amount = asset(1000),
1115 }); // all assets held by depositor
1116 env(tx);
1117 env.close();
1118
1119 {
1120 // Remove depositor's MPToken and it will be re-created
1121 mptt.authorize({.account = depositor, .flags = tfMPTUnauthorize});
1122 env.close();
1123
1124 auto const mptoken = keylet::mptoken(mptt.issuanceID(), depositor);
1125 auto const sleMPT1 = env.le(mptoken);
1126 BEAST_EXPECT(sleMPT1 == nullptr);
1127
1128 tx = vault.withdraw(
1129 {.depositor = depositor, .id = keylet.key, .amount = asset(100)});
1130 env(tx);
1131 env.close();
1132
1133 auto const sleMPT2 = env.le(mptoken);
1134 BEAST_EXPECT(sleMPT2 != nullptr);
1135 BEAST_EXPECT(sleMPT2->at(sfMPTAmount) == 100);
1136 }
1137
1138 {
1139 // Remove 3rd party MPToken and it will not be re-created
1140 mptt.authorize({.account = owner, .flags = tfMPTUnauthorize});
1141 env.close();
1142
1143 auto const mptoken = keylet::mptoken(mptt.issuanceID(), owner);
1144 auto const sleMPT1 = env.le(mptoken);
1145 BEAST_EXPECT(sleMPT1 == nullptr);
1146
1147 tx = vault.withdraw(
1148 {.depositor = depositor, .id = keylet.key, .amount = asset(100)});
1149 tx[sfDestination] = owner.human();
1150 env(tx, Ter(tecNO_AUTH));
1151 env.close();
1152
1153 auto const sleMPT2 = env.le(mptoken);
1154 BEAST_EXPECT(sleMPT2 == nullptr);
1155 }
1156 },
1157 {.requireAuth = false});
1158
1159 auto const redeemAllNoAssetMpt = [this](TER expected) {
1160 return [this, expected](
1161 Env& env,
1162 Account const&,
1163 Account const& owner,
1164 Account const& depositor,
1165 Asset const& asset,
1166 Vault& vault,
1167 MPTTester& mptt) {
1168 testcase << "MPT non-owner redeems all shares with no asset MPToken"
1169 << (isTesSuccess(expected) ? "" : " pre-fixCleanup3_4_0");
1170
1171 auto [tx, keylet] = vault.create({.owner = owner, .asset = asset});
1172 env(tx);
1173 env.close();
1174
1175 tx = vault.deposit({
1176 .depositor = depositor,
1177 .id = keylet.key,
1178 .amount = asset(1000),
1179 }); // all assets held by depositor
1180 env(tx);
1181 env.close();
1182
1183 auto const vaultSle = env.le(keylet);
1184 if (!BEAST_EXPECT(vaultSle))
1185 return;
1186 auto const shareMPTID = vaultSle->at(sfShareMPTID);
1187
1188 // Depositor's asset MPToken balance is now zero; delete it.
1189 mptt.authorize({.account = depositor, .flags = tfMPTUnauthorize});
1190 env.close();
1191
1192 auto const mptoken = keylet::mptoken(mptt.issuanceID(), depositor);
1193
1194 auto const shareKeylet = keylet::mptoken(shareMPTID, depositor.id());
1195 auto const sleShareBefore = env.le(shareKeylet);
1196 if (!BEAST_EXPECT(sleShareBefore))
1197 return;
1198 auto const shareAmountBefore = sleShareBefore->at(sfMPTAmount);
1199 auto const assetsTotalBefore = vaultSle->at(sfAssetsTotal);
1200 auto const assetsAvailableBefore = vaultSle->at(sfAssetsAvailable);
1201
1202 // Redeeming ALL shares in one transaction both erases the
1203 // now-empty share MPToken and re-creates the asset MPToken.
1204 tx = vault.withdraw(
1205 {.depositor = depositor, .id = keylet.key, .amount = asset(1000)});
1206 env(tx, Ter{expected});
1207 env.close();
1208
1209 auto const sleAsset = env.le(mptoken);
1210 auto const sleShare = env.le(shareKeylet);
1211 auto const vaultAfter = env.le(keylet);
1212 if (!BEAST_EXPECT(vaultAfter))
1213 return;
1214 if (isTesSuccess(expected))
1215 {
1216 if (!BEAST_EXPECT(sleAsset))
1217 return;
1218 BEAST_EXPECT(sleAsset->at(sfMPTAmount) == 1000);
1219 BEAST_EXPECT(!sleShare);
1220 BEAST_EXPECT(vaultAfter->at(sfAssetsTotal) == beast::kZero);
1221 BEAST_EXPECT(vaultAfter->at(sfAssetsAvailable) == beast::kZero);
1222 }
1223 else
1224 {
1225 BEAST_EXPECT(!sleAsset);
1226 if (!BEAST_EXPECT(sleShare))
1227 return;
1228 BEAST_EXPECT(sleShare->at(sfMPTAmount) == shareAmountBefore);
1229 BEAST_EXPECT(vaultAfter->at(sfAssetsTotal) == assetsTotalBefore);
1230 BEAST_EXPECT(vaultAfter->at(sfAssetsAvailable) == assetsAvailableBefore);
1231 }
1232 };
1233 };
1234
1235 testCase(redeemAllNoAssetMpt(tesSUCCESS), {.requireAuth = false});
1236 testCase(
1237 redeemAllNoAssetMpt(tecINVARIANT_FAILED),
1238 {.requireAuth = false, .features = testableAmendments() - fixCleanup3_4_0});
1239
1240 auto const [acctReserve, incReserve] = [this] -> std::pair<int, int> {
1241 Env const env{*this, testableAmendments()};
1242 return {
1243 env.current()->fees().accountReserve(0, 1).drops() / kDropsPerXrp.drops(),
1244 env.current()->fees().increment.drops() / kDropsPerXrp.drops()};
1245 }();
1246
1247 testCase(
1248 [&, this](
1249 Env& env,
1250 Account const& issuer,
1251 Account const& owner,
1252 Account const& depositor,
1253 PrettyAsset const& asset,
1254 Vault& vault,
1255 MPTTester& mptt) {
1256 testcase("MPT fail reserve to re-create MPToken");
1257
1258 auto [tx, keylet] = vault.create({.owner = owner, .asset = asset});
1259 env(tx);
1260 env.close();
1261 auto const v = env.le(keylet);
1262 BEAST_EXPECT(v);
1263
1264 env(pay(depositor, owner, asset(1000)));
1265 env.close();
1266
1267 tx = vault.deposit({
1268 .depositor = owner,
1269 .id = keylet.key,
1270 .amount = asset(1000),
1271 }); // all assets held by owner
1272 env(tx);
1273 env.close();
1274
1275 {
1276 // Remove owners's MPToken and it will not be re-created
1277 mptt.authorize({.account = owner, .flags = tfMPTUnauthorize});
1278 env.close();
1279
1280 auto const mptoken = keylet::mptoken(mptt.issuanceID(), owner);
1281 auto const sleMPT = env.le(mptoken);
1282 BEAST_EXPECT(sleMPT == nullptr);
1283
1284 // Use one reserve so the next transaction fails
1285 env(ticket::create(owner, 1));
1286 env.close();
1287
1288 // No reserve to create MPToken for asset in VaultWithdraw
1289 tx = vault.withdraw(
1290 {.depositor = owner, .id = keylet.key, .amount = asset(100)});
1291 env(tx, Ter{tecINSUFFICIENT_RESERVE});
1292 env.close();
1293
1294 env(pay(depositor, owner, XRP(incReserve)));
1295 env.close();
1296
1297 // Withdraw can now create asset MPToken, tx will succeed
1298 env(tx);
1299 env.close();
1300 }
1301 },
1302 {.requireAuth = false, .initialXRP = acctReserve + (incReserve * 4) + 1});
1303
1304 testCase([this](
1305 Env& env,
1306 Account const& issuer,
1307 Account const& owner,
1308 Account const& depositor,
1309 PrettyAsset const& asset,
1310 Vault& vault,
1311 MPTTester& mptt) {
1312 testcase("MPT issuance deleted");
1313
1314 auto [tx, keylet] = vault.create({.owner = owner, .asset = asset});
1315 env(tx);
1316 env.close();
1317
1318 tx = vault.deposit({.depositor = depositor, .id = keylet.key, .amount = asset(1000)});
1319 env(tx);
1320 env.close();
1321
1322 {
1323 auto const tx = vault.clawback(
1324 {.issuer = issuer, .id = keylet.key, .holder = depositor, .amount = asset(0)});
1325 env(tx);
1326 }
1327
1328 mptt.destroy({.issuer = issuer, .id = mptt.issuanceID()});
1329 env.close();
1330
1331 {
1332 auto [tx, keylet] = vault.create({.owner = depositor, .asset = asset});
1333 env(tx, Ter{tecOBJECT_NOT_FOUND});
1334 }
1335
1336 {
1337 auto const tx =
1338 vault.deposit({.depositor = depositor, .id = keylet.key, .amount = asset(10)});
1339 env(tx, Ter{tecOBJECT_NOT_FOUND});
1340 }
1341
1342 {
1343 auto const tx =
1344 vault.withdraw({.depositor = depositor, .id = keylet.key, .amount = asset(10)});
1345 env(tx, Ter{tecOBJECT_NOT_FOUND});
1346 }
1347
1348 {
1349 auto const tx = vault.clawback(
1350 {.issuer = issuer, .id = keylet.key, .holder = depositor, .amount = asset(0)});
1351 env(tx, Ter{tecOBJECT_NOT_FOUND});
1352 }
1353
1354 env(vault.del({.owner = owner, .id = keylet.key}));
1355 });
1356
1357 testCase([this](
1358 Env& env,
1359 Account const& issuer,
1360 Account const& owner,
1361 Account const& depositor,
1362 PrettyAsset const& asset,
1363 Vault& vault,
1364 MPTTester& mptt) {
1365 testcase("MPT vault owner can receive shares unless unauthorized");
1366
1367 auto [tx, keylet] = vault.create({.owner = owner, .asset = asset});
1368 env(tx);
1369 env.close();
1370
1371 tx = vault.deposit({.depositor = depositor, .id = keylet.key, .amount = asset(1000)});
1372 env(tx);
1373 env.close();
1374
1375 auto const issuanceId = [&env](xrpl::Keylet keylet) -> MPTID {
1376 auto const vault = env.le(keylet);
1377 return vault->at(sfShareMPTID);
1378 }(keylet);
1379 PrettyAsset const shares = MPTIssue(issuanceId);
1380
1381 {
1382 // owner has MPToken for shares they did not explicitly create
1383 env(pay(depositor, owner, shares(1)));
1384 env.close();
1385
1386 tx = vault.withdraw({.depositor = owner, .id = keylet.key, .amount = shares(1)});
1387 env(tx);
1388 env.close();
1389
1390 // owner's MPToken for vault shares not destroyed by withdraw
1391 env(pay(depositor, owner, shares(1)));
1392 env.close();
1393
1394 tx = vault.clawback(
1395 {.issuer = issuer, .id = keylet.key, .holder = owner, .amount = asset(0)});
1396 env(tx);
1397 env.close();
1398
1399 // owner's MPToken for vault shares not destroyed by clawback
1400 env(pay(depositor, owner, shares(1)));
1401 env.close();
1402
1403 // pay back, so we can destroy owner's MPToken now
1404 env(pay(owner, depositor, shares(1)));
1405 env.close();
1406
1407 {
1408 // explicitly destroy vault owners MPToken with zero balance
1409 json::Value jv;
1410 jv[sfAccount] = owner.human();
1411 jv[sfMPTokenIssuanceID] = to_string(issuanceId);
1412 jv[sfFlags] = tfMPTUnauthorize;
1413 jv[sfTransactionType] = jss::MPTokenAuthorize;
1414 env(jv);
1415 env.close();
1416 }
1417
1418 // owner no longer has MPToken for vault shares
1419 tx = pay(depositor, owner, shares(1));
1420 env(tx, Ter{tecNO_AUTH});
1421 env.close();
1422
1423 // destroy all remaining shares, so we can delete vault
1424 tx = vault.clawback(
1425 {.issuer = issuer, .id = keylet.key, .holder = depositor, .amount = asset(0)});
1426 env(tx);
1427 env.close();
1428
1429 // will soft fail destroying MPToken for vault owner
1430 env(vault.del({.owner = owner, .id = keylet.key}));
1431 env.close();
1432 }
1433 });
1434
1435 testCase(
1436 [this](
1437 Env& env,
1438 Account const& issuer,
1439 Account const& owner,
1440 Account const& depositor,
1441 PrettyAsset const& asset,
1442 Vault& vault,
1443 MPTTester& mptt) {
1444 testcase("MPT clawback disabled");
1445
1446 auto [tx, keylet] = vault.create({.owner = owner, .asset = asset});
1447 env(tx);
1448 env.close();
1449
1450 tx = vault.deposit(
1451 {.depositor = depositor, .id = keylet.key, .amount = asset(1000)});
1452 env(tx);
1453 env.close();
1454
1455 {
1456 auto const tx = vault.clawback({
1457 .issuer = issuer,
1458 .id = keylet.key,
1459 .holder = depositor,
1460 .amount = asset(0),
1461 });
1462 env(tx, Ter{tecNO_PERMISSION});
1463 }
1464 },
1465 {.enableClawback = false});
1466
1467 testCase([this](
1468 Env& env,
1469 Account const& issuer,
1470 Account const& owner,
1471 Account const& depositor,
1472 Asset const& asset,
1473 Vault& vault,
1474 MPTTester& mptt) {
1475 testcase("MPT un-authorization");
1476 auto [tx, keylet] = vault.create({.owner = owner, .asset = asset});
1477 env(tx);
1478 env.close();
1479 tx = vault.deposit({.depositor = depositor, .id = keylet.key, .amount = asset(1000)});
1480 env(tx);
1481 env.close();
1482
1483 mptt.authorize({.account = issuer, .holder = depositor, .flags = tfMPTUnauthorize});
1484 env.close();
1485
1486 {
1487 auto tx = vault.withdraw(
1488 {.depositor = depositor, .id = keylet.key, .amount = asset(100)});
1489 env(tx, Ter(tecNO_AUTH));
1490
1491 // Withdrawal to other (authorized) accounts works
1492 tx[sfDestination] = issuer.human();
1493 env(tx);
1494 env.close();
1495
1496 tx[sfDestination] = owner.human();
1497 env(tx);
1498 env.close();
1499 }
1500
1501 {
1502 // Cannot deposit some more
1503 auto const tx =
1504 vault.deposit({.depositor = depositor, .id = keylet.key, .amount = asset(100)});
1505 env(tx, Ter(tecNO_AUTH));
1506 }
1507
1508 {
1509 // Cannot clawback if issuer is the holder
1510 tx = vault.clawback(
1511 {.issuer = issuer, .id = keylet.key, .holder = issuer, .amount = asset(800)});
1512 env(tx, Ter(tecNO_PERMISSION));
1513 }
1514 // Clawback works
1515 tx = vault.clawback(
1516 {.issuer = issuer, .id = keylet.key, .holder = depositor, .amount = asset(800)});
1517 env(tx);
1518 env.close();
1519
1520 env(vault.del({.owner = owner, .id = keylet.key}));
1521 });
1522
1523 {
1524 testcase("MPT shares to a vault");
1525
1526 Env env{*this, testableAmendments()};
1527 Account const owner{"owner"};
1528 Account const issuer{"issuer"};
1529 env.fund(XRP(1000000), owner, issuer);
1530 env.close();
1531 Vault const vault{env};
1532
1533 MPTTester mptt{env, issuer, kMptInitNoFund};
1534 mptt.create(
1535 {.flags = tfMPTCanTransfer | tfMPTCanLock | lsfMPTCanClawback | tfMPTRequireAuth});
1536 mptt.authorize({.account = owner});
1537 mptt.authorize({.account = issuer, .holder = owner});
1538 PrettyAsset const asset = mptt.issuanceID();
1539 env(pay(issuer, owner, asset(100)));
1540 auto [tx1, k1] = vault.create({.owner = owner, .asset = asset});
1541 env(tx1);
1542 env.close();
1543
1544 auto const shares = [&env, keylet = k1, this] -> Asset {
1545 auto const vault = env.le(keylet);
1546 BEAST_EXPECT(vault != nullptr);
1547 return MPTIssue(vault->at(sfShareMPTID));
1548 }();
1549
1550 auto [tx2, k2] = vault.create({.owner = owner, .asset = shares});
1551 env(tx2, Ter{tecWRONG_ASSET});
1552 env.close();
1553 }
1554
1555 {
1556 testcase("MPT locked: vault shares inherit underlying lock");
1557
1558 Env env{*this, testableAmendments()};
1559 Account const issuer{"issuer"};
1560 Account const owner{"owner"};
1561 Account const alice{"alice"};
1562 Account const bob{"bob"};
1563 Account const carol{"carol"};
1564 env.fund(XRP(10'000), issuer, owner, alice, bob, carol);
1565 env.close();
1566 Vault const vault{env};
1567
1568 MPTTester asset{{
1569 .env = env,
1570 .issuer = issuer,
1571 .holders = {owner, alice, bob, carol},
1572 .flags = tfMPTCanTransfer | tfMPTCanTrade | tfMPTCanLock,
1573 }};
1574 env(pay(issuer, alice, asset(1'000)));
1575 env(pay(issuer, bob, asset(1'000)));
1576 env.close();
1577
1578 auto [tx, keylet] = vault.create({.owner = owner, .asset = asset});
1579 env(tx);
1580 env.close();
1581
1582 env(vault.deposit({.depositor = alice, .id = keylet.key, .amount = asset(500)}));
1583 // Bob also deposits so he has a share MPToken to receive into.
1584 env(vault.deposit({.depositor = bob, .id = keylet.key, .amount = asset(500)}));
1585 env.close();
1586
1587 auto const shares = [&] -> PrettyAsset {
1588 auto const sle = env.le(keylet);
1589 BEAST_EXPECT(sle != nullptr);
1590 return MPTIssue(sle->at(sfShareMPTID));
1591 }();
1592 auto const shareMptID = shares.raw().get<MPTIssue>().getMptID();
1593 auto const shareBalance = [&](Account const& account) {
1594 auto const sle = env.le(keylet::mptoken(shareMptID, account));
1595 return sle ? sle->at(sfMPTAmount) : 0;
1596 };
1597
1598 // Sanity: before the underlying lock, peer-to-peer share
1599 // transfers are allowed.
1600 env(pay(alice, bob, shares(1)));
1601 env.close();
1602
1603 // Create the offer while shares are spendable, then lock the
1604 // underlying to test whether a stale offer can still be crossed.
1605 env(offer(alice, XRP(1), shares(1)));
1606 env.close();
1607
1608 // Lock the underlying after the vault and share balances exist.
1609 asset.set({.account = issuer, .flags = tfMPTLock});
1610 env.close();
1611
1612 // Direct vault share payment inherits the underlying lock via
1613 // sfReferenceHolding. Caught in the strand check, like a global
1614 // or individual share lock.
1615 BEAST_EXPECT(shareBalance(alice) == 499);
1616 BEAST_EXPECT(shareBalance(bob) == 501);
1617 env(pay(alice, bob, shares(1)), Ter{tecPATH_DRY});
1618 env.close();
1619 BEAST_EXPECT(shareBalance(alice) == 499);
1620 BEAST_EXPECT(shareBalance(bob) == 501);
1621
1622 // The same inherited lock must also block DEX payment paths that
1623 // would consume an offer selling vault shares. bob, the
1624 // destination, inherits the lock and is caught in the strand
1625 // check.
1626 env(pay(carol, bob, shares(1)),
1627 Sendmax(XRP(1)),
1628 Path(BookSpec{shares.raw()}),
1629 Ter{tecPATH_DRY});
1630 env.close();
1631 BEAST_EXPECT(shareBalance(alice) == 499);
1632 BEAST_EXPECT(shareBalance(bob) == 501);
1633 BEAST_EXPECT(expectOffers(env, alice, 1));
1634 }
1635
1636 // A holder individually frozen on the underlying can neither sell
1637 // nor buy vault shares through an unfrozen holder's offer. The
1638 // inherited freeze is caught when the strand is built, before the
1639 // offer is consumed.
1640 auto const testShareDEXEndpointFrozen =
1641 [&](Env& env,
1642 PrettyAsset const& asset,
1643 Account const& owner,
1644 Account const& alice,
1645 Account const& bob,
1646 Account const& carol,
1647 std::function<void(bool)> const& setAliceFrozen) {
1648 Vault const vault{env};
1649 auto [tx, keylet] = vault.create({.owner = owner, .asset = asset});
1650 env(tx);
1651 env.close();
1652
1653 env(vault.deposit({.depositor = alice, .id = keylet.key, .amount = asset(500)}));
1654 env(vault.deposit({.depositor = bob, .id = keylet.key, .amount = asset(500)}));
1655 env.close();
1656
1657 PrettyAsset const shares = MPTIssue(env.le(keylet)->at(sfShareMPTID));
1658 auto const shareMptID = shares.raw().get<MPTIssue>().getMptID();
1659 auto const shareBalance = [&](Account const& account) {
1660 auto const sle = env.le(keylet::mptoken(shareMptID, account));
1661 return sle ? sle->at(sfMPTAmount) : 0;
1662 };
1663
1664 // bob bids XRP for shares and asks more XRP for shares, so that
1665 // his offers don't cross
1666 env(offer(bob, shares(1), XRP(1)));
1667 env(offer(bob, XRP(2), shares(1)));
1668 env.close();
1669
1670 setAliceFrozen(true);
1671
1672 auto const aliceShares = shareBalance(alice);
1673 auto const bobShares = shareBalance(bob);
1674 auto const expectUnchanged = [&] {
1675 BEAST_EXPECT(shareBalance(alice) == aliceShares);
1676 BEAST_EXPECT(shareBalance(bob) == bobShares);
1677 BEAST_EXPECT(expectOffers(env, bob, 2));
1678 };
1679
1680 // alice sells shares: the first step's source is frozen
1681 env(pay(alice, carol, XRP(1)),
1682 Sendmax(shares(1)),
1683 Path(~XRP),
1684 Txflags(tfNoRippleDirect),
1685 Ter{tecPATH_DRY});
1686 env.close();
1687 expectUnchanged();
1688
1689 // carol buys shares for alice: the last step's destination is
1690 // frozen
1691 env(pay(carol, alice, shares(1)),
1692 Sendmax(XRP(2)),
1693 Path(BookSpec{shares.raw()}),
1694 Txflags(tfNoRippleDirect),
1695 Ter{tecPATH_DRY});
1696 env.close();
1697 expectUnchanged();
1698
1699 // Both succeed once alice is unfrozen
1700 setAliceFrozen(false);
1701
1702 env(pay(alice, carol, XRP(1)),
1703 Sendmax(shares(1)),
1704 Path(~XRP),
1705 Txflags(tfNoRippleDirect));
1706 env.close();
1707 BEAST_EXPECT(shareBalance(bob) == bobShares + 1);
1708
1709 env(pay(carol, alice, shares(1)),
1710 Sendmax(XRP(2)),
1711 Path(BookSpec{shares.raw()}),
1712 Txflags(tfNoRippleDirect));
1713 env.close();
1714 BEAST_EXPECT(shareBalance(alice) == aliceShares);
1715 BEAST_EXPECT(shareBalance(bob) == bobShares);
1716 BEAST_EXPECT(expectOffers(env, bob, 0));
1717 };
1718
1719 // Vault shares as the intermediate asset between two books. Only the
1720 // offer owners hold the shares in transit. An owner individually
1721 // frozen on the underlying can neither give nor receive the shares.
1722 auto const testShareDEXMiddleFrozen = [&](Env& env,
1723 PrettyAsset const& asset,
1724 Account const& owner,
1725 Account const& alice,
1726 Account const& bob,
1727 Account const& carol,
1728 std::function<void(bool)> const& setAliceFrozen) {
1729 Vault const vault{env};
1730 auto [tx, keylet] = vault.create({.owner = owner, .asset = asset});
1731 env(tx);
1732 env.close();
1733
1734 env(vault.deposit({.depositor = alice, .id = keylet.key, .amount = asset(500)}));
1735 env(vault.deposit({.depositor = bob, .id = keylet.key, .amount = asset(500)}));
1736 env.close();
1737
1738 PrettyAsset const shares = MPTIssue(env.le(keylet)->at(sfShareMPTID));
1739 auto const shareMptID = shares.raw().get<MPTIssue>().getMptID();
1740 auto const shareBalance = [&](Account const& account) {
1741 auto const sle = env.le(keylet::mptoken(shareMptID, account));
1742 return sle ? sle->at(sfMPTAmount) : 0;
1743 };
1744
1745 // alice gives the shares: XRP -> shares (alice) -> asset (bob)
1746 {
1747 env(offer(alice, XRP(1), shares(1)));
1748 env(offer(bob, shares(1), asset(1)));
1749 env.close();
1750
1751 setAliceFrozen(true);
1752
1753 auto const aliceShares = shareBalance(alice);
1754 auto const bobShares = shareBalance(bob);
1755 env(pay(carol, owner, asset(1)),
1756 Sendmax(XRP(1)),
1757 Path(BookSpec{shares.raw()}, BookSpec{asset.raw()}),
1758 Txflags(tfNoRippleDirect),
1759 Ter{tecPATH_PARTIAL});
1760 env.close();
1761 BEAST_EXPECT(shareBalance(alice) == aliceShares);
1762 BEAST_EXPECT(shareBalance(bob) == bobShares);
1763
1764 setAliceFrozen(false);
1765
1766 env(pay(carol, owner, asset(1)),
1767 Sendmax(XRP(1)),
1768 Path(BookSpec{shares.raw()}, BookSpec{asset.raw()}),
1769 Txflags(tfNoRippleDirect));
1770 env.close();
1771 BEAST_EXPECT(shareBalance(alice) == aliceShares - 1);
1772 BEAST_EXPECT(shareBalance(bob) == bobShares + 1);
1773 BEAST_EXPECT(expectOffers(env, alice, 0));
1774 BEAST_EXPECT(expectOffers(env, bob, 0));
1775 }
1776
1777 // alice receives the shares: asset -> shares (bob) -> XRP (alice)
1778 {
1779 env(offer(bob, asset(1), shares(1)));
1780 env(offer(alice, shares(1), XRP(1)));
1781 env.close();
1782
1783 setAliceFrozen(true);
1784
1785 auto const aliceShares = shareBalance(alice);
1786 auto const bobShares = shareBalance(bob);
1787 env(pay(owner, carol, XRP(1)),
1788 Sendmax(asset(1)),
1789 Path(BookSpec{shares.raw()}, ~XRP),
1790 Txflags(tfNoRippleDirect),
1791 Ter{tecPATH_PARTIAL});
1792 env.close();
1793 BEAST_EXPECT(shareBalance(alice) == aliceShares);
1794 BEAST_EXPECT(shareBalance(bob) == bobShares);
1795
1796 setAliceFrozen(false);
1797
1798 env(pay(owner, carol, XRP(1)),
1799 Sendmax(asset(1)),
1800 Path(BookSpec{shares.raw()}, ~XRP),
1801 Txflags(tfNoRippleDirect));
1802 env.close();
1803 BEAST_EXPECT(shareBalance(alice) == aliceShares + 1);
1804 BEAST_EXPECT(shareBalance(bob) == bobShares - 1);
1805 BEAST_EXPECT(expectOffers(env, alice, 0));
1806 BEAST_EXPECT(expectOffers(env, bob, 0));
1807 }
1808 };
1809
1810 {
1811 testcase("MPT individually locked: vault share DEX inherits underlying lock");
1812
1813 Env env{*this, testableAmendments()};
1814 Account const issuer{"issuer"};
1815 Account const owner{"owner"};
1816 Account const alice{"alice"};
1817 Account const bob{"bob"};
1818 Account const carol{"carol"};
1819 env.fund(XRP(10'000), issuer, owner, alice, bob, carol);
1820 env.close();
1821
1822 MPTTester asset{{
1823 .env = env,
1824 .issuer = issuer,
1825 .holders = {owner, alice, bob},
1826 .flags = tfMPTCanTransfer | tfMPTCanTrade | tfMPTCanLock,
1827 }};
1828 env(pay(issuer, owner, asset(1'000)));
1829 env(pay(issuer, alice, asset(2'000)));
1830 env(pay(issuer, bob, asset(2'000)));
1831 env.close();
1832
1833 auto const setAliceFrozen = [&](bool frozen) {
1834 asset.set({.holder = alice, .flags = frozen ? tfMPTLock : tfMPTUnlock});
1835 env.close();
1836 };
1837 testShareDEXEndpointFrozen(env, asset, owner, alice, bob, carol, setAliceFrozen);
1838 testShareDEXMiddleFrozen(env, asset, owner, alice, bob, carol, setAliceFrozen);
1839 }
1840
1841 {
1842 testcase("IOU individually frozen: vault share DEX inherits underlying freeze");
1843
1844 Env env{*this, testableAmendments()};
1845 Account const issuer{"issuer"};
1846 Account const owner{"owner"};
1847 Account const alice{"alice"};
1848 Account const bob{"bob"};
1849 Account const carol{"carol"};
1850 env.fund(XRP(10'000), issuer, owner, alice, bob, carol);
1851 env.close();
1852
1853 // Deliver the IOU from a book to a holder
1854 env(fset(issuer, asfDefaultRipple));
1855 PrettyAsset const asset = issuer["IOU"];
1856 env.trust(asset(10'000), owner, alice, bob);
1857 env(pay(issuer, owner, asset(1'000)));
1858 env(pay(issuer, alice, asset(2'000)));
1859 env(pay(issuer, bob, asset(2'000)));
1860 env.close();
1861
1862 auto const setAliceFrozen = [&](bool frozen) {
1863 env(trust(issuer, asset(0), alice, frozen ? tfSetFreeze : tfClearFreeze));
1864 env.close();
1865 };
1866 testShareDEXEndpointFrozen(env, asset, owner, alice, bob, carol, setAliceFrozen);
1867 testShareDEXMiddleFrozen(env, asset, owner, alice, bob, carol, setAliceFrozen);
1868 }
1869
1870 {
1871 testcase("MPT CanTrade governance: share inherits underlying on DEX and AMM");
1872
1873 Env env{*this, testableAmendments()};
1874 Account const issuer{"issuer"};
1875 Account const owner{"owner"};
1876 Account const alice{"alice"};
1877 Account const bob{"bob"};
1878 env.fund(XRP(100'000), issuer, owner, alice, bob);
1879 env.close();
1880 Vault const vault{env};
1881
1882 MPTTester mptt{env, issuer, kMptInitNoFund};
1883 mptt.create({.flags = tfMPTCanTransfer | tfMPTCanLock});
1884 PrettyAsset const asset = mptt.issuanceID();
1885 mptt.authorize({.account = owner});
1886 mptt.authorize({.account = alice});
1887 mptt.authorize({.account = bob});
1888 env(pay(issuer, alice, asset(10'000)));
1889 env(pay(issuer, bob, asset(10'000)));
1890 env.close();
1891
1892 auto [tx, keylet] = vault.create({.owner = owner, .asset = asset});
1893 env(tx);
1894 env.close();
1895
1896 // Seed shares so we can later place them on trading venues.
1897 env(vault.deposit({.depositor = alice, .id = keylet.key, .amount = asset(5'000)}));
1898 env(vault.deposit({.depositor = bob, .id = keylet.key, .amount = asset(5'000)}));
1899 env.close();
1900
1901 auto const shares = [&] -> PrettyAsset {
1902 auto const sle = env.le(keylet);
1903 BEAST_EXPECT(sle != nullptr);
1904 return MPTIssue(sle->at(sfShareMPTID));
1905 }();
1906
1907 // CanTrade is not set on the underlying, both the asset and
1908 // the vault share are blocked on the DEX.
1909 env(offer(alice, XRP(1), asset(10)), Ter{tecNO_PERMISSION});
1910 env(offer(alice, XRP(1), shares(1)), Ter{tecNO_PERMISSION});
1911 env.close();
1912
1913 // Deposit still works before enabling CanTrade.
1914 env(vault.deposit({.depositor = alice, .id = keylet.key, .amount = asset(100)}));
1915 env.close();
1916
1917 // Peer-to-peer share transfers still work (CanTransfer is set on
1918 // both layers).
1919 env(pay(alice, bob, shares(1)));
1920 env.close();
1921
1922 // Withdraw still works before enabling CanTrade.
1923 env(vault.withdraw({.depositor = alice, .id = keylet.key, .amount = asset(100)}));
1924 env.close();
1925
1926 // Enable CanTrade on the underlying.
1927 mptt.set({.flags = tfMPTSetCanTrade});
1928 env.close();
1929
1930 env(offer(alice, XRP(1), asset(10)));
1931 env(offer(alice, XRP(1), shares(1)));
1932 env.close();
1933
1934 AMM const ammUnderlying(env, alice, XRP(1'000), asset(1'000));
1935 }
1936
1937 {
1938 testcase("MPT OutstandingAmount > MaximumAmount");
1939
1940 Env env{*this, testableAmendments() | featureSingleAssetVault};
1941 Account const alice{"alice"};
1942 Account const issuer{"issuer"};
1943 env.fund(XRP(1'000), alice, issuer);
1944 env.close();
1945 Vault const vault{env};
1946
1947 MPTTester const btc({.env = env, .issuer = issuer, .holders = {alice}, .maxAmt = 100});
1948
1949 auto [tx, k] = vault.create({.owner = issuer, .asset = btc});
1950 env(tx);
1951 env.close();
1952
1953 tx = vault.deposit({.depositor = issuer, .id = k.key, .amount = btc(110)});
1954 // accountHolds is the first check and the issuer has only BTC(100)
1955 // available
1956 env(tx, Ter{tecINSUFFICIENT_FUNDS});
1957 env.close();
1958
1959 // OutstandingAmount == MaximumAmount
1960 env(pay(issuer, alice, btc(100)));
1961 env.close();
1962
1963 tx = vault.deposit({.depositor = issuer, .id = k.key, .amount = btc(100)});
1964 // the issuer has BTC(0) available
1965 env(tx, Ter{tecINSUFFICIENT_FUNDS});
1966 env.close();
1967
1968 tx = vault.deposit({.depositor = alice, .id = k.key, .amount = btc(100)});
1969 // alice transfers BTC(100), OutstandingAmount is 100
1970 env(tx);
1971 env.close();
1972 }
1973 }
1974
1975 void
1977 {
1978 using namespace test::jtx;
1979
1980 struct CaseArgs
1981 {
1982 int initialXRP = 1000;
1983 Number initialIOU = 200;
1984 double transferRate = 1.0;
1985 bool charlieRipple = true;
1986 FeatureBitset features = testableAmendments();
1987 };
1988
1989 auto const testCase = [&, this](
1990 std::function<void(
1991 Env & env,
1992 Account const& owner,
1993 Account const& issuer,
1994 Account const& charlie,
1995 std::function<Account(xrpl::Keylet)> vaultAccount,
1996 Vault& vault,
1997 PrettyAsset const& asset,
1998 std::function<MPTID(xrpl::Keylet)> issuanceId)> test,
1999 CaseArgs args = {}) {
2000 Env env{*this, args.features};
2001 Account const owner{"owner"};
2002 Account const issuer{"issuer"};
2003 Account const charlie{"charlie"};
2004 Vault vault{env};
2005 env.fund(XRP(args.initialXRP), issuer, owner, charlie);
2006 env(fset(issuer, asfAllowTrustLineClawback));
2007 env.close();
2008
2009 PrettyAsset const asset = issuer["IOU"];
2010 env.trust(asset(1000), owner);
2011 env(pay(issuer, owner, asset(args.initialIOU)));
2012 env.close();
2013 if (!args.charlieRipple)
2014 {
2015 env(fset(issuer, 0, asfDefaultRipple));
2016 env.close();
2017 env.trust(asset(1000), charlie);
2018 env.close();
2019 env(pay(issuer, charlie, asset(args.initialIOU)));
2020 env.close();
2021 env(fset(issuer, asfDefaultRipple));
2022 }
2023 else
2024 {
2025 env.trust(asset(1000), charlie);
2026 }
2027 env.close();
2028 env(rate(issuer, args.transferRate));
2029 env.close();
2030
2031 auto const vaultAccount = [&env](xrpl::Keylet keylet) -> Account {
2032 return Account("vault", env.le(keylet)->at(sfAccount));
2033 };
2034 auto const issuanceId = [&env](xrpl::Keylet keylet) -> MPTID {
2035 return env.le(keylet)->at(sfShareMPTID);
2036 };
2037
2038 test(env, owner, issuer, charlie, vaultAccount, vault, asset, issuanceId);
2039 };
2040
2041 testCase([&, this](
2042 Env& env,
2043 Account const& owner,
2044 Account const& issuer,
2045 Account const&,
2046 auto vaultAccount,
2047 Vault& vault,
2048 PrettyAsset const& asset,
2049 auto&&...) {
2050 testcase("IOU cannot use different asset");
2051 PrettyAsset const foo = issuer["FOO"];
2052
2053 auto [tx, keylet] = vault.create({.owner = owner, .asset = asset});
2054 env(tx);
2055 env.close();
2056
2057 {
2058 // Cannot create new trustline to a vault
2059 auto const tx = [&, account = vaultAccount(keylet)] {
2060 json::Value jv;
2061 jv[jss::Account] = issuer.human();
2062 {
2063 auto& ja = jv[jss::LimitAmount] =
2064 foo(0).value().getJson(JsonOptions::Values::None);
2065 ja[jss::issuer] = toBase58(account);
2066 }
2067 jv[jss::TransactionType] = jss::TrustSet;
2068 jv[jss::Flags] = tfSetFreeze;
2069 return jv;
2070 }();
2071 env(tx, Ter{tecNO_PERMISSION});
2072 env.close();
2073 }
2074
2075 {
2076 auto const tx =
2077 vault.deposit({.depositor = issuer, .id = keylet.key, .amount = foo(20)});
2078 env(tx, Ter{tecWRONG_ASSET});
2079 env.close();
2080 }
2081
2082 {
2083 auto const tx =
2084 vault.withdraw({.depositor = issuer, .id = keylet.key, .amount = foo(20)});
2085 env(tx, Ter{tecWRONG_ASSET});
2086 env.close();
2087 }
2088
2089 env(vault.del({.owner = owner, .id = keylet.key}));
2090 env.close();
2091 });
2092
2093 // The issuer charges a 25% transfer fee, so 100 gross delivers 80 net.
2094 auto const feeArgs = CaseArgs{.transferRate = 1.25};
2095
2096 auto const testTransferFeeGate = [&](FeatureBitset const& features) {
2097 testCase(
2098 [this, features](
2099 Env& env,
2100 Account const& owner,
2101 Account const& issuer,
2102 Account const& charlie,
2103 auto,
2104 Vault& vault,
2105 PrettyAsset const& asset,
2106 auto&&...) {
2107 bool const feeCharged = features[fixCleanup3_5_0];
2108 testcase(
2109 feeCharged ? "IOU transfer fee on third-party withdrawal"
2110 : "IOU transfer fee waived pre-fixCleanup3_5_0");
2111
2112 auto const funded = createFundedVault(env, vault, owner, owner, asset(100));
2113 auto const issue = asset.raw().get<Issue>();
2114
2115 // Deposits are fee-free.
2116 BEAST_EXPECT(env.balance(owner, issue) == asset(100));
2117 BEAST_EXPECT(env.balance(funded.account, issue) == asset(100));
2118
2119 env(vault.clawback({
2120 .issuer = issuer,
2121 .id = funded.keylet.key,
2122 .holder = owner,
2123 .amount = asset(50),
2124 }));
2125 env.close();
2126
2127 // Clawbacks are fee-free.
2128 BEAST_EXPECT(env.balance(owner, issue) == asset(100));
2129 BEAST_EXPECT(env.balance(funded.account, issue) == asset(50));
2130
2131 env(vault.withdraw({
2132 .depositor = owner,
2133 .id = funded.keylet.key,
2134 .amount = funded.shares(20'000'000),
2135 }));
2136 env.close();
2137
2138 // Self-withdrawals are fee-free.
2139 BEAST_EXPECT(env.balance(owner, issue) == asset(120));
2140 BEAST_EXPECT(env.balance(funded.account, issue) == asset(30));
2141
2142 auto tx = vault.withdraw({
2143 .depositor = owner,
2144 .id = funded.keylet.key,
2145 .amount = funded.shares(30'000'000),
2146 });
2147 tx[sfDestination] = charlie.human();
2148 env(tx);
2149 env.close();
2150
2151 auto const expected = feeCharged ? asset(24) : asset(30);
2152 BEAST_EXPECT(env.balance(owner, issue) == asset(120));
2153 BEAST_EXPECT(env.balance(charlie, issue) == expected);
2154 BEAST_EXPECT(env.balance(funded.account, issue) == asset(0));
2155
2156 env(vault.del({.owner = owner, .id = funded.keylet.key}));
2157 env.close();
2158 },
2159 CaseArgs{.transferRate = 1.25, .features = features});
2160 };
2161 testTransferFeeGate(testableAmendments() - fixCleanup3_5_0);
2162 testTransferFeeGate(testableAmendments());
2163
2164 testCase(
2165 [this](
2166 Env& env,
2167 Account const& owner,
2168 Account const&,
2169 Account const& charlie,
2170 auto,
2171 Vault& vault,
2172 PrettyAsset const& asset,
2173 auto&&...) {
2174 testcase("IOU transfer fee on fixed-asset third-party withdrawal");
2175
2176 auto const funded = createFundedVault(env, vault, owner, owner, asset(100));
2177 auto const issue = asset.raw().get<Issue>();
2178 auto const shareIssue = funded.shares.raw().get<MPTIssue>();
2179
2180 auto tx = vault.withdraw(
2181 {.depositor = owner, .id = funded.keylet.key, .amount = asset(40)});
2182 tx[sfDestination] = charlie.human();
2183 env(tx);
2184 env.close();
2185
2186 // The destination receives the requested 40; the gross 50 leaves the vault.
2187 BEAST_EXPECT(env.balance(charlie, issue) == asset(40));
2188 BEAST_EXPECT(env.balance(funded.account, issue) == asset(50));
2189 BEAST_EXPECT(env.balance(owner, shareIssue) == funded.shares(50'000'000));
2190 BEAST_EXPECT(env.balance(owner, issue) == asset(100));
2191 },
2192 feeArgs);
2193
2194 testCase(
2195 [this](
2196 Env& env,
2197 Account const& owner,
2198 Account const&,
2199 Account const& charlie,
2200 auto,
2201 Vault& vault,
2202 PrettyAsset const& asset,
2203 auto&&...) {
2204 testcase("IOU transfer fee on fixed-share third-party withdrawal");
2205
2206 auto const funded = createFundedVault(env, vault, owner, owner, asset(100));
2207 auto const issue = asset.raw().get<Issue>();
2208 auto const shareIssue = funded.shares.raw().get<MPTIssue>();
2209
2210 auto tx = vault.withdraw({
2211 .depositor = owner,
2212 .id = funded.keylet.key,
2213 .amount = funded.shares(25'000'000),
2214 });
2215 tx[sfDestination] = charlie.human();
2216 env(tx);
2217 env.close();
2218
2219 // The shares redeem 25 assets; the destination receives 20 net.
2220 BEAST_EXPECT(env.balance(charlie, issue) == asset(20));
2221 BEAST_EXPECT(env.balance(funded.account, issue) == asset(75));
2222 BEAST_EXPECT(env.balance(owner, shareIssue) == funded.shares(75'000'000));
2223 },
2224 feeArgs);
2225
2226 testCase(
2227 [this](
2228 Env& env,
2229 Account const& owner,
2230 Account const& issuer,
2231 Account const&,
2232 auto,
2233 Vault& vault,
2234 PrettyAsset const& asset,
2235 auto&&...) {
2236 testcase("IOU no transfer fee on withdrawal to issuer");
2237
2238 auto const funded = createFundedVault(env, vault, owner, owner, asset(100));
2239 auto const issue = asset.raw().get<Issue>();
2240
2241 auto tx = vault.withdraw(
2242 {.depositor = owner, .id = funded.keylet.key, .amount = asset(10)});
2243 tx[sfDestination] = issuer.human();
2244 env(tx);
2245 env.close();
2246
2247 BEAST_EXPECT(env.balance(funded.account, issue) == asset(90));
2248 BEAST_EXPECT(env.balance(owner, issue) == asset(100));
2249 },
2250 feeArgs);
2251
2252 testCase(
2253 [this](
2254 Env& env,
2255 Account const& owner,
2256 Account const&,
2257 Account const&,
2258 auto,
2259 Vault& vault,
2260 PrettyAsset const& asset,
2261 auto&&...) {
2262 testcase("IOU no transfer fee on self-withdrawal");
2263
2264 auto const funded = createFundedVault(env, vault, owner, owner, asset(100));
2265 auto const issue = asset.raw().get<Issue>();
2266
2267 env(vault.withdraw(
2268 {.depositor = owner, .id = funded.keylet.key, .amount = asset(10)}));
2269 env.close();
2270
2271 BEAST_EXPECT(env.balance(owner, issue) == asset(110));
2272 BEAST_EXPECT(env.balance(funded.account, issue) == asset(90));
2273 },
2274 feeArgs);
2275
2276 testCase(
2277 [this](
2278 Env& env,
2279 Account const& owner,
2280 Account const&,
2281 Account const& charlie,
2282 auto,
2283 Vault& vault,
2284 PrettyAsset const& asset,
2285 auto&&...) {
2286 testcase("IOU transfer fee must fit in the vault position");
2287
2288 auto const funded = createFundedVault(env, vault, owner, owner, asset(100));
2289 auto const issue = asset.raw().get<Issue>();
2290
2291 // Delivering 81 costs 101.25 gross, more than the vault position.
2292 auto tx = vault.withdraw(
2293 {.depositor = owner, .id = funded.keylet.key, .amount = asset(81)});
2294 tx[sfDestination] = charlie.human();
2295 env(tx, Ter{tecINSUFFICIENT_FUNDS});
2296 env.close();
2297
2298 // Delivering 80 costs exactly the 100 held.
2299 tx = vault.withdraw(
2300 {.depositor = owner, .id = funded.keylet.key, .amount = asset(80)});
2301 tx[sfDestination] = charlie.human();
2302 env(tx);
2303 env.close();
2304
2305 BEAST_EXPECT(env.balance(charlie, issue) == asset(80));
2306 BEAST_EXPECT(env.balance(funded.account, issue) == asset(0));
2307
2308 env(vault.del({.owner = owner, .id = funded.keylet.key}));
2309 env.close();
2310 },
2311 feeArgs);
2312
2313 testCase(
2314 [this](
2315 Env& env,
2316 Account const& owner,
2317 Account const& issuer,
2318 Account const& charlie,
2319 auto,
2320 Vault& vault,
2321 PrettyAsset const& asset,
2322 auto&&...) {
2323 testcase("IOU no transfer fee on issuer withdrawal to a third party");
2324
2325 auto const funded = createFundedVault(env, vault, owner, issuer, asset(100));
2326 auto const issue = asset.raw().get<Issue>();
2327
2328 auto tx = vault.withdraw(
2329 {.depositor = issuer, .id = funded.keylet.key, .amount = asset(40)});
2330 tx[sfDestination] = charlie.human();
2331 env(tx);
2332 env.close();
2333
2334 BEAST_EXPECT(env.balance(charlie, issue) == asset(40));
2335 BEAST_EXPECT(env.balance(funded.account, issue) == asset(60));
2336 },
2337 feeArgs);
2338
2339 testCase(
2340 [this](
2341 Env& env,
2342 Account const& owner,
2343 Account const&,
2344 Account const& charlie,
2345 auto,
2346 Vault& vault,
2347 PrettyAsset const& asset,
2348 auto&&...) {
2349 testcase("IOU receiver limit applies to the net amount");
2350
2351 // The limit fits the 40 delivered but not the 50 gross.
2352 env(trust(charlie, asset(40)));
2353 env.close();
2354
2355 auto const funded = createFundedVault(env, vault, owner, owner, asset(100));
2356 auto const issue = asset.raw().get<Issue>();
2357
2358 auto tx = vault.withdraw(
2359 {.depositor = owner, .id = funded.keylet.key, .amount = asset(40)});
2360 tx[sfDestination] = charlie.human();
2361 env(tx);
2362 env.close();
2363
2364 BEAST_EXPECT(env.balance(charlie, issue) == asset(40));
2365 BEAST_EXPECT(env.balance(funded.account, issue) == asset(50));
2366 },
2367 feeArgs);
2368
2369 testCase([&, this](
2370 Env& env,
2371 Account const& owner,
2372 Account const& issuer,
2373 Account const& charlie,
2374 auto,
2375 Vault& vault,
2376 PrettyAsset const& asset,
2377 auto&&...) {
2378 testcase("IOU no trust line to 3rd party");
2379
2380 auto [tx, keylet] = vault.create({.owner = owner, .asset = asset});
2381 env(tx);
2382 env.close();
2383
2384 env(vault.deposit({.depositor = owner, .id = keylet.key, .amount = asset(100)}));
2385 env.close();
2386
2387 Account const erin{"erin"};
2388 env.fund(XRP(1000), erin);
2389 env.close();
2390
2391 // Withdraw to 3rd party without trust line
2392 auto const tx1 = [&](xrpl::Keylet keylet) {
2393 auto tx =
2394 vault.withdraw({.depositor = owner, .id = keylet.key, .amount = asset(10)});
2395 tx[sfDestination] = erin.human();
2396 return tx;
2397 }(keylet);
2398 env(tx1, Ter{tecNO_LINE});
2399 });
2400
2401 testCase([&, this](
2402 Env& env,
2403 Account const& owner,
2404 Account const& issuer,
2405 Account const& charlie,
2406 auto,
2407 Vault& vault,
2408 PrettyAsset const& asset,
2409 auto&&...) {
2410 testcase("IOU no trust line to depositor");
2411
2412 auto [tx, keylet] = vault.create({.owner = owner, .asset = asset});
2413 env(tx);
2414 env.close();
2415
2416 // reset limit, so deposit of all funds will delete the trust line
2417 env.trust(asset(0), owner);
2418 env.close();
2419
2420 env(vault.deposit({.depositor = owner, .id = keylet.key, .amount = asset(200)}));
2421 env.close();
2422
2423 auto const trustline = env.le(keylet::trustLine(owner, asset.raw().get<Issue>()));
2424 BEAST_EXPECT(trustline == nullptr);
2425
2426 // Withdraw without trust line, will succeed
2427 auto const tx1 = [&](xrpl::Keylet keylet) {
2428 return vault.withdraw({.depositor = owner, .id = keylet.key, .amount = asset(10)});
2429 }(keylet);
2430 env(tx1);
2431 });
2432
2433 testCase(
2434 [&, this](
2435 Env& env,
2436 Account const& owner,
2437 Account const& issuer,
2438 Account const& charlie,
2439 auto vaultAccount,
2440 Vault& vault,
2441 PrettyAsset const& asset,
2442 std::function<MPTID(xrpl::Keylet)> issuanceId) {
2443 testcase("IOU non-transferable");
2444
2445 auto [tx, keylet] = vault.create({.owner = owner, .asset = asset});
2446 tx[sfScale] = 0;
2447 env(tx);
2448 env.close();
2449
2450 // Turn on noripple on the pseudo account's trust line.
2451 // Charlie's is already set.
2452 env(trust(issuer, vaultAccount(keylet)["IOU"], tfSetNoRipple));
2453
2454 {
2455 // Charlie cannot deposit
2456 auto const tx = vault.deposit(
2457 {.depositor = charlie, .id = keylet.key, .amount = asset(100)});
2458 env(tx, Ter{terNO_RIPPLE});
2459 env.close();
2460 }
2461
2462 {
2463 PrettyAsset const shares = issuanceId(keylet);
2464 auto const tx1 =
2465 vault.deposit({.depositor = owner, .id = keylet.key, .amount = asset(100)});
2466 env(tx1);
2467 env.close();
2468
2469 // Charlie cannot receive funds
2470 auto tx2 = vault.withdraw(
2471 {.depositor = owner, .id = keylet.key, .amount = shares(100)});
2472 tx2[sfDestination] = charlie.human();
2473 env(tx2, Ter{terNO_RIPPLE});
2474 env.close();
2475
2476 {
2477 // Create MPToken for shares held by Charlie
2479 tx[sfAccount] = charlie.human();
2480 tx[sfMPTokenIssuanceID] =
2481 to_string(shares.raw().get<MPTIssue>().getMptID());
2482 tx[sfTransactionType] = jss::MPTokenAuthorize;
2483 env(tx);
2484 env.close();
2485 }
2486 // Behavioral shift introduced by share inheritance:
2487 // before fixCleanup3_2_0 this share Payment succeeded
2488 // and the underlying IOU's NoRipple restriction surfaced
2489 // only later on Charlie's withdrawal (terNO_RIPPLE).
2490 // Post-amendment, canTransfer reads the share's
2491 // sfReferenceHolding and dispatches to the underlying IOU;
2492 // rippling is disabled between owner and charlie so the
2493 // share payment itself is now blocked. tecPATH_DRY is
2494 // the path-find layer's translation of the underlying
2495 // terNO_RIPPLE under featureMPTokensV2.
2496 env(pay(owner, charlie, shares(100)), Ter{tecPATH_DRY});
2497 env.close();
2498 }
2499
2500 tx = vault.withdraw({.depositor = owner, .id = keylet.key, .amount = asset(100)});
2501 env(tx);
2502 env.close();
2503
2504 // Delete vault with zero balance
2505 env(vault.del({.owner = owner, .id = keylet.key}));
2506 },
2507 {.charlieRipple = false});
2508
2509 testCase(
2510 [&, this](
2511 Env& env,
2512 Account const& owner,
2513 Account const& issuer,
2514 Account const& charlie,
2515 auto const& vaultAccount,
2516 Vault& vault,
2517 PrettyAsset const& asset,
2518 auto&&...) {
2519 testcase("IOU calculation rounding");
2520
2521 auto [tx, keylet] = vault.create({.owner = owner, .asset = asset});
2522 tx[sfScale] = 1;
2523 env(tx);
2524 env.close();
2525
2526 auto const startingOwnerBalance = env.balance(owner, asset);
2527 BEAST_EXPECT((startingOwnerBalance.value() == STAmount{asset, 11875, -2}));
2528
2529 // This operation (first deposit 100, then 3.75 x 5) is known to
2530 // have triggered calculation rounding errors in Number
2531 // (addition and division), causing the last deposit to be
2532 // blocked by Vault invariants.
2533 env(vault.deposit({.depositor = owner, .id = keylet.key, .amount = asset(100)}));
2534
2535 auto const tx1 = vault.deposit(
2536 {.depositor = owner, .id = keylet.key, .amount = asset(Number(375, -2))});
2537 for (auto i = 0; i < 5; ++i)
2538 {
2539 env(tx1);
2540 }
2541 env.close();
2542
2543 {
2544 STAmount const xfer{asset, 1185, -1};
2545 BEAST_EXPECT(env.balance(owner, asset) == startingOwnerBalance.value() - xfer);
2546 BEAST_EXPECT(env.balance(vaultAccount(keylet), asset) == xfer);
2547
2548 auto const vault = env.le(keylet);
2549 BEAST_EXPECT(vault->at(sfAssetsAvailable) == xfer);
2550 BEAST_EXPECT(vault->at(sfAssetsTotal) == xfer);
2551 }
2552
2553 // Total vault balance should be 118.5 IOU. Withdraw and delete
2554 // the vault to verify this exact amount was deposited and the
2555 // owner has matching shares
2556 env(vault.withdraw({
2557 .depositor = owner,
2558 .id = keylet.key,
2559 .amount = asset(Number(1000 + (37 * 5), -1)),
2560 }));
2561
2562 {
2563 BEAST_EXPECT(env.balance(owner, asset) == startingOwnerBalance.value());
2564 BEAST_EXPECT(env.balance(vaultAccount(keylet), asset) == beast::kZero);
2565 auto const vault = env.le(keylet);
2566 BEAST_EXPECT(vault->at(sfAssetsAvailable) == beast::kZero);
2567 BEAST_EXPECT(vault->at(sfAssetsTotal) == beast::kZero);
2568 }
2569
2570 env(vault.del({.owner = owner, .id = keylet.key}));
2571 env.close();
2572 },
2573 {.initialIOU = Number(11875, -2)});
2574
2575 auto const [acctReserve, incReserve] = [this] -> std::pair<int, int> {
2576 Env const env{*this, testableAmendments()};
2577 return {
2578 env.current()->fees().accountReserve(0, 1).drops() / kDropsPerXrp.drops(),
2579 env.current()->fees().increment.drops() / kDropsPerXrp.drops()};
2580 }();
2581
2582 testCase(
2583 [&, this](
2584 Env& env,
2585 Account const& owner,
2586 Account const& issuer,
2587 Account const& charlie,
2588 auto,
2589 Vault& vault,
2590 PrettyAsset const& asset,
2591 auto&&...) {
2592 testcase("IOU no trust line to depositor no reserve");
2593 auto [tx, keylet] = vault.create({.owner = owner, .asset = asset});
2594 env(tx);
2595 env.close();
2596
2597 // reset limit, so deposit of all funds will delete the trust
2598 // line
2599 env.trust(asset(0), owner);
2600 env.close();
2601
2602 env(vault.deposit({.depositor = owner, .id = keylet.key, .amount = asset(200)}));
2603 env.close();
2604
2605 auto const trustline = env.le(keylet::trustLine(owner, asset.raw().get<Issue>()));
2606 BEAST_EXPECT(trustline == nullptr);
2607
2608 env(ticket::create(owner, 1));
2609 env.close();
2610
2611 // Fail because not enough reserve to create trust line
2612 tx = vault.withdraw({.depositor = owner, .id = keylet.key, .amount = asset(10)});
2613 env(tx, Ter{tecNO_LINE_INSUF_RESERVE});
2614 env.close();
2615
2616 env(pay(charlie, owner, XRP(incReserve)));
2617 env.close();
2618
2619 // Withdraw can now create trust line, will succeed
2620 env(tx);
2621 env.close();
2622 },
2623 CaseArgs{.initialXRP = acctReserve + (incReserve * 4) + 1});
2624
2625 testCase(
2626 [&, this](
2627 Env& env,
2628 Account const& owner,
2629 Account const& issuer,
2630 Account const& charlie,
2631 auto,
2632 Vault& vault,
2633 PrettyAsset const& asset,
2634 auto&&...) {
2635 testcase("IOU no reserve for share MPToken");
2636 auto [tx, keylet] = vault.create({.owner = owner, .asset = asset});
2637 env(tx);
2638 env.close();
2639
2640 env(pay(owner, charlie, asset(100)));
2641 env.close();
2642
2643 env(ticket::create(charlie, 3));
2644 env.close();
2645
2646 // Fail because not enough reserve to create MPToken for shares
2647 tx = vault.deposit({.depositor = charlie, .id = keylet.key, .amount = asset(100)});
2648 env(tx, Ter{tecINSUFFICIENT_RESERVE});
2649 env.close();
2650
2651 env(pay(issuer, charlie, XRP(incReserve)));
2652 env.close();
2653
2654 // Deposit can now create MPToken, will succeed
2655 env(tx);
2656 env.close();
2657 },
2658 CaseArgs{.initialXRP = acctReserve + (incReserve * 4) + 1});
2659 }
2660
2661public:
2662 void
2663 run() override
2664 {
2665 testSequences();
2666 testWithMPT();
2667 testWithIOU();
2668 }
2669};
2670
2671BEAST_DEFINE_TESTSUITE_PRIO(VaultLifecycle, app, xrpl, 1);
2672
2673} // namespace xrpl
TestcaseT testcase
Memberspace for declaring test cases.
Definition suite.h:155
Represents a JSON value.
Definition json_value.h:121
constexpr TIss const & get() const
Integers of any length that is a multiple of 32-bits.
Definition base_uint.h:82
A currency issued by an account.
Definition Issue.h:18
constexpr MPTID const & getMptID() const
Definition MPTIssue.h:43
Number is a floating point type that can represent a wide range of values.
Definition Number.h:351
Asset const & asset() const
Definition STAmount.h:496
static FundedVault createFundedVault(test::jtx::Env &env, test::jtx::Vault &vault, test::jtx::Account const &owner, test::jtx::Account const &depositor, STAmount const &amount)
Creates a vault owned by owner and deposits amount into it from depositor.
void run() override
Runs the suite.
Shared base for the Vault*_test family under src/test/app/vault/.
test::jtx::PrettyAsset PrettyAsset
Immutable cryptographic account descriptor.
Definition jtx/Account.h:21
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 memoize(Account const &account)
Associate AccountID with account.
Definition Env.cpp:174
constexpr Zero kZero
Definition Zero.h:30
@ Object
object value (collection of name/value pairs).
Definition json_value.h:33
Keylet computation functions.
Definition Indexes.h:39
Keylet const & skip() noexcept
The index of the "short" skip list.
Definition Indexes.cpp:245
Keylet mptoken(MPTID const &issuanceID, AccountID const &holder) noexcept
Definition Indexes.cpp:547
Keylet mptokenIssuance(MPTID const &issuanceID) noexcept
Definition Indexes.cpp:541
Keylet trustLine(AccountID const &id0, AccountID const &id1, Currency const &currency) noexcept
The index of a trust line for a given currency.
Definition Indexes.cpp:287
Use hash_* containers for keys that do not need a cryptographically secure hashing algorithm.
Definition algorithm.h:5
@ terNO_RIPPLE
Definition TER.h:226
Issue const & xrpIssue()
Returns an asset specifier that represents XRP.
Definition Issue.h:108
constexpr XRPAmount kDropsPerXrp
Number of drops per 1 XRP.
Definition XRPAmount.h:247
int scale(Number const &number, Asset const &asset)
Get the scale of a Number for a given asset.
Definition STAmount.h:819
std::string toBase58(AccountID const &v)
Convert AccountID to base58 checked string.
Definition AccountID.cpp:95
std::string to_string(BaseUInt< Bits, Tag > const &a)
Definition base_uint.h:658
BEAST_DEFINE_TESTSUITE_PRIO(NFTokenBaseUtil, app, xrpl, 2)
LedgerSpecificFlags
Rate transferRate(ReadView const &view, AccountID const &issuer)
Returns IOU issuer transfer fee as Rate.
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
@ temMALFORMED
Definition TER.h:75
bool isTesSuccess(TER x) noexcept
Definition TER.h:686
TERSubset< CanCvtToTER > TER
Definition TER.h:657
TER requireAuth(ReadView const &view, MPTIssue const &mptIssue, AccountID const &account, AuthType authType=AuthType::Legacy, std::uint8_t depth=0)
Check if the account lacks required authorization for MPT.
@ tecWRONG_ASSET
Definition TER.h:371
@ tecLOCKED
Definition TER.h:369
@ tecNO_LINE_INSUF_RESERVE
Definition TER.h:303
@ tecPATH_PARTIAL
Definition TER.h:293
@ tecNO_ENTRY
Definition TER.h:317
@ tecPATH_DRY
Definition TER.h:305
@ tecOBJECT_NOT_FOUND
Definition TER.h:337
@ tecNO_AUTH
Definition TER.h:311
@ tecINVARIANT_FAILED
Definition TER.h:324
@ tecINSUFFICIENT_FUNDS
Definition TER.h:336
@ tecNO_LINE
Definition TER.h:312
@ tecPRECISION_LOSS
Definition TER.h:374
@ tecINSUFFICIENT_RESERVE
Definition TER.h:318
@ tecLIMIT_EXCEEDED
Definition TER.h:372
@ tecNO_PERMISSION
Definition TER.h:316
@ tecDST_TAG_NEEDED
Definition TER.h:320
@ tecHAS_OBLIGATIONS
Definition TER.h:328
@ tesSUCCESS
Definition TER.h:253
A pair of SHAMap key and LedgerEntryType.
Definition Keylet.h:20
UInt256 key
Definition Keylet.h:21