50 Env env{*
this, testableAmendments()};
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"};
59 Vault const vault{env};
60 env.fund(XRP(1000), issuer, owner, depositor, charlie, pdOwner, credIssuer1, credIssuer2);
62 env(fset(issuer, asfAllowTrustLineClawback));
64 env.require(Flags(issuer, asfAllowTrustLineClawback));
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)));
75 auto [tx,
keylet] = vault.create({.owner = owner, .asset = asset, .flags = tfVaultPrivate});
78 BEAST_EXPECT(env.le(
keylet));
81 testcase(
"private vault owner can deposit");
83 vault.deposit({.depositor = owner, .id =
keylet.key, .amount = asset(50)});
88 testcase(
"private vault depositor not authorized yet");
90 vault.deposit({.depositor = depositor, .id =
keylet.key, .amount = asset(50)});
95 testcase(
"private vault cannot set non-existing domain");
96 auto tx = vault.set({.owner = owner, .id =
keylet.key});
102 testcase(
"private vault set domainId");
105 pdomain::Credentials
const credentials1{
106 {.issuer = credIssuer1, .credType = credType},
109 env(pdomain::setTx(pdOwner, credentials1));
110 auto const domainId1 = [&] {
112 return pdomain::getNewDomain(env.meta());
115 auto tx = vault.set({.owner = owner, .id =
keylet.key});
127 {.issuer = credIssuer1, .credType = credType},
128 {.issuer = credIssuer2, .credType = credType},
132 auto const domainId = [&] {
134 return pdomain::getNewDomain(env.meta());
137 auto tx = vault.set({.owner = owner, .id =
keylet.key});
143 tx = vault.set({.owner = owner, .id =
keylet.key});
151 testcase(
"private vault depositor still not authorized");
153 vault.deposit({.depositor = depositor, .id =
keylet.key, .amount = asset(50)});
158 auto const credKeylet = credentials::keylet(depositor, credIssuer1, credType);
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));
166 auto const credSle = env.le(credKeylet);
167 BEAST_EXPECT(credSle !=
nullptr);
170 vault.deposit({.depositor = depositor, .id =
keylet.key, .amount = asset(50)});
174 tx = vault.deposit({.depositor = charlie, .id =
keylet.key, .amount = asset(50)});
180 testcase(
"private vault depositor lost authorization");
181 env(credentials::deleteCred(credIssuer1, depositor, credIssuer1, credType));
182 env(credentials::deleteCred(credIssuer1, charlie, credIssuer1, credType));
184 auto const credSle = env.le(credKeylet);
185 BEAST_EXPECT(credSle ==
nullptr);
188 vault.deposit({.depositor = depositor, .id =
keylet.key, .amount = asset(50)});
194 auto const vault = env.le(
keylet);
195 BEAST_EXPECT(vault !=
nullptr);
196 return MPTIssue(vault->at(sfShareMPTID));
200 testcase(
"private vault expired authorization");
201 uint32_t
const closeTime =
202 env.current()->header().parentCloseTime.time_since_epoch().count();
204 auto tx0 = credentials::create(depositor, credIssuer2, credType);
205 tx0[sfExpiration] = closeTime + 20;
207 tx0 = credentials::create(charlie, credIssuer2, credType);
208 tx0[sfExpiration] = closeTime + 20;
212 env(credentials::accept(depositor, credIssuer2, credType));
213 env(credentials::accept(charlie, credIssuer2, credType));
219 vault.deposit({.depositor = depositor, .id =
keylet.key, .amount = asset(50)});
223 auto const tokenKeylet =
225 BEAST_EXPECT(env.le(tokenKeylet) !=
nullptr);
234 auto const credsKeylet = credentials::keylet(depositor, credIssuer2, credType);
235 BEAST_EXPECT(env.le(credsKeylet) !=
nullptr);
238 vault.deposit({.depositor = depositor, .id =
keylet.key, .amount = asset(1)});
242 BEAST_EXPECT(env.le(credsKeylet) ==
nullptr);
246 auto const credsKeylet = credentials::keylet(charlie, credIssuer2, credType);
247 BEAST_EXPECT(env.le(credsKeylet) !=
nullptr);
248 auto const tokenKeylet =
250 BEAST_EXPECT(env.le(tokenKeylet) ==
nullptr);
253 vault.deposit({.depositor = charlie, .id =
keylet.key, .amount = asset(2)});
257 BEAST_EXPECT(env.le(credsKeylet) ==
nullptr);
258 BEAST_EXPECT(env.le(tokenKeylet) ==
nullptr);
263 testcase(
"private vault reset domainId");
264 auto tx = vault.set({.owner = owner, .id =
keylet.key});
265 tx[sfDomainID] =
"0";
269 tx = vault.deposit({.depositor = depositor, .id =
keylet.key, .amount = asset(50)});
273 tx = vault.withdraw({.depositor = depositor, .id =
keylet.key, .amount = asset(50)});
278 {.issuer = issuer, .id =
keylet.key, .holder = depositor, .amount = asset(0)});
282 {.issuer = issuer, .id =
keylet.key, .holder = owner, .amount = asset(0)});
299 testcase(
"private vault share transfer after depositor loses domain");
315 Env env{*
this, testableAmendments()};
316 Account const issuer{
"issuer"};
318 Account const depositor{
"depositor"};
320 Account const pdOwner{
"pdOwner"};
321 Account const credIssuer{
"credIssuer"};
323 Vault const vault{env};
324 env.fund(XRP(1000), issuer, owner, depositor, bob, pdOwner, credIssuer);
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)));
338 auto [tx,
keylet] = vault.create({.owner = owner, .asset = asset, .flags = tfVaultPrivate});
342 pdomain::Credentials
const credentials{{.issuer = credIssuer, .credType = credType}};
344 auto const domainId = [&] {
346 return pdomain::getNewDomain(env.meta());
349 auto domainTx = vault.set({.owner = owner, .id =
keylet.key});
350 domainTx[sfDomainID] =
to_string(domainId);
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));
363 env(vault.deposit({.depositor = depositor, .id = keylet.key, .amount = asset(100)}));
364 env(vault.deposit({.depositor = bob, .id = keylet.key, .amount = asset(100)}));
368 auto const sle = env.le(
keylet);
369 BEAST_EXPECT(sle !=
nullptr);
370 return MPTIssue(sle->at(sfShareMPTID));
374 auto const credKeylet = credentials::keylet(depositor, credIssuer, credType);
375 env(credentials::deleteCred(credIssuer, depositor, credIssuer, credType));
377 BEAST_EXPECT(env.le(credKeylet) ==
nullptr);
383 Account const charlie{
"charlie"};
384 env.fund(XRP(1000), charlie);
387 vault.deposit({.depositor = charlie, .id =
keylet.key, .amount = asset(1)});
393 env(pay(depositor, bob, shares(1)), Ter{
tecNO_AUTH});
401 BEAST_EXPECT(expectOffers(env, depositor, 0));
409 testcase(
"private vault share purchase via DEX requires buyer domain membership");
415 Env env{*
this, testableAmendments()};
416 Account const issuer{
"issuer"};
419 Account const charlie{
"charlie"};
420 Account const pdOwner{
"pdOwner"};
421 Account const credIssuer{
"credIssuer"};
423 Vault const vault{env};
424 env.fund(XRP(1000), issuer, owner, bob, charlie, pdOwner, credIssuer);
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)));
434 auto [tx,
keylet] = vault.create({.owner = owner, .asset = asset, .flags = tfVaultPrivate});
438 pdomain::Credentials
const credentials{{.issuer = credIssuer, .credType = credType}};
440 auto const domainId = [&] {
442 return pdomain::getNewDomain(env.meta());
445 auto domainTx = vault.set({.owner = owner, .id =
keylet.key});
446 domainTx[sfDomainID] =
to_string(domainId);
452 env(credentials::create(bob, credIssuer, credType));
453 env(credentials::accept(bob, credIssuer, credType));
455 env(vault.deposit({.depositor = bob, .id = keylet.key, .amount = asset(100)}));
459 auto const sle = env.le(
keylet);
460 BEAST_EXPECT(sle !=
nullptr);
461 return MPTIssue(sle->at(sfShareMPTID));
465 env(offer(bob, XRP(1), shares(1)));
467 BEAST_EXPECT(expectOffers(env, bob, 1));
474 env(offer(charlie, shares(1), XRP(1)), Ter{
tecNO_AUTH});
476 BEAST_EXPECT(expectOffers(env, bob, 1));
477 BEAST_EXPECT(expectOffers(env, charlie, 0));
487 Env env{*
this, testableAmendments()};
489 Account const depositor{
"depositor"};
490 Account const alice{
"charlie"};
492 Vault const vault{env};
493 env.fund(XRP(100000), owner, depositor, alice);
497 auto [tx,
keylet] = vault.create({.owner = owner, .asset = asset, .flags = tfVaultPrivate});
501 auto const [vaultAccount, issuanceId] =
503 auto const vault = env.le(
keylet);
504 BEAST_EXPECT(vault !=
nullptr);
505 return {vault->at(sfAccount), vault->at(sfShareMPTID)};
512 testcase(
"private XRP vault owner can deposit");
514 vault.deposit({.depositor = owner, .id =
keylet.key, .amount = asset(50)});
520 testcase(
"private XRP vault cannot pay shares to depositor yet");
521 env(pay(owner, depositor, shares(1)), Ter{
tecNO_AUTH});
525 testcase(
"private XRP vault depositor not authorized yet");
527 vault.deposit({.depositor = depositor, .id =
keylet.key, .amount = asset(50)});
532 testcase(
"private XRP vault set DomainID");
533 pdomain::Credentials
const credentials{{.issuer = owner, .credType = credType}};
536 auto const domainId = [&] {
538 return pdomain::getNewDomain(env.meta());
541 auto tx = vault.set({.owner = owner, .id =
keylet.key});
547 auto const credKeylet = credentials::keylet(depositor, owner, credType);
549 testcase(
"private XRP vault depositor now authorized");
550 env(credentials::create(depositor, owner, credType));
551 env(credentials::accept(depositor, owner, credType));
554 BEAST_EXPECT(env.le(credKeylet));
556 vault.deposit({.depositor = depositor, .id =
keylet.key, .amount = asset(50)});
562 testcase(
"private XRP vault can pay shares to depositor");
563 env(pay(owner, depositor, shares(1)));
567 testcase(
"private XRP vault cannot pay shares to 3rd party");
569 jv[sfAccount] = alice.human();
570 jv[sfTransactionType] = jss::MPTokenAuthorize;
571 jv[sfMPTokenIssuanceID] =
to_string(issuanceId);
575 env(pay(owner, alice, shares(1)), Ter{
tecNO_AUTH});
589 bool const withFix = features[fixCleanup3_4_0];
591 std::string{
"VaultWithdraw private vault destination domain check"} +
592 (withFix ?
" (fixCleanup3_4_0)" :
" (pre-fix)"));
594 Account const issuer{
"issuer"};
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"};
603 Env env{*
this, features};
604 Vault const vault{env};
607 XRP(100'000), issuer, owner, depositor, beneficiary, outsider, pdOwner, credIssuer);
613 for (
auto const& account : {owner, depositor, beneficiary, outsider})
615 env.trust(asset(1'000'000), account);
616 env(pay(issuer, account, asset(10'000)));
620 auto const domainId = [&] {
621 pdomain::Credentials
const credentials{{.issuer = credIssuer, .credType = credType}};
624 return pdomain::getNewDomain(env.meta());
627 auto const joinDomain = [&](
Account const& account) {
628 env(credentials::create(account, credIssuer, credType));
629 env(credentials::accept(account, credIssuer, credType));
632 joinDomain(depositor);
633 joinDomain(beneficiary);
636 vault.create({.owner = owner, .asset = asset, .flags = tfVaultPrivate});
641 auto tx = vault.set({.owner = owner, .id =
keylet.key});
647 env(vault.deposit({.depositor = depositor, .id = keylet.key, .amount = asset(1'000)}));
652 vault.withdraw({.depositor = depositor, .id =
keylet.key, .amount = asset(1)});
653 tx[sfDestination] = destination.human();
659 env(withdrawTo(beneficiary));
672 env(withdrawTo(issuer));
685 env(vault.withdraw({.depositor = depositor, .id = keylet.key, .amount = asset(1)}));
691 env(withdrawTo(depositor));
697 std::string{
"VaultWithdraw private vault submitter lost vault access"} +
698 (withFix ?
" (fixCleanup3_4_0)" :
" (pre-fix)"));
700 env(credentials::deleteCred(credIssuer, depositor, credIssuer, credType));
705 env(vault.withdraw({.depositor = depositor, .id = keylet.key, .amount = asset(1)}));
714 env(withdrawTo(issuer));
720 std::string{
"VaultWithdraw private vault with no domain set"} +
721 (withFix ?
" (fixCleanup3_4_0)" :
" (pre-fix)"));
725 env(credentials::create(depositor, credIssuer, credType));
726 env(credentials::accept(depositor, credIssuer, credType));
729 auto tx = vault.set({.owner = owner, .id =
keylet.key});
730 tx[sfDomainID] =
"0";
741 env(vault.withdraw({.depositor = depositor, .id = keylet.key, .amount = asset(1)}));
744 env(withdrawTo(issuer));
750 std::string{
"VaultWithdraw public vault destination unaffected"} +
751 (withFix ?
" (fixCleanup3_4_0)" :
" (pre-fix)"));
753 auto [publicTx, publicKeylet] = vault.create({.owner = owner, .asset = asset});
757 env(vault.deposit({.depositor = owner, .id = publicKeylet.key, .amount = asset(100)}));
761 vault.withdraw({.depositor = owner, .id = publicKeylet.key, .amount = asset(1)});
762 tx[sfDestination] = outsider.human();
772 "withdraw with credential-based deposit preauth " +
773 std::string{features[fixCleanup3_4_0] ?
"post-fix" :
"pre-fix"});
775 using namespace std::chrono_literals;
777 bool const fixEnabled = features[fixCleanup3_4_0];
779 Env env{*
this, features};
782 Account const depositor{
"depositor"};
784 Account const credIssuer{
"credIssuer"};
785 char const credType[] =
"abcde";
787 env.fund(XRP(1000), owner, depositor, dest, credIssuer);
788 env(fset(dest, asfDepositAuth));
793 auto [tx,
keylet] = vault.create({.owner = owner, .asset = asset});
797 env(vault.deposit({.depositor = depositor, .id = keylet.key, .amount = asset(100)}));
800 auto const withdrawToDest = [&] {
802 vault.withdraw({.depositor = depositor, .id =
keylet.key, .amount = asset(10)});
803 wtx[sfDestination] = dest.human();
812 auto jv = credentials::create(depositor, credIssuer, credType);
814 env.current()->header().parentCloseTime.time_since_epoch().count() + 100;
815 jv[sfExpiration.jsonName] = expiration;
817 env(credentials::accept(depositor, credIssuer, credType));
820 auto const credKeylet = credentials::keylet(depositor, credIssuer, credType);
822 credentials::ledgerEntry(env, depositor, credIssuer, credType)[jss::result][jss::index]
826 env(deposit::authCredentials(dest, {{.issuer = credIssuer, .credType = credType}}));
836 env(withdrawToDest(), credentials::Ids({credIdx}), Ter{
temDISABLED});
842 env(withdrawToDest(), credentials::Ids({credIdx}));
847 "0E0B04ED60588A758B67E21FBBE95AC5A63598BA951761DC0EC9C08D7E01E034";
852 env(withdrawToDest(), credentials::Ids({credIdx, credIdx}), Ter{
temMALFORMED});
856 char const credType2[] =
"fghij";
857 env(credentials::create(depositor, credIssuer, credType2));
858 env(credentials::accept(depositor, credIssuer, credType2));
860 auto const credIdx2 =
861 credentials::ledgerEntry(env, depositor, credIssuer, credType2)[jss::result][jss::index]
868 BEAST_EXPECT(env.le(credKeylet));
869 env(withdrawToDest(), credentials::Ids({credIdx}), Ter{
tecEXPIRED});
871 BEAST_EXPECT(!env.le(credKeylet));