60 auto const testCase = [&,
this](
68 Env env{*
this, args.features};
72 env.fund(XRP(1000), issuer, owner);
75 env(fset(issuer, asfAllowTrustLineClawback));
76 env(fset(issuer, asfRequireAuth));
80 env(trust(owner, asset(1000)));
81 env(trust(issuer, asset(0), owner, tfSetfAuth));
82 env(pay(issuer, owner, asset(1000)));
85 test(env, issuer, owner, asset, vault);
88 auto const testDisabled = [&](
TER resultAfterCreate =
temDISABLED) {
89 return [&, resultAfterCreate](
95 testcase(
"disabled single asset vault");
97 auto [tx,
keylet] = vault.create({.owner = owner, .asset = asset});
101 auto const tx = vault.set({.owner = owner, .id =
keylet.key});
102 env(tx, kData(
"test"), Ter{resultAfterCreate});
107 vault.deposit({.depositor = owner, .id =
keylet.key, .amount = asset(10)});
108 env(tx, Ter{resultAfterCreate});
113 vault.withdraw({.depositor = owner, .id =
keylet.key, .amount = asset(10)});
114 env(tx, Ter{resultAfterCreate});
118 auto const tx = vault.clawback(
119 {.issuer = issuer, .id =
keylet.key, .holder = owner, .amount = asset(10)});
120 env(tx, Ter{resultAfterCreate});
124 auto const tx = vault.del({.owner = owner, .id =
keylet.key});
125 env(tx, Ter{resultAfterCreate});
130 testCase(testDisabled(), {.features = testableAmendments() - featureSingleAssetVault});
132 testCase(testDisabled(
tecNO_ENTRY), {.features = testableAmendments() - featureMPTokensV1});
140 testcase(
"disabled permissioned domains");
142 auto [tx,
keylet] = vault.create({.owner = owner, .asset = asset});
145 tx[sfFlags] = tx[sfFlags].asUInt() | tfVaultPrivate;
150 auto tx = vault.set({.owner = owner, .id =
keylet.key});
151 env(tx, kData(
"Test"));
157 {.features = testableAmendments() - featurePermissionedDomains});
159 testCase([&](Env& env,
166 auto [tx,
keylet] = vault.create({.owner = owner, .asset = asset});
167 tx[sfFlags] = tfClearDeepFreeze;
171 auto tx = vault.set({.owner = owner, .id =
keylet.key});
172 tx[sfFlags] = tfClearDeepFreeze;
178 vault.deposit({.depositor = owner, .id =
keylet.key, .amount = asset(10)});
179 tx[sfFlags] = tfClearDeepFreeze;
185 vault.withdraw({.depositor = owner, .id =
keylet.key, .amount = asset(10)});
186 tx[sfFlags] = tfClearDeepFreeze;
191 auto tx = vault.clawback(
192 {.issuer = issuer, .id =
keylet.key, .holder = owner, .amount = asset(10)});
193 tx[sfFlags] = tfClearDeepFreeze;
198 auto tx = vault.del({.owner = owner, .id =
keylet.key});
199 tx[sfFlags] = tfClearDeepFreeze;
204 testCase([&](Env& env,
211 auto [tx,
keylet] = vault.create({.owner = owner, .asset = asset});
216 auto tx = vault.set({.owner = owner, .id =
keylet.key});
223 vault.deposit({.depositor = owner, .id =
keylet.key, .amount = asset(10)});
230 vault.withdraw({.depositor = owner, .id =
keylet.key, .amount = asset(10)});
236 auto tx = vault.clawback(
237 {.issuer = issuer, .id =
keylet.key, .holder = owner, .amount = asset(10)});
243 auto tx = vault.del({.owner = owner, .id =
keylet.key});
251 testcase(
"disabled permissioned domain");
253 auto [tx,
keylet] = vault.create({.owner = owner, .asset =
xrpIssue()});
258 auto tx = vault.set({.owner = owner, .id =
keylet.key});
264 auto tx = vault.set({.owner = owner, .id =
keylet.key});
265 tx[sfDomainID] =
"0";
269 {.features = testableAmendments() - featurePermissionedDomains});
271 testCase([&](Env& env,
278 auto [tx,
keylet] = vault.create({.owner = owner, .asset =
xrpIssue()});
281 auto const tx = vault.set({
290 vault.deposit({.depositor = owner, .id =
beast::kZero, .amount = asset(10)});
296 vault.withdraw({.depositor = owner, .id =
beast::kZero, .amount = asset(10)});
301 auto const tx = vault.clawback(
302 {.issuer = issuer, .id =
beast::kZero, .holder = owner, .amount = asset(10)});
307 auto const tx = vault.del({
317 testcase(
"withdraw to bad destination");
319 auto [tx,
keylet] = vault.create({.owner = owner, .asset = asset});
323 vault.withdraw({.depositor = owner, .id =
keylet.key, .amount = asset(10)});
324 tx[jss::Destination] =
"0";
334 auto [tx,
keylet] = vault.create({.owner = owner, .asset = asset});
340 auto [tx,
keylet] = vault.create({.owner = owner, .asset = asset});
347 auto [tx,
keylet] = vault.create({.owner = owner, .asset = asset});
351 auto const sleVault = env.le(
keylet);
352 BEAST_EXPECT(sleVault);
353 BEAST_EXPECT((*sleVault)[sfScale] == 18);
357 auto [tx,
keylet] = vault.create({.owner = owner, .asset = asset});
361 auto const sleVault = env.le(
keylet);
362 BEAST_EXPECT(sleVault);
363 BEAST_EXPECT((*sleVault)[sfScale] == 0);
367 auto [tx,
keylet] = vault.create({.owner = owner, .asset = asset});
370 auto const sleVault = env.le(
keylet);
371 BEAST_EXPECT(sleVault);
372 BEAST_EXPECT((*sleVault)[sfScale] == 6);
375 {.features = testableAmendments() - featureLendingProtocolV1_2});
379 testcase(
"create or set invalid data");
381 auto [tx1,
keylet] = vault.create({.owner = owner, .asset = asset});
397 auto tx = vault.set({.owner = owner, .id =
keylet.key});
403 auto tx = vault.set({.owner = owner, .id =
keylet.key});
414 auto [tx,
keylet] = vault.create({.owner = owner, .asset = asset});
417 auto const tx = vault.set({.owner = owner, .id =
keylet.key});
424 testcase(
"create with invalid metadata");
426 auto [tx1,
keylet] = vault.create({.owner = owner, .asset = asset});
430 tx[sfMPTokenMetadata] =
"";
447 auto [tx,
keylet] = vault.create({.owner = owner, .asset = asset});
450 auto tx = vault.set({.owner = owner, .id =
keylet.key});
460 auto [tx,
keylet] = vault.create({.owner = owner, .asset = asset});
463 auto const tx = vault.deposit(
470 vault.deposit({.depositor = owner, .id =
keylet.key, .amount = asset(0)});
477 testcase(
"invalid set immutable flag");
479 auto [tx,
keylet] = vault.create({.owner = owner, .asset = asset});
482 auto tx = vault.set({.owner = owner, .id =
keylet.key});
483 tx[sfFlags] = tfVaultPrivate;
490 testcase(
"invalid withdraw amount");
492 auto [tx,
keylet] = vault.create({.owner = owner, .asset = asset});
495 auto const tx = vault.withdraw(
502 vault.withdraw({.depositor = owner, .id =
keylet.key, .amount = asset(0)});
507 testCase([&](Env& env,
514 auto [tx,
keylet] = vault.create({.owner = owner, .asset = asset});
519 auto const tx = vault.clawback(
520 {.issuer = issuer, .id =
keylet.key, .holder = owner, .amount = asset(50)});
525 auto const tx = vault.clawback({
539 auto [tx1,
keylet] = vault.create({.owner = owner, .asset = asset});
543 tx[sfWithdrawalPolicy] = 0;
561 tx[sfFlags] = tfVaultPrivate;
562 tx[sfDomainID] =
"0";
574 auto const testCase = [
this](
582 Env env{*
this, testableAmendments()};
583 Account const issuer{
"issuer"};
585 Account const depositor{
"depositor"};
587 env.fund(XRP(1000), issuer, owner, depositor);
592 test(env, issuer, owner, depositor, asset, vault);
604 tx[sfAssetsMaximum] = asset(0).number();
616 auto const tx = vault.deposit(
617 {.depositor = depositor, .id =
keylet::skip().
key, .amount = asset(10)});
628 testcase(
"nothing to withdraw from");
629 auto const tx = vault.withdraw(
630 {.depositor = depositor, .id =
keylet::skip().
key, .amount = asset(10)});
653 auto [tx,
keylet] = vault.create({.owner = owner, .asset = asset});
665 auto [tx,
keylet] = vault.create({.owner = owner, .asset = asset});
666 tx[sfWithdrawalPolicy] = 1;
667 testcase(
"explicitly select withdrawal policy");
678 auto [tx,
keylet] = vault.create({.owner = owner, .asset = asset});
680 env(tx, Fee(env.current()->fees().base - 1), Ter(
telINSUF_FEE_P));
690 auto [tx,
keylet] = vault.create({.owner = owner, .asset = asset});
694 env(pay(owner, issuer, XRP(775)));
706 auto [tx,
keylet] = vault.create({.owner = owner, .asset = asset});
707 tx[sfFlags] = tfVaultPrivate;
721 auto [tx,
keylet] = vault.create({.owner = owner, .asset = asset});
734 auto [tx,
keylet] = vault.create({.owner = owner, .asset = asset});
746 testcase(
"IOU fail because MPT is disabled");
747 Env env{*
this, (testableAmendments() - featureMPTokensV1)};
748 Account const issuer{
"issuer"};
750 env.fund(XRP(1000), issuer, owner);
753 Vault const vault{env};
754 Asset const asset = issuer[
"IOU"].asset();
755 auto [tx,
keylet] = vault.create({.owner = owner, .asset = asset});
763 Env env{*
this, testableAmendments()};
764 Account const issuer{
"issuer"};
766 env.fund(XRP(1000), issuer, owner);
768 env(fset(issuer, asfGlobalFreeze));
771 Vault const vault{env};
772 Asset const asset = issuer[
"IOU"].asset();
773 auto [tx,
keylet] = vault.create({.owner = owner, .asset = asset});
780 testcase(
"IOU fail create no ripling");
781 Env env{*
this, testableAmendments()};
782 Account const issuer{
"issuer"};
784 env.fund(XRP(1000), issuer, owner);
786 env(fclear(issuer, asfDefaultRipple));
789 Vault const vault{env};
790 Asset const asset = issuer[
"IOU"].asset();
791 auto [tx,
keylet] = vault.create({.owner = owner, .asset = asset});
798 Env env{*
this, testableAmendments()};
799 Account const issuer{
"issuer"};
801 env.fund(XRP(1000), owner);
804 Vault const vault{env};
805 Asset const asset = issuer[
"IOU"].asset();
807 auto [tx,
keylet] = vault.create({.owner = owner, .asset = asset});
815 testcase(
"IOU fail create vault for AMM LPToken");
816 Env env{*
this, testableAmendments()};
820 IOU
const usd = gw[
"USD"];
826 auto const defXRP = XRP(30000);
829 return a + XRP(1000);
831 auto defIOU =
STAmount{a.asset(), 30000};
834 return a +
STAmount{a.asset(), 1000};
836 auto const toFund1 = toFund(asset1);
837 auto const toFund2 = toFund(asset2);
838 BEAST_EXPECT(asset1 <= toFund1 && asset2 <= toFund2);
840 if (!asset1.native() && !asset2.native())
842 fund(env, gw, {alice, carol}, {toFund1, toFund2}, Fund::All);
844 else if (asset1.native())
846 fund(env, gw, {alice, carol}, toFund1, {toFund2}, Fund::All);
848 else if (asset2.native())
850 fund(env, gw, {alice, carol}, toFund2, {toFund1}, Fund::All);
853 AMM
const ammAlice(env, alice, asset1, asset2, CreateArg{.log =
false, .tfee = 0});
856 env.fund(XRP(1000000), owner);
858 Vault const vault{env};
859 auto [tx, k] = vault.create({.owner = owner, .asset = ammAlice.lptIssue()});
1089 bool const withFix = features[fixCleanup3_4_0];
1091 std::string{
"VaultWithdraw pseudo-account destination"} +
1092 (withFix ?
" (fixCleanup3_4_0)" :
" (pre-fix)"));
1094 Account const issuer{
"issuer"};
1096 Account const depositor{
"depositor"};
1097 Account const pdOwner{
"pdOwner"};
1098 Account const credIssuer{
"credIssuer"};
1101 Env env{*
this, features};
1102 Vault const vault{env};
1104 env.fund(XRP(100'000), issuer, owner, depositor, pdOwner, credIssuer);
1107 env(fset(issuer, asfDefaultRipple));
1111 for (
auto const& account : {owner, depositor})
1113 env.trust(asset(1'000'000), account);
1114 env(pay(issuer, account, asset(10'000)));
1121 auto const pseudoDestination = [&] {
1122 auto [tx,
keylet] = vault.create({.owner = owner, .asset = asset});
1125 return Account(
"otherVault", env.le(
keylet)->at(sfAccount));
1130 auto const withdrawToPseudo = [&](
UInt256 const& vaultId) {
1131 auto tx = vault.withdraw({.depositor = depositor, .id = vaultId, .amount = asset(1)});
1132 tx[sfDestination] = pseudoDestination.human();
1137 auto [createTx,
keylet] = vault.create({.owner = owner, .asset = asset});
1141 env(vault.deposit({.depositor = depositor, .id = keylet.key, .amount = asset(1'000)}));
1144 env(withdrawToPseudo(
keylet.key), Ter(expected));
1148 env(vault.withdraw({.depositor = depositor, .id = keylet.key, .amount = asset(1)}));
1153 auto const domainId = [&] {
1155 {.issuer = credIssuer, .credType = credType},
1159 return pdomain::getNewDomain(env.meta());
1162 env(credentials::create(depositor, credIssuer, credType));
1163 env(credentials::accept(depositor, credIssuer, credType));
1166 auto [createTx,
keylet] =
1167 vault.create({.owner = owner, .asset = asset, .flags = tfVaultPrivate});
1171 auto setTx = vault.set({.owner = owner, .id =
keylet.key});
1172 setTx[sfDomainID] =
to_string(domainId);
1176 env(vault.deposit({.depositor = depositor, .id = keylet.key, .amount = asset(1'000)}));
1181 env(withdrawToPseudo(
keylet.key), Ter(expected));