64 Env env{*
this, testableAmendments()};
67 Account const depositor{
"depositor"};
68 env.fund(XRP(1000), issuer, owner, depositor);
71 Vault const vault{env};
73 env.trust(asset(1000), owner);
74 env(pay(issuer, owner, asset(100)));
75 env.trust(asset(1000), depositor);
76 env(pay(issuer, depositor, asset(100)));
79 auto [tx,
keylet] = vault.create({.owner = owner, .asset = asset});
80 tx[sfFlags] = tfVaultShareNonTransferable;
85 testcase(
"nontransferable deposits");
87 vault.deposit({.depositor = depositor, .id =
keylet.key, .amount = asset(40)});
91 vault.deposit({.depositor = owner, .id =
keylet.key, .amount = asset(60)});
96 auto const vaultAccount =
98 auto jvVault = env.rpc(
"vault_info",
strHex(key));
100 BEAST_EXPECT(jvVault[jss::result][jss::vault][sfAssetsTotal] ==
"100");
102 jvVault[jss::result][jss::vault][jss::shares][sfOutstandingAmount] ==
"100000000");
109 auto const mptId =
makeMptID(1, vaultAccount);
110 Asset const shares = mptId;
113 testcase(
"nontransferable shares cannot be moved");
114 env(pay(owner, depositor, shares(10)), Ter{
tecNO_AUTH});
115 env(pay(depositor, owner, shares(10)), Ter{
tecNO_AUTH});
119 testcase(
"nontransferable shares can be used to withdraw");
121 vault.withdraw({.depositor = depositor, .id =
keylet.key, .amount = asset(20)});
125 vault.withdraw({.depositor = owner, .id =
keylet.key, .amount = asset(30)});
131 testcase(
"nontransferable shares balance check");
132 auto jvVault = env.rpc(
"vault_info",
strHex(
keylet.key));
133 BEAST_EXPECT(jvVault[jss::result][jss::vault][sfAssetsTotal] ==
"50");
135 jvVault[jss::result][jss::vault][jss::shares][sfOutstandingAmount] ==
"50000000");
139 testcase(
"nontransferable shares withdraw rest");
141 vault.withdraw({.depositor = depositor, .id =
keylet.key, .amount = asset(20)});
145 vault.withdraw({.depositor = owner, .id =
keylet.key, .amount = asset(30)});
151 testcase(
"nontransferable shares delete empty vault");
152 auto const tx = vault.del({.owner = owner, .id =
keylet.key});
154 BEAST_EXPECT(!env.le(
keylet));
188 testcase(
"removeEmptyHolding deletes MPToken with sfLockedAmount");
192 auto const amendments = testableAmendments();
195 auto const baseFee = env.current()->fees().base;
197 Account const issuer{
"issuer"};
199 Account const depositor{
"depositor"};
202 env.fund(XRP(100000), issuer, owner, depositor, bob);
205 Vault const vault{env};
208 MPTTester mptt{env, issuer, kMptInitNoFund};
209 mptt.create({.flags = tfMPTCanTransfer | tfMPTCanLock});
211 mptt.authorize({.account = owner});
212 mptt.authorize({.account = depositor});
213 env(pay(issuer, depositor, asset(1000)));
217 auto [tx,
keylet] = vault.create({.owner = owner, .asset = asset});
221 auto const vaultSle = env.le(
keylet);
222 BEAST_EXPECT(vaultSle !=
nullptr);
223 auto const shareMptID = vaultSle->at(sfShareMPTID);
224 MPTIssue const shareIssue{shareMptID};
227 env(vault.deposit({.depositor = depositor, .id = keylet.key, .amount = asset(1000)}));
233 BEAST_EXPECT(sleMpt !=
nullptr);
234 BEAST_EXPECT(sleMpt->at(sfMPTAmount) == 1000);
238 env(escrow::create(depositor, bob,
STAmount{shareIssue, 500}),
239 escrow::kCondition(escrow::kCb1),
240 escrow::kFinishTime(env.now() + 1s),
248 BEAST_EXPECT(sleMpt !=
nullptr);
249 BEAST_EXPECT(sleMpt->at(sfLockedAmount) == 500);
250 BEAST_EXPECT(sleMpt->at(sfMPTAmount) == 500);
254 env(vault.withdraw({.depositor = depositor, .id = keylet.key, .amount = asset(500)}),
258 auto const sleMptAfter = env.le(
keylet::mptoken(shareMptID, depositor));
259 if (!f[fixCleanup3_1_3])
264 BEAST_EXPECT(sleMptAfter ==
nullptr);
270 BEAST_EXPECT(sleMptAfter !=
nullptr);
273 BEAST_EXPECT(sleMptAfter->at(sfLockedAmount) == 500);
274 BEAST_EXPECT(sleMptAfter->at(sfMPTAmount) == 0);
279 runTest(amendments - fixCleanup3_1_3);
330 auto const readReferenceHolding = [&](Env
const& env,
332 auto const sleVault = env.le(vaultKeylet);
336 if (!sleIssuance || !sleIssuance->isFieldPresent(sfReferenceHolding))
338 return sleIssuance->getFieldH256(sfReferenceHolding);
345 testcase(
"sfReferenceHolding: MPT-backed vault, post-amendment");
346 Env env{*
this, testableAmendments()};
347 Account const issuer{
"issuer"};
349 env.fund(XRP(10'000), issuer, owner);
352 MPTTester mptt{env, issuer, kMptInitNoFund};
353 mptt.create({.flags = tfMPTCanTransfer | tfMPTCanLock});
355 mptt.authorize({.account = owner});
357 Vault const vault{env};
358 auto [tx,
keylet] = vault.create({.owner = owner, .asset = asset});
362 auto const sleVault = env.le(
keylet);
363 BEAST_EXPECT(sleVault !=
nullptr);
364 auto const pseudoId = sleVault->at(sfAccount);
367 auto const stored = readReferenceHolding(env,
keylet);
368 BEAST_EXPECT(stored.has_value());
369 BEAST_EXPECT(stored && *stored == expected);
371 BEAST_EXPECT(env.le(
keylet::mptoken(mptt.issuanceID(), pseudoId)) !=
nullptr);
375 testcase(
"sfReferenceHolding: IOU-backed vault, post-amendment");
376 Env env{*
this, testableAmendments()};
377 Account const issuer{
"issuer"};
379 env.fund(XRP(10'000), issuer, owner);
380 env(fset(issuer, asfDefaultRipple));
384 env.trust(asset(1'000'000), owner);
387 Vault const vault{env};
388 auto [tx,
keylet] = vault.create({.owner = owner, .asset = asset});
392 auto const sleVault = env.le(
keylet);
393 BEAST_EXPECT(sleVault !=
nullptr);
394 auto const pseudoId = sleVault->at(sfAccount);
397 auto const stored = readReferenceHolding(env,
keylet);
398 BEAST_EXPECT(stored.has_value());
399 BEAST_EXPECT(stored && *stored == expected);
407 testcase(
"sfReferenceHolding: XRP-backed vault, field absent");
408 Env env{*
this, testableAmendments()};
410 env.fund(XRP(10'000), owner);
414 Vault const vault{env};
415 auto [tx,
keylet] = vault.create({.owner = owner, .asset = asset});
419 BEAST_EXPECT(!readReferenceHolding(env,
keylet).has_value());
425 testcase(
"sfReferenceHolding: vault share, pre-amendment");
426 Env env{*
this, testableAmendments() - fixCleanup3_2_0};
427 Account const issuer{
"issuer"};
429 env.fund(XRP(10'000), issuer, owner);
432 MPTTester mptt{env, issuer, kMptInitNoFund};
433 mptt.create({.flags = tfMPTCanTransfer | tfMPTCanLock});
435 mptt.authorize({.account = owner});
437 Vault const vault{env};
438 auto [tx,
keylet] = vault.create({.owner = owner, .asset = asset});
442 BEAST_EXPECT(!readReferenceHolding(env,
keylet).has_value());
449 testcase(
"sfReferenceHolding: plain MPT issuance never set");
450 Env env{*
this, testableAmendments()};
451 Account const issuer{
"issuer"};
452 env.fund(XRP(10'000), issuer);
455 MPTTester mptt{env, issuer, kMptInitNoFund};
456 mptt.create({.flags = tfMPTCanTransfer | tfMPTCanLock});
460 if (BEAST_EXPECT(sleIssuance))
461 BEAST_EXPECT(!sleIssuance->isFieldPresent(sfReferenceHolding));
481 auto const referencedHoldingExists = [&](Env
const& env,
482 Keylet const& vaultKeylet) ->
bool {
483 auto const sleVault = env.le(vaultKeylet);
487 if (!sleIssuance || !sleIssuance->isFieldPresent(sfReferenceHolding))
489 auto const holdingKey = sleIssuance->getFieldH256(sfReferenceHolding);
495 testcase(
"vault pseudo MPToken: Clawback blocked by tecPSEUDO_ACCOUNT");
496 Env env{*
this, testableAmendments()};
497 Account const issuer{
"issuer"};
499 Account const depositor{
"depositor"};
500 env.fund(XRP(10'000), issuer, owner, depositor);
503 MPTTester mptt{env, issuer, kMptInitNoFund};
504 mptt.create({.flags = tfMPTCanTransfer | tfMPTCanLock | tfMPTCanClawback});
506 mptt.authorize({.account = owner});
507 mptt.authorize({.account = depositor});
508 env(pay(issuer, depositor, asset(1'000)));
511 Vault const vault{env};
512 auto [tx,
keylet] = vault.create({.owner = owner, .asset = asset});
516 env(vault.deposit({.depositor = depositor, .id = keylet.key, .amount = asset(500)}));
519 BEAST_EXPECT(referencedHoldingExists(env,
keylet));
521 Account const pseudoAccount{
"vault-pseudo", env.le(
keylet)->at(sfAccount)};
531 BEAST_EXPECT(referencedHoldingExists(env,
keylet));
533 BEAST_EXPECT(env.balance(pseudoAccount, asset).number() == 500);
537 testcase(
"vault pseudo MPToken: Issuer cannot Unauthorize pseudo");
538 Env env{*
this, testableAmendments()};
539 Account const issuer{
"issuer"};
541 env.fund(XRP(10'000), issuer, owner);
544 MPTTester mptt{env, issuer, kMptInitNoFund};
545 mptt.create({.flags = tfMPTCanTransfer | tfMPTCanLock | tfMPTRequireAuth});
547 mptt.authorize({.account = owner});
548 mptt.authorize({.account = issuer, .holder = owner});
551 Vault const vault{env};
552 auto [tx,
keylet] = vault.create({.owner = owner, .asset = asset});
556 BEAST_EXPECT(referencedHoldingExists(env,
keylet));
558 auto const pseudoId = env.le(
keylet)->at(sfAccount);
566 jv[sfAccount] = issuer.human();
568 jv[sfMPTokenIssuanceID] =
to_string(mptt.issuanceID());
569 jv[sfFlags] = tfMPTUnauthorize;
570 jv[sfTransactionType] = jss::MPTokenAuthorize;
573 BEAST_EXPECT(referencedHoldingExists(env,
keylet));
577 testcase(
"vault pseudo MPToken: MPTokenIssuanceDestroy blocked while vault holds");
578 Env env{*
this, testableAmendments()};
579 Account const issuer{
"issuer"};
581 Account const depositor{
"depositor"};
582 env.fund(XRP(10'000), issuer, owner, depositor);
585 MPTTester mptt{env, issuer, kMptInitNoFund};
586 mptt.create({.flags = tfMPTCanTransfer | tfMPTCanLock});
588 mptt.authorize({.account = owner});
589 mptt.authorize({.account = depositor});
590 env(pay(issuer, depositor, asset(1'000)));
593 Vault const vault{env};
594 auto [tx,
keylet] = vault.create({.owner = owner, .asset = asset});
598 env(vault.deposit({.depositor = depositor, .id = keylet.key, .amount = asset(500)}));
601 BEAST_EXPECT(referencedHoldingExists(env,
keylet));
610 BEAST_EXPECT(referencedHoldingExists(env,
keylet));
615 testcase(
"vault pseudo trust line: Clawback blocked by tecPSEUDO_ACCOUNT");
616 Env env{*
this, testableAmendments()};
617 Account const issuer{
"issuer"};
619 env.fund(XRP(10'000), issuer, owner);
620 env(fset(issuer, asfAllowTrustLineClawback));
624 env.trust(asset(1'000'000), owner);
625 env(pay(issuer, owner, asset(1'000)));
628 Vault const vault{env};
629 auto [tx,
keylet] = vault.create({.owner = owner, .asset = asset});
633 env(vault.deposit({.depositor = owner, .id = keylet.key, .amount = asset(500)}));
636 BEAST_EXPECT(referencedHoldingExists(env,
keylet));
638 Account const pseudoAccount{
"vault-pseudo", env.le(
keylet)->at(sfAccount)};
649 BEAST_EXPECT(referencedHoldingExists(env,
keylet));
651 BEAST_EXPECT(env.balance(pseudoAccount, asset).number() == 500);
655 testcase(
"vault pseudo trust line: TrustSet limit=0 from issuer preserves line");
656 Env env{*
this, testableAmendments()};
657 Account const issuer{
"issuer"};
659 env.fund(XRP(10'000), issuer, owner);
660 env(fset(issuer, asfDefaultRipple));
664 env.trust(asset(1'000'000), owner);
665 env(pay(issuer, owner, asset(1'000)));
668 Vault const vault{env};
669 auto [tx,
keylet] = vault.create({.owner = owner, .asset = asset});
673 env(vault.deposit({.depositor = owner, .id = keylet.key, .amount = asset(500)}));
676 BEAST_EXPECT(referencedHoldingExists(env,
keylet));
684 Account const pseudoAccount{
"vault-pseudo", env.le(
keylet)->at(sfAccount)};
685 env(trust(issuer, pseudoAccount[
"IOU"](0)));
687 BEAST_EXPECT(referencedHoldingExists(env,
keylet));
692 testcase(
"vault pseudo holding: VaultDelete is the legitimate cleanup path");
693 Env env{*
this, testableAmendments()};
694 Account const issuer{
"issuer"};
696 env.fund(XRP(10'000), issuer, owner);
699 MPTTester mptt{env, issuer, kMptInitNoFund};
700 mptt.create({.flags = tfMPTCanTransfer | tfMPTCanLock});
702 mptt.authorize({.account = owner});
704 Vault const vault{env};
705 auto [tx,
keylet] = vault.create({.owner = owner, .asset = asset});
709 BEAST_EXPECT(referencedHoldingExists(env,
keylet));
710 auto const pseudoId = env.le(
keylet)->at(sfAccount);
711 auto const sharedMptId = env.le(
keylet)->at(sfShareMPTID);
712 auto const holdingKeylet =
keylet::mptoken(mptt.issuanceID(), pseudoId);
717 env(vault.del({.owner = owner, .id = keylet.key}));
720 BEAST_EXPECT(env.le(
keylet) ==
nullptr);
721 BEAST_EXPECT(env.le(holdingKeylet) ==
nullptr);