xrpld
Loading...
Searching...
No Matches
VaultDomain_test.cpp
1#include <test/app/vault/VaultTestBase.h>
2#include <test/jtx/Account.h>
3#include <test/jtx/Env.h>
4#include <test/jtx/TestHelpers.h>
5#include <test/jtx/amount.h>
6#include <test/jtx/credentials.h>
7#include <test/jtx/deposit.h>
8#include <test/jtx/flags.h>
9#include <test/jtx/offer.h>
10#include <test/jtx/pay.h>
11#include <test/jtx/permissioned_domains.h>
12#include <test/jtx/ter.h>
13#include <test/jtx/vault.h>
14
15#include <xrpl/basics/base_uint.h>
16#include <xrpl/basics/chrono.h>
17#include <xrpl/beast/unit_test/suite.h>
18#include <xrpl/json/json_forwards.h>
19#include <xrpl/json/json_value.h>
20#include <xrpl/protocol/AccountID.h>
21#include <xrpl/protocol/Asset.h>
22#include <xrpl/protocol/Feature.h>
23#include <xrpl/protocol/Indexes.h>
24#include <xrpl/protocol/Issue.h>
25#include <xrpl/protocol/Keylet.h>
26#include <xrpl/protocol/MPTIssue.h>
27#include <xrpl/protocol/SField.h>
28#include <xrpl/protocol/TER.h>
29#include <xrpl/protocol/TxFlags.h>
30#include <xrpl/protocol/jss.h>
31
32#include <chrono>
33#include <cstdint>
34#include <string>
35#include <tuple>
36#include <utility>
37
38namespace xrpl {
39
41{
42private:
43 void
45 {
46 using namespace test::jtx;
47
48 testcase("private vault");
49
50 Env env{*this, testableAmendments()};
51 Account const issuer{"issuer"};
52 Account const owner{"owner"};
53 Account const depositor{"depositor"};
54 Account const charlie{"charlie"};
55 Account const pdOwner{"pdOwner"};
56 Account const credIssuer1{"credIssuer1"};
57 Account const credIssuer2{"credIssuer2"};
58 std::string const credType = "credential";
59 Vault const vault{env};
60 env.fund(XRP(1000), issuer, owner, depositor, charlie, pdOwner, credIssuer1, credIssuer2);
61 env.close();
62 env(fset(issuer, asfAllowTrustLineClawback));
63 env.close();
64 env.require(Flags(issuer, asfAllowTrustLineClawback));
65
66 PrettyAsset const asset = issuer["IOU"];
67 env.trust(asset(1000), owner);
68 env(pay(issuer, owner, asset(500)));
69 env.trust(asset(1000), depositor);
70 env(pay(issuer, depositor, asset(500)));
71 env.trust(asset(1000), charlie);
72 env(pay(issuer, charlie, asset(5)));
73 env.close();
74
75 auto [tx, keylet] = vault.create({.owner = owner, .asset = asset, .flags = tfVaultPrivate});
76 env(tx);
77 env.close();
78 BEAST_EXPECT(env.le(keylet));
79
80 {
81 testcase("private vault owner can deposit");
82 auto const tx =
83 vault.deposit({.depositor = owner, .id = keylet.key, .amount = asset(50)});
84 env(tx);
85 }
86
87 {
88 testcase("private vault depositor not authorized yet");
89 auto const tx =
90 vault.deposit({.depositor = depositor, .id = keylet.key, .amount = asset(50)});
91 env(tx, Ter{tecNO_AUTH});
92 }
93
94 {
95 testcase("private vault cannot set non-existing domain");
96 auto tx = vault.set({.owner = owner, .id = keylet.key});
97 tx[sfDomainID] = to_string(BaseUInt<256>(42ul));
98 env(tx, Ter{tecOBJECT_NOT_FOUND});
99 }
100
101 {
102 testcase("private vault set domainId");
103
104 {
105 pdomain::Credentials const credentials1{
106 {.issuer = credIssuer1, .credType = credType},
107 };
108
109 env(pdomain::setTx(pdOwner, credentials1));
110 auto const domainId1 = [&] {
111 auto const tx = env.tx()->getJson(JsonOptions::Values::None);
112 return pdomain::getNewDomain(env.meta());
113 }();
114
115 auto tx = vault.set({.owner = owner, .id = keylet.key});
116 tx[sfDomainID] = to_string(domainId1);
117 env(tx);
118 env.close();
119
120 // Update domain second time, should be harmless
121 env(tx);
122 env.close();
123 }
124
125 {
126 pdomain::Credentials const credentials{
127 {.issuer = credIssuer1, .credType = credType},
128 {.issuer = credIssuer2, .credType = credType},
129 };
130
131 env(pdomain::setTx(pdOwner, credentials));
132 auto const domainId = [&] {
133 auto const tx = env.tx()->getJson(JsonOptions::Values::None);
134 return pdomain::getNewDomain(env.meta());
135 }();
136
137 auto tx = vault.set({.owner = owner, .id = keylet.key});
138 tx[sfDomainID] = to_string(domainId);
139 env(tx);
140 env.close();
141
142 // Should be idempotent
143 tx = vault.set({.owner = owner, .id = keylet.key});
144 tx[sfDomainID] = to_string(domainId);
145 env(tx);
146 env.close();
147 }
148 }
149
150 {
151 testcase("private vault depositor still not authorized");
152 auto const tx =
153 vault.deposit({.depositor = depositor, .id = keylet.key, .amount = asset(50)});
154 env(tx, Ter{tecNO_AUTH});
155 env.close();
156 }
157
158 auto const credKeylet = credentials::keylet(depositor, credIssuer1, credType);
159 {
160 testcase("private vault depositor now authorized");
161 env(credentials::create(depositor, credIssuer1, credType));
162 env(credentials::accept(depositor, credIssuer1, credType));
163 env(credentials::create(charlie, credIssuer1, credType));
164 // charlie's credential not accepted
165 env.close();
166 auto const credSle = env.le(credKeylet);
167 BEAST_EXPECT(credSle != nullptr);
168
169 auto tx =
170 vault.deposit({.depositor = depositor, .id = keylet.key, .amount = asset(50)});
171 env(tx);
172 env.close();
173
174 tx = vault.deposit({.depositor = charlie, .id = keylet.key, .amount = asset(50)});
175 env(tx, Ter{tecNO_AUTH});
176 env.close();
177 }
178
179 {
180 testcase("private vault depositor lost authorization");
181 env(credentials::deleteCred(credIssuer1, depositor, credIssuer1, credType));
182 env(credentials::deleteCred(credIssuer1, charlie, credIssuer1, credType));
183 env.close();
184 auto const credSle = env.le(credKeylet);
185 BEAST_EXPECT(credSle == nullptr);
186
187 auto const tx =
188 vault.deposit({.depositor = depositor, .id = keylet.key, .amount = asset(50)});
189 env(tx, Ter{tecNO_AUTH});
190 env.close();
191 }
192
193 auto const shares = [&env, keylet = keylet, this] -> Asset {
194 auto const vault = env.le(keylet);
195 BEAST_EXPECT(vault != nullptr);
196 return MPTIssue(vault->at(sfShareMPTID));
197 }();
198
199 {
200 testcase("private vault expired authorization");
201 uint32_t const closeTime =
202 env.current()->header().parentCloseTime.time_since_epoch().count();
203 {
204 auto tx0 = credentials::create(depositor, credIssuer2, credType);
205 tx0[sfExpiration] = closeTime + 20;
206 env(tx0);
207 tx0 = credentials::create(charlie, credIssuer2, credType);
208 tx0[sfExpiration] = closeTime + 20;
209 env(tx0);
210 env.close();
211
212 env(credentials::accept(depositor, credIssuer2, credType));
213 env(credentials::accept(charlie, credIssuer2, credType));
214 env.close();
215 }
216
217 {
218 auto const tx1 =
219 vault.deposit({.depositor = depositor, .id = keylet.key, .amount = asset(50)});
220 env(tx1);
221 env.close();
222
223 auto const tokenKeylet =
224 keylet::mptoken(shares.get<MPTIssue>().getMptID(), depositor.id());
225 BEAST_EXPECT(env.le(tokenKeylet) != nullptr);
226 }
227
228 {
229 // time advance
230 env.close();
231 env.close();
232 env.close();
233
234 auto const credsKeylet = credentials::keylet(depositor, credIssuer2, credType);
235 BEAST_EXPECT(env.le(credsKeylet) != nullptr);
236
237 auto const tx2 =
238 vault.deposit({.depositor = depositor, .id = keylet.key, .amount = asset(1)});
239 env(tx2, Ter{tecEXPIRED});
240 env.close();
241
242 BEAST_EXPECT(env.le(credsKeylet) == nullptr);
243 }
244
245 {
246 auto const credsKeylet = credentials::keylet(charlie, credIssuer2, credType);
247 BEAST_EXPECT(env.le(credsKeylet) != nullptr);
248 auto const tokenKeylet =
249 keylet::mptoken(shares.get<MPTIssue>().getMptID(), charlie.id());
250 BEAST_EXPECT(env.le(tokenKeylet) == nullptr);
251
252 auto const tx3 =
253 vault.deposit({.depositor = charlie, .id = keylet.key, .amount = asset(2)});
254 env(tx3, Ter{tecEXPIRED});
255
256 env.close();
257 BEAST_EXPECT(env.le(credsKeylet) == nullptr);
258 BEAST_EXPECT(env.le(tokenKeylet) == nullptr);
259 }
260 }
261
262 {
263 testcase("private vault reset domainId");
264 auto tx = vault.set({.owner = owner, .id = keylet.key});
265 tx[sfDomainID] = "0";
266 env(tx);
267 env.close();
268
269 tx = vault.deposit({.depositor = depositor, .id = keylet.key, .amount = asset(50)});
270 env(tx, Ter{tecNO_AUTH});
271 env.close();
272
273 tx = vault.withdraw({.depositor = depositor, .id = keylet.key, .amount = asset(50)});
274 env(tx);
275 env.close();
276
277 tx = vault.clawback(
278 {.issuer = issuer, .id = keylet.key, .holder = depositor, .amount = asset(0)});
279 env(tx);
280
281 tx = vault.clawback(
282 {.issuer = issuer, .id = keylet.key, .holder = owner, .amount = asset(0)});
283 env(tx);
284 env.close();
285
286 tx = vault.del({
287 .owner = owner,
288 .id = keylet.key,
289 });
290 env(tx);
291 }
292 }
293
294 void
296 {
297 using namespace test::jtx;
298
299 testcase("private vault share transfer after depositor loses domain");
300
301 // The "Private Vault - Access Control Rules" spec requires that a holder who
302 // loses Layer 2 (Permissioned Domain membership) after acquiring shares be
303 // blocked from sending them onward, by P2P transfer or DEX offer, the same
304 // way a brand-new never-authorized holder is blocked. Only withdrawal to
305 // self is meant to stay open.
306 //
307 // For a domain-gated share MPToken, requireAuth()'s escape hatch for
308 // holders who already have an MPToken (MPTokenHelpers.cpp) only applies to
309 // the classic explicit-issuer-authorization flag, which
310 // enforceMPTokenAuthorization documents as "meaningless" for
311 // domain-authorized holders and never sets. So a stale MPToken does not
312 // carry authorization forward once the account's domain credential is
313 // gone, and both actions below are correctly blocked.
314
315 Env env{*this, testableAmendments()};
316 Account const issuer{"issuer"};
317 Account const owner{"owner"};
318 Account const depositor{"depositor"};
319 Account const bob{"bob"};
320 Account const pdOwner{"pdOwner"};
321 Account const credIssuer{"credIssuer"};
322 std::string const credType = "credential";
323 Vault const vault{env};
324 env.fund(XRP(1000), issuer, owner, depositor, bob, pdOwner, credIssuer);
325 env.close();
326
327 PrettyAsset const asset = issuer["IOU"];
328 env.trust(asset(1000), owner);
329 env(pay(issuer, owner, asset(500)));
330 env.trust(asset(1000), depositor);
331 env(pay(issuer, depositor, asset(500)));
332 env.trust(asset(1000), bob);
333 env(pay(issuer, bob, asset(500)));
334 env.close();
335
336 // Transferable shares (no tfVaultShareNonTransferable): sections 3.3/3.4 of
337 // the spec (DEX trading / P2P transfer) only apply to transferable shares.
338 auto [tx, keylet] = vault.create({.owner = owner, .asset = asset, .flags = tfVaultPrivate});
339 env(tx);
340 env.close();
341
342 pdomain::Credentials const credentials{{.issuer = credIssuer, .credType = credType}};
343 env(pdomain::setTx(pdOwner, credentials));
344 auto const domainId = [&] {
345 auto const tx = env.tx()->getJson(JsonOptions::Values::None);
346 return pdomain::getNewDomain(env.meta());
347 }();
348 {
349 auto domainTx = vault.set({.owner = owner, .id = keylet.key});
350 domainTx[sfDomainID] = to_string(domainId);
351 env(domainTx);
352 env.close();
353 }
354
355 // Both depositor and bob acquire domain membership and deposit, so each
356 // ends up with an authorized share MPToken.
357 env(credentials::create(depositor, credIssuer, credType));
358 env(credentials::accept(depositor, credIssuer, credType));
359 env(credentials::create(bob, credIssuer, credType));
360 env(credentials::accept(bob, credIssuer, credType));
361 env.close();
362
363 env(vault.deposit({.depositor = depositor, .id = keylet.key, .amount = asset(100)}));
364 env(vault.deposit({.depositor = bob, .id = keylet.key, .amount = asset(100)}));
365 env.close();
366
367 auto const shares = [&env, keylet = keylet, this] -> PrettyAsset {
368 auto const sle = env.le(keylet);
369 BEAST_EXPECT(sle != nullptr);
370 return MPTIssue(sle->at(sfShareMPTID));
371 }();
372
373 // Depositor loses Layer 2: their Permissioned Domain credential is revoked.
374 auto const credKeylet = credentials::keylet(depositor, credIssuer, credType);
375 env(credentials::deleteCred(credIssuer, depositor, credIssuer, credType));
376 env.close();
377 BEAST_EXPECT(env.le(credKeylet) == nullptr);
378
379 // Sanity check, mirrors testWithDomainCheck's "not authorized yet" case: a
380 // brand-new depositor with no MPToken yet is still correctly blocked. The
381 // gap below is specific to holders who already hold shares.
382 {
383 Account const charlie{"charlie"};
384 env.fund(XRP(1000), charlie);
385 env.close();
386 auto const depTx =
387 vault.deposit({.depositor = charlie, .id = keylet.key, .amount = asset(1)});
388 env(depTx, Ter{tecNO_AUTH});
389 }
390
391 // P2P transfer: spec section 3.4 requires this blocked once Layer 2 is
392 // lost, and it is.
393 env(pay(depositor, bob, shares(1)), Ter{tecNO_AUTH});
394 env.close();
395
396 // DEX/CLOB: spec section 3.3 requires the seller leg blocked the same way.
397 // The offer can't even be created: preclaim treats the seller as
398 // unfunded once their share balance reads as zero for auth purposes.
399 env(offer(depositor, XRP(1), shares(1)), Ter{tecUNFUNDED_OFFER});
400 env.close();
401 BEAST_EXPECT(expectOffers(env, depositor, 0));
402 }
403
404 void
406 {
407 using namespace test::jtx;
408
409 testcase("private vault share purchase via DEX requires buyer domain membership");
410
411 // The "Private Vault - Access Control Rules" spec requires the buyer leg
412 // of a DEX trade in private-vault shares to hold Layer 1 and Layer 2 as
413 // well, not just the seller.
414
415 Env env{*this, testableAmendments()};
416 Account const issuer{"issuer"};
417 Account const owner{"owner"};
418 Account const bob{"bob"};
419 Account const charlie{"charlie"};
420 Account const pdOwner{"pdOwner"};
421 Account const credIssuer{"credIssuer"};
422 std::string const credType = "credential";
423 Vault const vault{env};
424 env.fund(XRP(1000), issuer, owner, bob, charlie, pdOwner, credIssuer);
425 env.close();
426
427 PrettyAsset const asset = issuer["IOU"];
428 env.trust(asset(1000), owner);
429 env(pay(issuer, owner, asset(500)));
430 env.trust(asset(1000), bob);
431 env(pay(issuer, bob, asset(500)));
432 env.close();
433
434 auto [tx, keylet] = vault.create({.owner = owner, .asset = asset, .flags = tfVaultPrivate});
435 env(tx);
436 env.close();
437
438 pdomain::Credentials const credentials{{.issuer = credIssuer, .credType = credType}};
439 env(pdomain::setTx(pdOwner, credentials));
440 auto const domainId = [&] {
441 auto const tx = env.tx()->getJson(JsonOptions::Values::None);
442 return pdomain::getNewDomain(env.meta());
443 }();
444 {
445 auto domainTx = vault.set({.owner = owner, .id = keylet.key});
446 domainTx[sfDomainID] = to_string(domainId);
447 env(domainTx);
448 env.close();
449 }
450
451 // Only bob joins the domain and deposits; charlie never does.
452 env(credentials::create(bob, credIssuer, credType));
453 env(credentials::accept(bob, credIssuer, credType));
454 env.close();
455 env(vault.deposit({.depositor = bob, .id = keylet.key, .amount = asset(100)}));
456 env.close();
457
458 auto const shares = [&env, keylet = keylet, this] -> PrettyAsset {
459 auto const sle = env.le(keylet);
460 BEAST_EXPECT(sle != nullptr);
461 return MPTIssue(sle->at(sfShareMPTID));
462 }();
463
464 // Bob (domain member, holds shares) rests a sell offer.
465 env(offer(bob, XRP(1), shares(1)));
466 env.close();
467 BEAST_EXPECT(expectOffers(env, bob, 1));
468
469 // Charlie never held the domain credential. Buying shares via a
470 // crossing offer must be blocked the same way a direct MPTokenAuthorize
471 // + pay attempt already is (see testWithDomainChecXRP's "cannot pay
472 // shares to 3rd party"): checkAcceptAsset() rejects the offer outright
473 // in preclaim, before any funding check is even reached.
474 env(offer(charlie, shares(1), XRP(1)), Ter{tecNO_AUTH});
475 env.close();
476 BEAST_EXPECT(expectOffers(env, bob, 1));
477 BEAST_EXPECT(expectOffers(env, charlie, 0));
478 }
479
480 void
482 {
483 using namespace test::jtx;
484
485 testcase("private XRP vault");
486
487 Env env{*this, testableAmendments()};
488 Account const owner{"owner"};
489 Account const depositor{"depositor"};
490 Account const alice{"charlie"};
491 std::string const credType = "credential";
492 Vault const vault{env};
493 env.fund(XRP(100000), owner, depositor, alice);
494 env.close();
495
496 PrettyAsset const asset = xrpIssue();
497 auto [tx, keylet] = vault.create({.owner = owner, .asset = asset, .flags = tfVaultPrivate});
498 env(tx);
499 env.close();
500
501 auto const [vaultAccount, issuanceId] =
502 [&env, keylet = keylet, this] -> std::tuple<AccountID, UInt192> {
503 auto const vault = env.le(keylet);
504 BEAST_EXPECT(vault != nullptr);
505 return {vault->at(sfAccount), vault->at(sfShareMPTID)};
506 }();
507 BEAST_EXPECT(env.le(keylet::account(vaultAccount)));
508 BEAST_EXPECT(env.le(keylet::mptokenIssuance(issuanceId)));
509 PrettyAsset const shares{issuanceId};
510
511 {
512 testcase("private XRP vault owner can deposit");
513 auto const tx =
514 vault.deposit({.depositor = owner, .id = keylet.key, .amount = asset(50)});
515 env(tx);
516 env.close();
517 }
518
519 {
520 testcase("private XRP vault cannot pay shares to depositor yet");
521 env(pay(owner, depositor, shares(1)), Ter{tecNO_AUTH});
522 }
523
524 {
525 testcase("private XRP vault depositor not authorized yet");
526 auto const tx =
527 vault.deposit({.depositor = depositor, .id = keylet.key, .amount = asset(50)});
528 env(tx, Ter{tecNO_AUTH});
529 }
530
531 {
532 testcase("private XRP vault set DomainID");
533 pdomain::Credentials const credentials{{.issuer = owner, .credType = credType}};
534
535 env(pdomain::setTx(owner, credentials));
536 auto const domainId = [&] {
537 auto const tx = env.tx()->getJson(JsonOptions::Values::None);
538 return pdomain::getNewDomain(env.meta());
539 }();
540
541 auto tx = vault.set({.owner = owner, .id = keylet.key});
542 tx[sfDomainID] = to_string(domainId);
543 env(tx);
544 env.close();
545 }
546
547 auto const credKeylet = credentials::keylet(depositor, owner, credType);
548 {
549 testcase("private XRP vault depositor now authorized");
550 env(credentials::create(depositor, owner, credType));
551 env(credentials::accept(depositor, owner, credType));
552 env.close();
553
554 BEAST_EXPECT(env.le(credKeylet));
555 auto const tx =
556 vault.deposit({.depositor = depositor, .id = keylet.key, .amount = asset(50)});
557 env(tx);
558 env.close();
559 }
560
561 {
562 testcase("private XRP vault can pay shares to depositor");
563 env(pay(owner, depositor, shares(1)));
564 }
565
566 {
567 testcase("private XRP vault cannot pay shares to 3rd party");
568 json::Value jv;
569 jv[sfAccount] = alice.human();
570 jv[sfTransactionType] = jss::MPTokenAuthorize;
571 jv[sfMPTokenIssuanceID] = to_string(issuanceId);
572 env(jv);
573 env.close();
574
575 env(pay(owner, alice, shares(1)), Ter{tecNO_AUTH});
576 }
577 }
578
579 // Withdrawing out of a private vault to a third party requires both the
580 // submitter and the destination to be members of the vault's permissioned
581 // domain. Withdrawal to self is exempt: revoking vault access must not
582 // trap already deposited funds. The asset issuer is exempt as a
583 // destination, so that frozen assets can always be returned.
584 void
586 {
587 using namespace test::jtx;
588
589 bool const withFix = features[fixCleanup3_4_0];
590 testcase(
591 std::string{"VaultWithdraw private vault destination domain check"} +
592 (withFix ? " (fixCleanup3_4_0)" : " (pre-fix)"));
593
594 Account const issuer{"issuer"};
595 Account const owner{"owner"};
596 Account const depositor{"depositor"};
597 Account const beneficiary{"beneficiary"};
598 Account const outsider{"outsider"};
599 Account const pdOwner{"pdOwner"};
600 Account const credIssuer{"credIssuer"};
601 std::string const credType = "credential";
602
603 Env env{*this, features};
604 Vault const vault{env};
605
606 env.fund(
607 XRP(100'000), issuer, owner, depositor, beneficiary, outsider, pdOwner, credIssuer);
608 env.close();
609
610 PrettyAsset const asset = issuer["IOU"];
611 // Everyone holds Layer 1 (asset) permission, so anything blocked below
612 // is blocked by the Layer 2 (vault) check alone.
613 for (auto const& account : {owner, depositor, beneficiary, outsider})
614 {
615 env.trust(asset(1'000'000), account);
616 env(pay(issuer, account, asset(10'000)));
617 }
618 env.close();
619
620 auto const domainId = [&] {
621 pdomain::Credentials const credentials{{.issuer = credIssuer, .credType = credType}};
622 env(pdomain::setTx(pdOwner, credentials));
623 env.close();
624 return pdomain::getNewDomain(env.meta());
625 }();
626
627 auto const joinDomain = [&](Account const& account) {
628 env(credentials::create(account, credIssuer, credType));
629 env(credentials::accept(account, credIssuer, credType));
630 env.close();
631 };
632 joinDomain(depositor);
633 joinDomain(beneficiary);
634
635 auto [createTx, keylet] =
636 vault.create({.owner = owner, .asset = asset, .flags = tfVaultPrivate});
637 env(createTx);
638 env.close();
639
640 {
641 auto tx = vault.set({.owner = owner, .id = keylet.key});
642 tx[sfDomainID] = to_string(domainId);
643 env(tx);
644 env.close();
645 }
646
647 env(vault.deposit({.depositor = depositor, .id = keylet.key, .amount = asset(1'000)}));
648 env.close();
649
650 auto const withdrawTo = [&, keylet = keylet](Account const& destination) {
651 auto tx =
652 vault.withdraw({.depositor = depositor, .id = keylet.key, .amount = asset(1)});
653 tx[sfDestination] = destination.human();
654 return tx;
655 };
656
657 {
658 // Destination holds both layers of permission.
659 env(withdrawTo(beneficiary));
660 env.close();
661 }
662
663 {
664 // Destination may hold the asset but was never let into the vault.
665 env(withdrawTo(outsider), Ter(withFix ? TER(tecNO_AUTH) : TER(tesSUCCESS)));
666 env.close();
667 }
668
669 {
670 // The asset issuer can always receive, to keep the recovery path
671 // for frozen assets open.
672 env(withdrawTo(issuer));
673 env.close();
674 }
675
676 {
677 // The vault owner gets no special treatment as a destination: it
678 // is a third party like any other and needs domain membership.
679 env(withdrawTo(owner), Ter(withFix ? TER(tecNO_AUTH) : TER(tesSUCCESS)));
680 env.close();
681 }
682
683 {
684 // Withdrawal to self needs no Destination and stays unaffected.
685 env(vault.withdraw({.depositor = depositor, .id = keylet.key, .amount = asset(1)}));
686 env.close();
687 }
688
689 {
690 // Naming yourself as the Destination is still a withdrawal to self.
691 env(withdrawTo(depositor));
692 env.close();
693 }
694
695 {
696 testcase(
697 std::string{"VaultWithdraw private vault submitter lost vault access"} +
698 (withFix ? " (fixCleanup3_4_0)" : " (pre-fix)"));
699
700 env(credentials::deleteCred(credIssuer, depositor, credIssuer, credType));
701 env.close();
702
703 // The exit of last resort: the submitter lost vault access but
704 // must still be able to redeem its own shares.
705 env(vault.withdraw({.depositor = depositor, .id = keylet.key, .amount = asset(1)}));
706 env.close();
707
708 // Moving funds to anyone else is not allowed any more, even to a
709 // destination that is itself a domain member.
710 env(withdrawTo(beneficiary), Ter(withFix ? TER(tecNO_AUTH) : TER(tesSUCCESS)));
711 env.close();
712
713 // Returning assets to the issuer stays open regardless.
714 env(withdrawTo(issuer));
715 env.close();
716 }
717
718 {
719 testcase(
720 std::string{"VaultWithdraw private vault with no domain set"} +
721 (withFix ? " (fixCleanup3_4_0)" : " (pre-fix)"));
722
723 // Give the submitter its vault access back first, so that the
724 // vault having no domain is the only reason left to refuse.
725 env(credentials::create(depositor, credIssuer, credType));
726 env(credentials::accept(depositor, credIssuer, credType));
727 env.close();
728
729 auto tx = vault.set({.owner = owner, .id = keylet.key});
730 tx[sfDomainID] = "0";
731 env(tx);
732 env.close();
733
734 // Clearing the domain leaves the vault with nobody it considers
735 // authorized, so a third-party destination cannot qualify even
736 // though both ends of the payout hold a credential.
737 env(withdrawTo(beneficiary), Ter(withFix ? TER(tecNO_AUTH) : TER(tesSUCCESS)));
738 env.close();
739
740 // The two exempt paths survive the domain going away.
741 env(vault.withdraw({.depositor = depositor, .id = keylet.key, .amount = asset(1)}));
742 env.close();
743
744 env(withdrawTo(issuer));
745 env.close();
746 }
747
748 {
749 testcase(
750 std::string{"VaultWithdraw public vault destination unaffected"} +
751 (withFix ? " (fixCleanup3_4_0)" : " (pre-fix)"));
752
753 auto [publicTx, publicKeylet] = vault.create({.owner = owner, .asset = asset});
754 env(publicTx);
755 env.close();
756
757 env(vault.deposit({.depositor = owner, .id = publicKeylet.key, .amount = asset(100)}));
758 env.close();
759
760 auto tx =
761 vault.withdraw({.depositor = owner, .id = publicKeylet.key, .amount = asset(1)});
762 tx[sfDestination] = outsider.human();
763 env(tx);
764 env.close();
765 }
766 }
767
768 void
770 {
771 testcase(
772 "withdraw with credential-based deposit preauth " +
773 std::string{features[fixCleanup3_4_0] ? "post-fix" : "pre-fix"});
774 using namespace test::jtx;
775 using namespace std::chrono_literals;
776
777 bool const fixEnabled = features[fixCleanup3_4_0];
778
779 Env env{*this, features};
780
781 Account const owner{"owner"};
782 Account const depositor{"depositor"};
783 Account const dest{"dest"};
784 Account const credIssuer{"credIssuer"};
785 char const credType[] = "abcde";
786
787 env.fund(XRP(1000), owner, depositor, dest, credIssuer);
788 env(fset(dest, asfDepositAuth));
789 env.close();
790
791 PrettyAsset const asset{xrpIssue(), 1'000'000};
792 Vault vault{env};
793 auto [tx, keylet] = vault.create({.owner = owner, .asset = asset});
794 env(tx);
795 env.close();
796
797 env(vault.deposit({.depositor = depositor, .id = keylet.key, .amount = asset(100)}));
798 env.close();
799
800 auto const withdrawToDest = [&] {
801 auto wtx =
802 vault.withdraw({.depositor = depositor, .id = keylet.key, .amount = asset(10)});
803 wtx[sfDestination] = dest.human();
804 return wtx;
805 };
806
807 // Without any preauth, withdraw to dest fails
808 env(withdrawToDest(), Ter{tecNO_PERMISSION});
809 env.close();
810
811 // Issue and accept a credential for the depositor (with expiration)
812 auto jv = credentials::create(depositor, credIssuer, credType);
813 std::uint32_t const expiration =
814 env.current()->header().parentCloseTime.time_since_epoch().count() + 100;
815 jv[sfExpiration.jsonName] = expiration;
816 env(jv);
817 env(credentials::accept(depositor, credIssuer, credType));
818 env.close();
819
820 auto const credKeylet = credentials::keylet(depositor, credIssuer, credType);
821 auto const credIdx =
822 credentials::ledgerEntry(env, depositor, credIssuer, credType)[jss::result][jss::index]
823 .asString();
824
825 // dest authorizes deposits from holders of credentials issued by credIssuer
826 env(deposit::authCredentials(dest, {{.issuer = credIssuer, .credType = credType}}));
827 env.close();
828
829 // Withdraw without supplying credentials still fails
830 env(withdrawToDest(), Ter{tecNO_PERMISSION});
831 env.close();
832
833 if (!fixEnabled)
834 {
835 // Pre-fix: sfCredentialIDs in VaultWithdraw is rejected as disabled
836 env(withdrawToDest(), credentials::Ids({credIdx}), Ter{temDISABLED});
837 env.close();
838 return;
839 }
840
841 // Withdraw with credentials succeeds
842 env(withdrawToDest(), credentials::Ids({credIdx}));
843 env.close();
844
845 // Bad credential id is rejected
846 std::string const invalidIdx =
847 "0E0B04ED60588A758B67E21FBBE95AC5A63598BA951761DC0EC9C08D7E01E034";
848 env(withdrawToDest(), credentials::Ids({invalidIdx}), Ter{tecBAD_CREDENTIALS});
849 env.close();
850
851 // Malformed credential array (duplicates) is rejected by checkFields
852 env(withdrawToDest(), credentials::Ids({credIdx, credIdx}), Ter{temMALFORMED});
853 env.close();
854
855 // Valid credential not authorized by dest hits authorizedDepositPreauth error path
856 char const credType2[] = "fghij";
857 env(credentials::create(depositor, credIssuer, credType2));
858 env(credentials::accept(depositor, credIssuer, credType2));
859 env.close();
860 auto const credIdx2 =
861 credentials::ledgerEntry(env, depositor, credIssuer, credType2)[jss::result][jss::index]
862 .asString();
863 env(withdrawToDest(), credentials::Ids({credIdx2}), Ter{tecNO_PERMISSION});
864 env.close();
865
866 // Advance time past expiration: credentials yield tecEXPIRED and are deleted
867 env.close(150s);
868 BEAST_EXPECT(env.le(credKeylet));
869 env(withdrawToDest(), credentials::Ids({credIdx}), Ter{tecEXPIRED});
870 env.close();
871 BEAST_EXPECT(!env.le(credKeylet));
872 }
873
874public:
875 void
887};
888
889BEAST_DEFINE_TESTSUITE(VaultDomain, app, xrpl);
890
891} // namespace xrpl
TestcaseT testcase
Memberspace for declaring test cases.
Definition suite.h:155
Represents a JSON value.
Definition json_value.h:121
Integers of any length that is a multiple of 32-bits.
Definition base_uint.h:82
constexpr MPTID const & getMptID() const
Definition MPTIssue.h:43
void testVaultWithdrawPrivateDestinationDomain(FeatureBitset features)
void run() override
Runs the suite.
void testWithdrawCredentialDepositPreauth(FeatureBitset features)
Shared base for the Vault*_test family under src/test/app/vault/.
FeatureBitset const all_
test::jtx::PrettyAsset PrettyAsset
Keylet computation functions.
Definition Indexes.h:39
Keylet mptoken(MPTID const &issuanceID, AccountID const &holder) noexcept
Definition Indexes.cpp:547
Keylet account(AccountID const &id) noexcept
AccountID root.
Definition Indexes.cpp:233
Keylet mptokenIssuance(MPTID const &issuanceID) noexcept
Definition Indexes.cpp:541
Use hash_* containers for keys that do not need a cryptographically secure hashing algorithm.
Definition algorithm.h:5
Issue const & xrpIssue()
Returns an asset specifier that represents XRP.
Definition Issue.h:108
std::string to_string(BaseUInt< Bits, Tag > const &a)
Definition base_uint.h:658
@ temMALFORMED
Definition TER.h:75
@ temDISABLED
Definition TER.h:102
TERSubset< CanCvtToTER > TER
Definition TER.h:657
@ tecOBJECT_NOT_FOUND
Definition TER.h:337
@ tecNO_AUTH
Definition TER.h:311
@ tecBAD_CREDENTIALS
Definition TER.h:370
@ tecUNFUNDED_OFFER
Definition TER.h:295
@ tecEXPIRED
Definition TER.h:325
@ tecNO_PERMISSION
Definition TER.h:316
BEAST_DEFINE_TESTSUITE(AccountTxPaging, app, xrpl)
@ tesSUCCESS
Definition TER.h:253