xrpld
Loading...
Searching...
No Matches
VaultValidation_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/credentials.h>
9#include <test/jtx/fee.h>
10#include <test/jtx/flags.h>
11#include <test/jtx/mpt.h>
12#include <test/jtx/pay.h>
13#include <test/jtx/permissioned_domains.h>
14#include <test/jtx/ter.h>
15#include <test/jtx/trust.h>
16#include <test/jtx/vault.h>
17
18#include <xrpl/basics/Number.h>
19#include <xrpl/basics/base_uint.h>
20#include <xrpl/basics/strHex.h>
21#include <xrpl/beast/unit_test/suite.h>
22#include <xrpl/beast/utility/Zero.h>
23#include <xrpl/json/json_forwards.h>
24#include <xrpl/json/json_value.h>
25#include <xrpl/protocol/Asset.h>
26#include <xrpl/protocol/Feature.h>
27#include <xrpl/protocol/Indexes.h>
28#include <xrpl/protocol/Issue.h>
29#include <xrpl/protocol/Keylet.h>
30#include <xrpl/protocol/Protocol.h>
31#include <xrpl/protocol/SField.h>
32#include <xrpl/protocol/STAmount.h>
33#include <xrpl/protocol/STNumber.h> // IWYU pragma: keep
34#include <xrpl/protocol/SeqProxy.h>
35#include <xrpl/protocol/TER.h>
36#include <xrpl/protocol/TxFlags.h>
37#include <xrpl/protocol/jss.h>
38
39#include <cstdint>
40#include <functional>
41#include <string>
42#include <tuple>
43#include <utility>
44
45namespace xrpl {
46
48{
49private:
50 void
52 {
53 using namespace test::jtx;
54
55 struct CaseArgs
56 {
57 FeatureBitset features = testableAmendments();
58 };
59
60 auto const testCase = [&, this](
61 std::function<void(
62 Env & env,
63 Account const& issuer,
64 Account const& owner,
65 Asset const& asset,
66 Vault& vault)> test,
67 CaseArgs args = {}) {
68 Env env{*this, args.features};
69 Account const issuer{"issuer"};
70 Account const owner{"owner"};
71 Vault vault{env};
72 env.fund(XRP(1000), issuer, owner);
73 env.close();
74
75 env(fset(issuer, asfAllowTrustLineClawback));
76 env(fset(issuer, asfRequireAuth));
77 env.close();
78
79 PrettyAsset const asset = issuer["IOU"];
80 env(trust(owner, asset(1000)));
81 env(trust(issuer, asset(0), owner, tfSetfAuth));
82 env(pay(issuer, owner, asset(1000)));
83 env.close();
84
85 test(env, issuer, owner, asset, vault);
86 };
87
88 auto const testDisabled = [&](TER resultAfterCreate = temDISABLED) {
89 return [&, resultAfterCreate](
90 Env& env,
91 Account const& issuer,
92 Account const& owner,
93 Asset const& asset,
94 Vault& vault) {
95 testcase("disabled single asset vault");
96
97 auto [tx, keylet] = vault.create({.owner = owner, .asset = asset});
98 env(tx, Ter{temDISABLED});
99
100 {
101 auto const tx = vault.set({.owner = owner, .id = keylet.key});
102 env(tx, kData("test"), Ter{resultAfterCreate});
103 }
104
105 {
106 auto const tx =
107 vault.deposit({.depositor = owner, .id = keylet.key, .amount = asset(10)});
108 env(tx, Ter{resultAfterCreate});
109 }
110
111 {
112 auto const tx =
113 vault.withdraw({.depositor = owner, .id = keylet.key, .amount = asset(10)});
114 env(tx, Ter{resultAfterCreate});
115 }
116
117 {
118 auto const tx = vault.clawback(
119 {.issuer = issuer, .id = keylet.key, .holder = owner, .amount = asset(10)});
120 env(tx, Ter{resultAfterCreate});
121 }
122
123 {
124 auto const tx = vault.del({.owner = owner, .id = keylet.key});
125 env(tx, Ter{resultAfterCreate});
126 }
127 };
128 };
129
130 testCase(testDisabled(), {.features = testableAmendments() - featureSingleAssetVault});
131
132 testCase(testDisabled(tecNO_ENTRY), {.features = testableAmendments() - featureMPTokensV1});
133
134 testCase(
135 [&](Env& env,
136 Account const& issuer,
137 Account const& owner,
138 Asset const& asset,
139 Vault& vault) {
140 testcase("disabled permissioned domains");
141
142 auto [tx, keylet] = vault.create({.owner = owner, .asset = asset});
143 env(tx);
144
145 tx[sfFlags] = tx[sfFlags].asUInt() | tfVaultPrivate;
146 tx[sfDomainID] = to_string(BaseUInt<256>(42ul));
147 env(tx, Ter{temDISABLED});
148
149 {
150 auto tx = vault.set({.owner = owner, .id = keylet.key});
151 env(tx, kData("Test"));
152
153 tx[sfDomainID] = to_string(BaseUInt<256>(13ul));
154 env(tx, Ter{temDISABLED});
155 }
156 },
157 {.features = testableAmendments() - featurePermissionedDomains});
158
159 testCase([&](Env& env,
160 Account const& issuer,
161 Account const& owner,
162 Asset const& asset,
163 Vault& vault) {
164 testcase("invalid flags");
165
166 auto [tx, keylet] = vault.create({.owner = owner, .asset = asset});
167 tx[sfFlags] = tfClearDeepFreeze;
168 env(tx, Ter{temINVALID_FLAG});
169
170 {
171 auto tx = vault.set({.owner = owner, .id = keylet.key});
172 tx[sfFlags] = tfClearDeepFreeze;
173 env(tx, Ter{temINVALID_FLAG});
174 }
175
176 {
177 auto tx =
178 vault.deposit({.depositor = owner, .id = keylet.key, .amount = asset(10)});
179 tx[sfFlags] = tfClearDeepFreeze;
180 env(tx, Ter{temINVALID_FLAG});
181 }
182
183 {
184 auto tx =
185 vault.withdraw({.depositor = owner, .id = keylet.key, .amount = asset(10)});
186 tx[sfFlags] = tfClearDeepFreeze;
187 env(tx, Ter{temINVALID_FLAG});
188 }
189
190 {
191 auto tx = vault.clawback(
192 {.issuer = issuer, .id = keylet.key, .holder = owner, .amount = asset(10)});
193 tx[sfFlags] = tfClearDeepFreeze;
194 env(tx, Ter{temINVALID_FLAG});
195 }
196
197 {
198 auto tx = vault.del({.owner = owner, .id = keylet.key});
199 tx[sfFlags] = tfClearDeepFreeze;
200 env(tx, Ter{temINVALID_FLAG});
201 }
202 });
203
204 testCase([&](Env& env,
205 Account const& issuer,
206 Account const& owner,
207 Asset const& asset,
208 Vault& vault) {
209 testcase("invalid fee");
210
211 auto [tx, keylet] = vault.create({.owner = owner, .asset = asset});
212 tx[jss::Fee] = "-1";
213 env(tx, Ter{temBAD_FEE});
214
215 {
216 auto tx = vault.set({.owner = owner, .id = keylet.key});
217 tx[jss::Fee] = "-1";
218 env(tx, Ter{temBAD_FEE});
219 }
220
221 {
222 auto tx =
223 vault.deposit({.depositor = owner, .id = keylet.key, .amount = asset(10)});
224 tx[jss::Fee] = "-1";
225 env(tx, Ter{temBAD_FEE});
226 }
227
228 {
229 auto tx =
230 vault.withdraw({.depositor = owner, .id = keylet.key, .amount = asset(10)});
231 tx[jss::Fee] = "-1";
232 env(tx, Ter{temBAD_FEE});
233 }
234
235 {
236 auto tx = vault.clawback(
237 {.issuer = issuer, .id = keylet.key, .holder = owner, .amount = asset(10)});
238 tx[jss::Fee] = "-1";
239 env(tx, Ter{temBAD_FEE});
240 }
241
242 {
243 auto tx = vault.del({.owner = owner, .id = keylet.key});
244 tx[jss::Fee] = "-1";
245 env(tx, Ter{temBAD_FEE});
246 }
247 });
248
249 testCase(
250 [&](Env& env, Account const&, Account const& owner, Asset const&, Vault& vault) {
251 testcase("disabled permissioned domain");
252
253 auto [tx, keylet] = vault.create({.owner = owner, .asset = xrpIssue()});
254 tx[sfDomainID] = to_string(BaseUInt<256>(42ul));
255 env(tx, Ter{temDISABLED});
256
257 {
258 auto tx = vault.set({.owner = owner, .id = keylet.key});
259 tx[sfDomainID] = to_string(BaseUInt<256>(42ul));
260 env(tx, Ter{temDISABLED});
261 }
262
263 {
264 auto tx = vault.set({.owner = owner, .id = keylet.key});
265 tx[sfDomainID] = "0";
266 env(tx, Ter{temDISABLED});
267 }
268 },
269 {.features = testableAmendments() - featurePermissionedDomains});
270
271 testCase([&](Env& env,
272 Account const& issuer,
273 Account const& owner,
274 Asset const& asset,
275 Vault& vault) {
276 testcase("use zero vault");
277
278 auto [tx, keylet] = vault.create({.owner = owner, .asset = xrpIssue()});
279
280 {
281 auto const tx = vault.set({
282 .owner = owner,
283 .id = beast::kZero,
284 });
285 env(tx, Ter{temMALFORMED});
286 }
287
288 {
289 auto const tx =
290 vault.deposit({.depositor = owner, .id = beast::kZero, .amount = asset(10)});
291 env(tx, Ter(temMALFORMED));
292 }
293
294 {
295 auto const tx =
296 vault.withdraw({.depositor = owner, .id = beast::kZero, .amount = asset(10)});
297 env(tx, Ter{temMALFORMED});
298 }
299
300 {
301 auto const tx = vault.clawback(
302 {.issuer = issuer, .id = beast::kZero, .holder = owner, .amount = asset(10)});
303 env(tx, Ter{temMALFORMED});
304 }
305
306 {
307 auto const tx = vault.del({
308 .owner = owner,
309 .id = beast::kZero,
310 });
311 env(tx, Ter{temMALFORMED});
312 }
313 });
314
315 testCase(
316 [&](Env& env, Account const&, Account const& owner, Asset const& asset, Vault& vault) {
317 testcase("withdraw to bad destination");
318
319 auto [tx, keylet] = vault.create({.owner = owner, .asset = asset});
320
321 {
322 auto tx =
323 vault.withdraw({.depositor = owner, .id = keylet.key, .amount = asset(10)});
324 tx[jss::Destination] = "0";
325 env(tx, Ter{temMALFORMED});
326 }
327 });
328
329 testCase(
330 [&](Env& env, Account const&, Account const& owner, Asset const& asset, Vault& vault) {
331 testcase("create with Scale");
332
333 {
334 auto [tx, keylet] = vault.create({.owner = owner, .asset = asset});
335 tx[sfScale] = 255;
336 env(tx, Ter(temMALFORMED));
337 }
338
339 {
340 auto [tx, keylet] = vault.create({.owner = owner, .asset = asset});
341 tx[sfScale] = 19;
342 env(tx, Ter(temMALFORMED));
343 }
344
345 // accepted range from 0 to 18
346 {
347 auto [tx, keylet] = vault.create({.owner = owner, .asset = asset});
348 tx[sfScale] = 18;
349 env(tx);
350 env.close();
351 auto const sleVault = env.le(keylet);
352 BEAST_EXPECT(sleVault);
353 BEAST_EXPECT((*sleVault)[sfScale] == 18);
354 }
355
356 {
357 auto [tx, keylet] = vault.create({.owner = owner, .asset = asset});
358 tx[sfScale] = 0;
359 env(tx);
360 env.close();
361 auto const sleVault = env.le(keylet);
362 BEAST_EXPECT(sleVault);
363 BEAST_EXPECT((*sleVault)[sfScale] == 0);
364 }
365
366 {
367 auto [tx, keylet] = vault.create({.owner = owner, .asset = asset});
368 env(tx);
369 env.close();
370 auto const sleVault = env.le(keylet);
371 BEAST_EXPECT(sleVault);
372 BEAST_EXPECT((*sleVault)[sfScale] == 6);
373 }
374 },
375 {.features = testableAmendments() - featureLendingProtocolV1_2});
376
377 testCase(
378 [&](Env& env, Account const&, Account const& owner, Asset const& asset, Vault& vault) {
379 testcase("create or set invalid data");
380
381 auto [tx1, keylet] = vault.create({.owner = owner, .asset = asset});
382
383 {
384 auto tx = tx1;
385 tx[sfData] = "";
386 env(tx, Ter(temMALFORMED));
387 }
388
389 {
390 auto tx = tx1;
391 // A hexadecimal string of 257 bytes.
392 tx[sfData] = std::string(514, 'A');
393 env(tx, Ter(temMALFORMED));
394 }
395
396 {
397 auto tx = vault.set({.owner = owner, .id = keylet.key});
398 tx[sfData] = "";
399 env(tx, Ter{temMALFORMED});
400 }
401
402 {
403 auto tx = vault.set({.owner = owner, .id = keylet.key});
404 // A hexadecimal string of 257 bytes.
405 tx[sfData] = std::string(514, 'A');
406 env(tx, Ter{temMALFORMED});
407 }
408 });
409
410 testCase(
411 [&](Env& env, Account const&, Account const& owner, Asset const& asset, Vault& vault) {
412 testcase("set nothing updated");
413
414 auto [tx, keylet] = vault.create({.owner = owner, .asset = asset});
415
416 {
417 auto const tx = vault.set({.owner = owner, .id = keylet.key});
418 env(tx, Ter{temMALFORMED});
419 }
420 });
421
422 testCase(
423 [&](Env& env, Account const&, Account const& owner, Asset const& asset, Vault& vault) {
424 testcase("create with invalid metadata");
425
426 auto [tx1, keylet] = vault.create({.owner = owner, .asset = asset});
427
428 {
429 auto tx = tx1;
430 tx[sfMPTokenMetadata] = "";
431 env(tx, Ter(temMALFORMED));
432 }
433
434 {
435 auto tx = tx1;
436 // This metadata is for the share token.
437 // A hexadecimal string of 1025 bytes.
438 tx[sfMPTokenMetadata] = std::string(2050, 'B');
439 env(tx, Ter(temMALFORMED));
440 }
441 });
442
443 testCase(
444 [&](Env& env, Account const&, Account const& owner, Asset const& asset, Vault& vault) {
445 testcase("set negative maximum");
446
447 auto [tx, keylet] = vault.create({.owner = owner, .asset = asset});
448
449 {
450 auto tx = vault.set({.owner = owner, .id = keylet.key});
451 tx[sfAssetsMaximum] = kNegativeAmount(asset).number();
452 env(tx, Ter{temMALFORMED});
453 }
454 });
455
456 testCase(
457 [&](Env& env, Account const&, Account const& owner, Asset const& asset, Vault& vault) {
458 testcase("invalid deposit amount");
459
460 auto [tx, keylet] = vault.create({.owner = owner, .asset = asset});
461
462 {
463 auto const tx = vault.deposit(
464 {.depositor = owner, .id = keylet.key, .amount = kNegativeAmount(asset)});
465 env(tx, Ter(temBAD_AMOUNT));
466 }
467
468 {
469 auto const tx =
470 vault.deposit({.depositor = owner, .id = keylet.key, .amount = asset(0)});
471 env(tx, Ter(temBAD_AMOUNT));
472 }
473 });
474
475 testCase(
476 [&](Env& env, Account const&, Account const& owner, Asset const& asset, Vault& vault) {
477 testcase("invalid set immutable flag");
478
479 auto [tx, keylet] = vault.create({.owner = owner, .asset = asset});
480
481 {
482 auto tx = vault.set({.owner = owner, .id = keylet.key});
483 tx[sfFlags] = tfVaultPrivate;
484 env(tx, Ter(temINVALID_FLAG));
485 }
486 });
487
488 testCase(
489 [&](Env& env, Account const&, Account const& owner, Asset const& asset, Vault& vault) {
490 testcase("invalid withdraw amount");
491
492 auto [tx, keylet] = vault.create({.owner = owner, .asset = asset});
493
494 {
495 auto const tx = vault.withdraw(
496 {.depositor = owner, .id = keylet.key, .amount = kNegativeAmount(asset)});
497 env(tx, Ter(temBAD_AMOUNT));
498 }
499
500 {
501 auto const tx =
502 vault.withdraw({.depositor = owner, .id = keylet.key, .amount = asset(0)});
503 env(tx, Ter(temBAD_AMOUNT));
504 }
505 });
506
507 testCase([&](Env& env,
508 Account const& issuer,
509 Account const& owner,
510 Asset const& asset,
511 Vault& vault) {
512 testcase("invalid clawback");
513
514 auto [tx, keylet] = vault.create({.owner = owner, .asset = asset});
515
516 // Preclaim only checks for native assets.
517 if (asset.native())
518 {
519 auto const tx = vault.clawback(
520 {.issuer = issuer, .id = keylet.key, .holder = owner, .amount = asset(50)});
521 env(tx, Ter(temMALFORMED));
522 }
523
524 {
525 auto const tx = vault.clawback({
526 .issuer = issuer,
527 .id = keylet.key,
528 .holder = owner,
529 .amount = kNegativeAmount(asset),
530 });
531 env(tx, Ter(temBAD_AMOUNT));
532 }
533 });
534
535 testCase(
536 [&](Env& env, Account const&, Account const& owner, Asset const& asset, Vault& vault) {
537 testcase("invalid create");
538
539 auto [tx1, keylet] = vault.create({.owner = owner, .asset = asset});
540
541 {
542 auto tx = tx1;
543 tx[sfWithdrawalPolicy] = 0;
544 env(tx, Ter(temMALFORMED));
545 }
546
547 {
548 auto tx = tx1;
549 tx[sfDomainID] = to_string(BaseUInt<256>(42ul));
550 env(tx, Ter{temMALFORMED});
551 }
552
553 {
554 auto tx = tx1;
555 tx[sfAssetsMaximum] = kNegativeAmount(asset).number();
556 env(tx, Ter{temMALFORMED});
557 }
558
559 {
560 auto tx = tx1;
561 tx[sfFlags] = tfVaultPrivate;
562 tx[sfDomainID] = "0";
563 env(tx, Ter{temMALFORMED});
564 }
565 });
566 }
567
568 // Test for non-asset specific behaviors.
569 void
571 {
572 using namespace test::jtx;
573
574 auto const testCase = [this](
575 std::function<void(
576 Env & env,
577 Account const& issuer,
578 Account const& owner,
579 Account const& depositor,
580 Asset const& asset,
581 Vault& vault)> test) {
582 Env env{*this, testableAmendments()};
583 Account const issuer{"issuer"};
584 Account const owner{"owner"};
585 Account const depositor{"depositor"};
586
587 env.fund(XRP(1000), issuer, owner, depositor);
588 env.close();
589 Vault vault{env};
590 Asset const asset = xrpIssue();
591
592 test(env, issuer, owner, depositor, asset, vault);
593 };
594
595 testCase([this](
596 Env& env,
597 Account const& issuer,
598 Account const& owner,
599 Account const& depositor,
600 PrettyAsset const& asset,
601 Vault& vault) {
602 testcase("nothing to set");
603 auto tx = vault.set({.owner = owner, .id = keylet::skip().key});
604 tx[sfAssetsMaximum] = asset(0).number();
605 env(tx, Ter(tecNO_ENTRY));
606 });
607
608 testCase([this](
609 Env& env,
610 Account const& issuer,
611 Account const& owner,
612 Account const& depositor,
613 PrettyAsset const& asset,
614 Vault& vault) {
615 testcase("nothing to deposit to");
616 auto const tx = vault.deposit(
617 {.depositor = depositor, .id = keylet::skip().key, .amount = asset(10)});
618 env(tx, Ter(tecNO_ENTRY));
619 });
620
621 testCase([this](
622 Env& env,
623 Account const& issuer,
624 Account const& owner,
625 Account const& depositor,
626 PrettyAsset const& asset,
627 Vault& vault) {
628 testcase("nothing to withdraw from");
629 auto const tx = vault.withdraw(
630 {.depositor = depositor, .id = keylet::skip().key, .amount = asset(10)});
631 env(tx, Ter(tecNO_ENTRY));
632 });
633
634 testCase([this](
635 Env& env,
636 Account const& issuer,
637 Account const& owner,
638 Account const& depositor,
639 Asset const& asset,
640 Vault& vault) {
641 testcase("nothing to delete");
642 auto const tx = vault.del({.owner = owner, .id = keylet::skip().key});
643 env(tx, Ter(tecNO_ENTRY));
644 });
645
646 testCase([this](
647 Env& env,
648 Account const& issuer,
649 Account const& owner,
650 Account const& depositor,
651 Asset const& asset,
652 Vault& vault) {
653 auto [tx, keylet] = vault.create({.owner = owner, .asset = asset});
654 testcase("transaction is good");
655 env(tx);
656 });
657
658 testCase([this](
659 Env& env,
660 Account const& issuer,
661 Account const& owner,
662 Account const& depositor,
663 Asset const& asset,
664 Vault& vault) {
665 auto [tx, keylet] = vault.create({.owner = owner, .asset = asset});
666 tx[sfWithdrawalPolicy] = 1;
667 testcase("explicitly select withdrawal policy");
668 env(tx);
669 });
670
671 testCase([this](
672 Env& env,
673 Account const& issuer,
674 Account const& owner,
675 Account const& depositor,
676 Asset const& asset,
677 Vault& vault) {
678 auto [tx, keylet] = vault.create({.owner = owner, .asset = asset});
679 testcase("insufficient fee");
680 env(tx, Fee(env.current()->fees().base - 1), Ter(telINSUF_FEE_P));
681 });
682
683 testCase([this](
684 Env& env,
685 Account const& issuer,
686 Account const& owner,
687 Account const& depositor,
688 Asset const& asset,
689 Vault& vault) {
690 auto [tx, keylet] = vault.create({.owner = owner, .asset = asset});
691 testcase("insufficient reserve");
692 // It is possible to construct a complicated mathematical
693 // expression for this amount, but it is sadly not easy.
694 env(pay(owner, issuer, XRP(775)));
695 env.close();
696 env(tx, Ter(tecINSUFFICIENT_RESERVE));
697 });
698
699 testCase([this](
700 Env& env,
701 Account const& issuer,
702 Account const& owner,
703 Account const& depositor,
704 Asset const& asset,
705 Vault& vault) {
706 auto [tx, keylet] = vault.create({.owner = owner, .asset = asset});
707 tx[sfFlags] = tfVaultPrivate;
708 tx[sfDomainID] = to_string(BaseUInt<256>(42ul));
709 testcase("non-existing domain");
710 env(tx, Ter{tecOBJECT_NOT_FOUND});
711 });
712
713 testCase([this](
714 Env& env,
715 Account const& issuer,
716 Account const& owner,
717 Account const& depositor,
718 Asset const& asset,
719 Vault& vault) {
720 testcase("cannot set Scale=0");
721 auto [tx, keylet] = vault.create({.owner = owner, .asset = asset});
722 tx[sfScale] = 0;
723 env(tx, Ter{temMALFORMED});
724 });
725
726 testCase([this](
727 Env& env,
728 Account const& issuer,
729 Account const& owner,
730 Account const& depositor,
731 Asset const& asset,
732 Vault& vault) {
733 testcase("cannot set Scale=1");
734 auto [tx, keylet] = vault.create({.owner = owner, .asset = asset});
735 tx[sfScale] = 1;
736 env(tx, Ter{temMALFORMED});
737 });
738 }
739
740 void
742 {
743 using namespace test::jtx;
744 {
745 {
746 testcase("IOU fail because MPT is disabled");
747 Env env{*this, (testableAmendments() - featureMPTokensV1)};
748 Account const issuer{"issuer"};
749 Account const owner{"owner"};
750 env.fund(XRP(1000), issuer, owner);
751 env.close();
752
753 Vault const vault{env};
754 Asset const asset = issuer["IOU"].asset();
755 auto [tx, keylet] = vault.create({.owner = owner, .asset = asset});
756
757 env(tx, Ter(temDISABLED));
758 env.close();
759 }
760
761 {
762 testcase("IOU fail create frozen");
763 Env env{*this, testableAmendments()};
764 Account const issuer{"issuer"};
765 Account const owner{"owner"};
766 env.fund(XRP(1000), issuer, owner);
767 env.close();
768 env(fset(issuer, asfGlobalFreeze));
769 env.close();
770
771 Vault const vault{env};
772 Asset const asset = issuer["IOU"].asset();
773 auto [tx, keylet] = vault.create({.owner = owner, .asset = asset});
774
775 env(tx, Ter(tecFROZEN));
776 env.close();
777 }
778
779 {
780 testcase("IOU fail create no ripling");
781 Env env{*this, testableAmendments()};
782 Account const issuer{"issuer"};
783 Account const owner{"owner"};
784 env.fund(XRP(1000), issuer, owner);
785 env.close();
786 env(fclear(issuer, asfDefaultRipple));
787 env.close();
788
789 Vault const vault{env};
790 Asset const asset = issuer["IOU"].asset();
791 auto [tx, keylet] = vault.create({.owner = owner, .asset = asset});
792 env(tx, Ter(terNO_RIPPLE));
793 env.close();
794 }
795
796 {
797 testcase("IOU no issuer");
798 Env env{*this, testableAmendments()};
799 Account const issuer{"issuer"};
800 Account const owner{"owner"};
801 env.fund(XRP(1000), owner);
802 env.close();
803
804 Vault const vault{env};
805 Asset const asset = issuer["IOU"].asset();
806 {
807 auto [tx, keylet] = vault.create({.owner = owner, .asset = asset});
808 env(tx, Ter(terNO_ACCOUNT));
809 env.close();
810 }
811 }
812 }
813
814 {
815 testcase("IOU fail create vault for AMM LPToken");
816 Env env{*this, testableAmendments()};
817 Account const gw("gateway");
818 Account const alice("alice");
819 Account const carol("carol");
820 IOU const usd = gw["USD"];
821
822 auto const [asset1, asset2] = std::pair<STAmount, STAmount>(XRP(10000), usd(10000));
823 auto const toFund = [&](STAmount const& a) -> STAmount {
824 if (a.native())
825 {
826 auto const defXRP = XRP(30000);
827 if (a <= defXRP)
828 return defXRP;
829 return a + XRP(1000);
830 }
831 auto defIOU = STAmount{a.asset(), 30000};
832 if (a <= defIOU)
833 return defIOU;
834 return a + STAmount{a.asset(), 1000};
835 };
836 auto const toFund1 = toFund(asset1);
837 auto const toFund2 = toFund(asset2);
838 BEAST_EXPECT(asset1 <= toFund1 && asset2 <= toFund2);
839
840 if (!asset1.native() && !asset2.native())
841 {
842 fund(env, gw, {alice, carol}, {toFund1, toFund2}, Fund::All);
843 }
844 else if (asset1.native())
845 {
846 fund(env, gw, {alice, carol}, toFund1, {toFund2}, Fund::All);
847 }
848 else if (asset2.native())
849 {
850 fund(env, gw, {alice, carol}, toFund2, {toFund1}, Fund::All);
851 }
852
853 AMM const ammAlice(env, alice, asset1, asset2, CreateArg{.log = false, .tfee = 0});
854
855 Account const owner{"owner"};
856 env.fund(XRP(1000000), owner);
857
858 Vault const vault{env};
859 auto [tx, k] = vault.create({.owner = owner, .asset = ammAlice.lptIssue()});
860 env(tx, Ter{tecWRONG_ASSET});
861 env.close();
862 }
863 }
864
865 void
867 {
868 using namespace test::jtx;
869
870 auto const testCase = [this](
871 std::function<void(
872 Env & env,
873 Account const& issuer,
874 Account const& owner,
875 Account const& depositor,
876 Asset const& asset,
877 Vault& vault)> test) {
878 Env env{*this, testableAmendments()};
879 Account const issuer{"issuer"};
880 Account const owner{"owner"};
881 Account const depositor{"depositor"};
882 env.fund(XRP(1000), issuer, owner, depositor);
883 env.close();
884 Vault vault{env};
885 MPTTester mptt{env, issuer, kMptInitNoFund};
886 // Locked because that is the default flag.
887 mptt.create();
888 Asset const asset = mptt.issuanceID();
889
890 test(env, issuer, owner, depositor, asset, vault);
891 };
892
893 testCase([this](
894 Env& env,
895 Account const& issuer,
896 Account const& owner,
897 Account const& depositor,
898 Asset const& asset,
899 Vault& vault) {
900 testcase("MPT no authorization");
901 auto [tx, keylet] = vault.create({.owner = owner, .asset = asset});
902 env(tx, Ter(tecNO_AUTH));
903 });
904
905 testCase([this](
906 Env& env,
907 Account const& issuer,
908 Account const& owner,
909 Account const& depositor,
910 Asset const& asset,
911 Vault& vault) {
912 testcase("MPT cannot set Scale=0");
913 auto [tx, keylet] = vault.create({.owner = owner, .asset = asset});
914 tx[sfScale] = 0;
915 env(tx, Ter{temMALFORMED});
916 });
917
918 testCase([this](
919 Env& env,
920 Account const& issuer,
921 Account const& owner,
922 Account const& depositor,
923 Asset const& asset,
924 Vault& vault) {
925 testcase("MPT cannot set Scale=1");
926 auto [tx, keylet] = vault.create({.owner = owner, .asset = asset});
927 tx[sfScale] = 1;
928 env(tx, Ter{temMALFORMED});
929 });
930 }
931
932 void
934 {
935 using namespace test::jtx;
936
937 Env env{*this};
938
939 Account const owner{"owner"};
940 env.fund(XRP(1'000'000), owner);
941 env.close();
942
943 Vault const vault{env};
944
945 auto const keylet = keylet::vault(owner.id(), SeqProxy::rawSequence(1));
946 auto delTx = vault.del({.owner = owner, .id = keylet.key});
947
948 // Test VaultDelete with featureLendingProtocolV1_1 disabled
949 // Transaction fails if the data field is provided
950 {
951 testcase("VaultDelete memo data featureLendingProtocolV1_1 disabled");
952 env.disableFeature(featureLendingProtocolV1_1);
953 delTx[sfMemoData] = strHex(std::string(kMaxDataPayloadLength, 'A'));
954 env(delTx, Ter(temDISABLED));
955 env.enableFeature(featureLendingProtocolV1_1);
956 env.close();
957 }
958
959 // Transaction fails if the data field is too large
960 {
961 testcase("VaultDelete memo data featureLendingProtocolV1_1 enabled data too large");
962 delTx[sfMemoData] = strHex(std::string(kMaxDataPayloadLength + 1, 'A'));
963 env(delTx, Ter(temMALFORMED));
964 env.close();
965 }
966
967 // Transaction fails if the data field is set, but is empty
968 {
969 testcase("VaultDelete memo data featureLendingProtocolV1_1 enabled data empty");
970 delTx[sfMemoData] = strHex(std::string());
971 env(delTx, Ter(temMALFORMED));
972 env.close();
973 }
974
975 {
976 testcase("VaultDelete memo data featureLendingProtocolV1_1 enabled no vault");
977 auto const keylet = keylet::vault(owner.id(), SeqProxy::rawSequence(env.seq(owner)));
978
979 // Recreate the transaction as the vault keylet changed
980 auto delTx = vault.del({.owner = owner, .id = keylet.key});
981 delTx[sfMemoData] = strHex(std::string(kMaxDataPayloadLength, 'A'));
982 env(delTx, Ter(tecNO_ENTRY));
983 env.close();
984 }
985
986 {
987 testcase("VaultDelete memo data featureLendingProtocolV1_1 enabled data valid");
988 PrettyAsset const xrpAsset = xrpIssue();
989 auto const [tx, keylet] = vault.create({.owner = owner, .asset = xrpAsset});
990 env(tx, Ter(tesSUCCESS));
991 env.close();
992 // Recreate the transaction as the vault keylet changed
993 auto delTx = vault.del({.owner = owner, .id = keylet.key});
994 delTx[sfMemoData] = strHex(std::string(kMaxDataPayloadLength, 'A'));
995 env(delTx, Ter(tesSUCCESS));
996 env.close();
997 }
998 }
999
1000 void
1002 {
1003 using namespace test::jtx;
1004
1005 Account const owner{"owner"};
1006 PrettyAsset const xrpAsset = xrpIssue();
1007
1008 {
1009 testcase("VaultCreate LEVersion: featureLendingProtocolV1_1 disabled, field absent");
1010 Env env{
1011 *this,
1012 testableAmendments() - featureLendingProtocolV1_1 - featureLendingProtocolV1_2};
1013 env.fund(XRP(1'000'000), owner);
1014 env.close();
1015
1016 Vault const vault{env};
1017 auto const [tx, keylet] = vault.create({.owner = owner, .asset = xrpAsset});
1018 env(tx, Ter(tesSUCCESS));
1019 env.close();
1020
1021 auto const sleVault = env.le(keylet);
1022 BEAST_EXPECT(sleVault);
1023 BEAST_EXPECT(!sleVault->isFieldPresent(sfLEVersion));
1024 }
1025
1026 {
1027 testcase(
1028 "VaultCreate LEVersion: featureLendingProtocolV1_1 enabled, LEVersion == "
1029 "VaultVersion::CashBasis");
1030 Env env{*this, testableAmendments() - featureLendingProtocolV1_2};
1031 env.fund(XRP(1'000'000), owner);
1032 env.close();
1033
1034 Vault const vault{env};
1035 auto const [tx, keylet] = vault.create({.owner = owner, .asset = xrpAsset});
1036 env(tx, Ter(tesSUCCESS));
1037 env.close();
1038
1039 auto const sleVault = env.le(keylet);
1040 BEAST_EXPECT(sleVault);
1041 BEAST_EXPECT(sleVault->isFieldPresent(sfLEVersion));
1042 BEAST_EXPECT(sleVault->at(sfLEVersion) == std::to_underlying(VaultVersion::CashBasis));
1043 }
1044
1045 {
1046 testcase("VaultCreate rejects LEVersion set in the transaction");
1047 Env env{*this};
1048 env.fund(XRP(1'000'000), owner);
1049 env.close();
1050
1051 Vault const vault{env};
1052 auto [tx, keylet] = vault.create({.owner = owner, .asset = xrpAsset});
1053 tx[sfLEVersion] = 2;
1054 env(tx, Ter(temMALFORMED));
1055 env.close();
1056
1057 BEAST_EXPECT(!env.le(keylet));
1058 }
1059
1060 {
1061 testcase("VaultSet rejects LEVersion set in the transaction");
1062 Env env{*this};
1063 env.fund(XRP(1'000'000), owner);
1064 env.close();
1065
1066 Vault const vault{env};
1067 auto const [createTx, keylet] = vault.create({.owner = owner, .asset = xrpAsset});
1068 env(createTx, Ter(tesSUCCESS));
1069 env.close();
1070
1071 auto setTx = vault.set({.owner = owner, .id = keylet.key});
1072 setTx[sfLEVersion] = 2;
1073 env(setTx, Ter(temMALFORMED));
1074 env.close();
1075 }
1076 }
1077
1078 // A pseudo-account belongs to a ledger object, so it must never be the
1079 // destination of a withdrawal. The payout is refused either way, by the
1080 // deposit authorization every pseudo-account carries, so the only change
1081 // is a misleading tecNO_PERMISSION becoming tecPSEUDO_ACCOUNT. The check
1082 // runs ahead of the private-vault domain check, which would otherwise
1083 // report a domain problem against an account that can never join one.
1084 void
1086 {
1087 using namespace test::jtx;
1088
1089 bool const withFix = features[fixCleanup3_4_0];
1090 testcase(
1091 std::string{"VaultWithdraw pseudo-account destination"} +
1092 (withFix ? " (fixCleanup3_4_0)" : " (pre-fix)"));
1093
1094 Account const issuer{"issuer"};
1095 Account const owner{"owner"};
1096 Account const depositor{"depositor"};
1097 Account const pdOwner{"pdOwner"};
1098 Account const credIssuer{"credIssuer"};
1099 std::string const credType = "credential";
1100
1101 Env env{*this, features};
1102 Vault const vault{env};
1103
1104 env.fund(XRP(100'000), issuer, owner, depositor, pdOwner, credIssuer);
1105 // Rippling plays no part in what is being tested here, and would
1106 // otherwise stop the payout before it reaches the check under test.
1107 env(fset(issuer, asfDefaultRipple));
1108 env.close();
1109
1110 PrettyAsset const asset = issuer["IOU"];
1111 for (auto const& account : {owner, depositor})
1112 {
1113 env.trust(asset(1'000'000), account);
1114 env(pay(issuer, account, asset(10'000)));
1115 }
1116 env.close();
1117
1118 // Another vault over the same asset supplies the destination. Its
1119 // pseudo-account holds a trust line for the asset from creation, so
1120 // the payout is refused for being a pseudo-account and nothing else.
1121 auto const pseudoDestination = [&] {
1122 auto [tx, keylet] = vault.create({.owner = owner, .asset = asset});
1123 env(tx);
1124 env.close();
1125 return Account("otherVault", env.le(keylet)->at(sfAccount));
1126 }();
1127
1128 TER const expected = withFix ? TER(tecPSEUDO_ACCOUNT) : TER(tecNO_PERMISSION);
1129
1130 auto const withdrawToPseudo = [&](UInt256 const& vaultId) {
1131 auto tx = vault.withdraw({.depositor = depositor, .id = vaultId, .amount = asset(1)});
1132 tx[sfDestination] = pseudoDestination.human();
1133 return tx;
1134 };
1135
1136 {
1137 auto [createTx, keylet] = vault.create({.owner = owner, .asset = asset});
1138 env(createTx);
1139 env.close();
1140
1141 env(vault.deposit({.depositor = depositor, .id = keylet.key, .amount = asset(1'000)}));
1142 env.close();
1143
1144 env(withdrawToPseudo(keylet.key), Ter(expected));
1145 env.close();
1146
1147 // Withdrawing to self out of the same vault stays unaffected.
1148 env(vault.withdraw({.depositor = depositor, .id = keylet.key, .amount = asset(1)}));
1149 env.close();
1150 }
1151
1152 {
1153 auto const domainId = [&] {
1154 pdomain::Credentials const credentials{
1155 {.issuer = credIssuer, .credType = credType},
1156 };
1157 env(pdomain::setTx(pdOwner, credentials));
1158 env.close();
1159 return pdomain::getNewDomain(env.meta());
1160 }();
1161
1162 env(credentials::create(depositor, credIssuer, credType));
1163 env(credentials::accept(depositor, credIssuer, credType));
1164 env.close();
1165
1166 auto [createTx, keylet] =
1167 vault.create({.owner = owner, .asset = asset, .flags = tfVaultPrivate});
1168 env(createTx);
1169 env.close();
1170
1171 auto setTx = vault.set({.owner = owner, .id = keylet.key});
1172 setTx[sfDomainID] = to_string(domainId);
1173 env(setTx);
1174 env.close();
1175
1176 env(vault.deposit({.depositor = depositor, .id = keylet.key, .amount = asset(1'000)}));
1177 env.close();
1178
1179 // The domain check never gets a say: the destination is rejected
1180 // for what it is, not for the domain it is missing.
1181 env(withdrawToPseudo(keylet.key), Ter(expected));
1182 env.close();
1183 }
1184 }
1185
1186 void
1188 {
1189 using namespace test::jtx;
1190
1191 bool const withFix = features[fixCleanup3_5_0];
1192 testcase(
1193 std::string("AssetsMaximum out of range for the asset (") + (withFix ? "post" : "pre") +
1194 "-fixCleanup3_5_0)");
1195
1196 Env env{*this, features};
1197 Account const issuer{"issuer"};
1198 Account const owner{"owner"};
1199 env.fund(XRP(1'000'000), issuer, owner);
1200 env.close();
1201
1202 Vault const vault{env};
1203
1204 // Without the fix, rounding an out-of-range AssetsMaximum to the vault
1205 // asset throws. FixedPrecision Vaults check AssetsMaximum against the
1206 // base grid in preclaim first, which rejects it without throwing.
1207 bool const fixedPrecision = features[featureLendingProtocolV1_1] &&
1208 features[featureLendingProtocolV1_2] && features[fixCleanup3_4_0];
1209 TER const preFixErr = fixedPrecision ? TER{tecPRECISION_LOSS} : TER{tefEXCEPTION};
1210 TER const createErr = withFix ? TER{temMALFORMED} : preFixErr;
1211 TER const setErr = withFix ? TER{tecPRECISION_LOSS} : preFixErr;
1212
1213 auto const test = [&](Asset const& asset, Number const& maxValid, Number const& overMax) {
1214 {
1215 auto [tx, keylet] = vault.create({.owner = owner, .asset = asset});
1216 tx[sfAssetsMaximum] = to_string(overMax);
1217 env(tx, Ter(createErr));
1218 env.close();
1219 BEAST_EXPECT(!env.le(keylet));
1220 }
1221
1222 auto [tx, keylet] = vault.create({.owner = owner, .asset = asset});
1223 tx[sfAssetsMaximum] = to_string(maxValid);
1224 env(tx);
1225 env.close();
1226
1227 auto setTx = vault.set({.owner = owner, .id = keylet.key});
1228 setTx[sfAssetsMaximum] = to_string(overMax);
1229 env(setTx, Ter(setErr));
1230 env.close();
1231
1232 if (auto const sle = env.le(keylet); BEAST_EXPECT(sle))
1233 BEAST_EXPECT(sle->at(sfAssetsMaximum) == maxValid);
1234 };
1235
1236 Number const maxXrp{static_cast<std::int64_t>(STAmount::kMaxNativeN)};
1237 test(xrpIssue(), maxXrp, maxXrp + 1);
1238
1239 MPT const btc = MPTTester({.env = env, .issuer = issuer, .holders = {owner}});
1240 test(btc.asset(), Number{static_cast<std::int64_t>(kMaxMpTokenAmount)}, Number{1, 19});
1241
1242 Number const maxIou{static_cast<std::int64_t>(STAmount::kMaxValue), STAmount::kMaxOffset};
1243 test(issuer["USD"], maxIou, Number{1, STAmount::kMaxOffset + 16});
1244 }
1245
1246public:
1247 void
1263};
1264
1265BEAST_DEFINE_TESTSUITE(VaultValidation, app, xrpl);
1266
1267} // namespace xrpl
TestcaseT testcase
Memberspace for declaring test cases.
Definition suite.h:155
constexpr bool native() const
Definition Asset.h:125
Integers of any length that is a multiple of 32-bits.
Definition base_uint.h:82
Number is a floating point type that can represent a wide range of values.
Definition Number.h:351
static constexpr std::uint64_t kMaxNativeN
Definition STAmount.h:72
static constexpr std::uint64_t kMaxValue
Definition STAmount.h:67
static constexpr int kMaxOffset
Definition STAmount.h:62
static constexpr SeqProxy rawSequence(std::uint32_t v)
Factory function to return a sequence-based SeqProxy.
Definition SeqProxy.h:62
Shared base for the Vault*_test family under src/test/app/vault/.
FeatureBitset const all_
static constexpr auto kNegativeAmount
test::jtx::PrettyAsset PrettyAsset
void testAssetsMaximumOutOfRange(FeatureBitset features)
void testVaultWithdrawPseudoAccountDestination(FeatureBitset features)
void run() override
Runs the suite.
constexpr Zero kZero
Definition Zero.h:30
Keylet computation functions.
Definition Indexes.h:39
Keylet const & skip() noexcept
The index of the "short" skip list.
Definition Indexes.cpp:245
Keylet vault(AccountID const &owner, SeqProxy const &seq) noexcept
Definition Indexes.cpp:565
Use hash_* containers for keys that do not need a cryptographically secure hashing algorithm.
Definition algorithm.h:5
@ telINSUF_FEE_P
Definition TER.h:43
@ terNO_RIPPLE
Definition TER.h:226
@ terNO_ACCOUNT
Definition TER.h:219
Issue const & xrpIssue()
Returns an asset specifier that represents XRP.
Definition Issue.h:108
std::string strHex(FwdIt begin, FwdIt end)
Definition strHex.h:13
@ tefEXCEPTION
Definition TER.h:166
std::string to_string(BaseUInt< Bits, Tag > const &a)
Definition base_uint.h:658
constexpr std::size_t kMaxDataPayloadLength
The maximum length of Data payload.
Definition Protocol.h:303
BaseUInt< 256 > UInt256
Definition base_uint.h:581
@ temBAD_FEE
Definition TER.h:80
@ temINVALID_FLAG
Definition TER.h:99
@ temMALFORMED
Definition TER.h:75
@ temDISABLED
Definition TER.h:102
@ temBAD_AMOUNT
Definition TER.h:77
TERSubset< CanCvtToTER > TER
Definition TER.h:657
@ tecWRONG_ASSET
Definition TER.h:371
@ tecPSEUDO_ACCOUNT
Definition TER.h:373
@ tecNO_ENTRY
Definition TER.h:317
@ tecOBJECT_NOT_FOUND
Definition TER.h:337
@ tecNO_AUTH
Definition TER.h:311
@ tecFROZEN
Definition TER.h:314
@ tecPRECISION_LOSS
Definition TER.h:374
@ tecINSUFFICIENT_RESERVE
Definition TER.h:318
@ tecNO_PERMISSION
Definition TER.h:316
BEAST_DEFINE_TESTSUITE(AccountTxPaging, app, xrpl)
@ tesSUCCESS
Definition TER.h:253
UInt256 key
Definition Keylet.h:21