93 Account const depositor{
"depositor"};
94 Account const charlie{
"charlie"};
97 auto const testSequence = [&,
this](
102 auto [tx,
keylet] = vault.create({.owner = owner, .asset = asset});
103 tx[sfData] =
"AFEED00E";
104 tx[sfAssetsMaximum] = asset(100).number();
107 BEAST_EXPECT(env.le(
keylet));
110 auto const [share, vaultAccount] =
112 auto const vault = env.le(
keylet);
113 BEAST_EXPECT(vault !=
nullptr);
114 if (!asset.integral())
116 BEAST_EXPECT(vault->at(sfScale) == 6);
120 BEAST_EXPECT(vault->at(sfScale) == 0);
123 BEAST_EXPECT(shares !=
nullptr);
124 if (!asset.integral())
126 BEAST_EXPECT(shares->at(sfAssetScale) == 6);
130 BEAST_EXPECT(shares->at(sfAssetScale) == 0);
132 return {
MPTIssue(vault->at(sfShareMPTID)),
Account(
"vault", vault->at(sfAccount))};
134 auto const shares = share.raw().get<
MPTIssue>();
135 env.memoize(vaultAccount);
140 env.fund(XRP(1000), alice, erin);
141 env(fset(alice, asfDepositAuth));
145 testcase(prefix +
" fail to deposit more than assets held");
146 auto const tx = vault.deposit(
147 {.depositor = depositor, .id =
keylet.key, .amount = asset(10000)});
153 testcase(prefix +
" deposit non-zero amount");
155 vault.deposit({.depositor = depositor, .id =
keylet.key, .amount = asset(50)});
158 BEAST_EXPECT(env.balance(depositor, shares) == share(50 *
scale));
162 testcase(prefix +
" deposit non-zero amount again");
164 vault.deposit({.depositor = depositor, .id =
keylet.key, .amount = asset(50)});
167 BEAST_EXPECT(env.balance(depositor, shares) == share(100 *
scale));
171 testcase(prefix +
" fail to delete non-empty vault");
172 auto const tx = vault.del({.owner = owner, .id =
keylet.key});
178 testcase(prefix +
" fail to update because wrong owner");
179 auto tx = vault.set({.owner = issuer, .id =
keylet.key});
180 tx[sfAssetsMaximum] = asset(50).number();
186 testcase(prefix +
" fail to set maximum lower than current amount");
187 auto tx = vault.set({.owner = owner, .id =
keylet.key});
188 tx[sfAssetsMaximum] = asset(50).number();
194 testcase(prefix +
" set maximum higher than current amount");
195 auto tx = vault.set({.owner = owner, .id =
keylet.key});
196 tx[sfAssetsMaximum] = asset(150).number();
202 testcase(prefix +
" set maximum is idempotent, set it again");
203 auto tx = vault.set({.owner = owner, .id =
keylet.key});
204 tx[sfAssetsMaximum] = asset(150).number();
211 auto tx = vault.set({.owner = owner, .id =
keylet.key});
218 testcase(prefix +
" fail to set domain on public vault");
219 auto tx = vault.set({.owner = owner, .id =
keylet.key});
226 testcase(prefix +
" fail to deposit more than maximum");
228 vault.deposit({.depositor = depositor, .id =
keylet.key, .amount = asset(100)});
234 testcase(prefix +
" reset maximum to zero i.e. not enforced");
235 auto tx = vault.set({.owner = owner, .id =
keylet.key});
236 tx[sfAssetsMaximum] = asset(0).number();
242 testcase(prefix +
" fail to withdraw more than assets held");
243 auto const tx = vault.withdraw(
244 {.depositor = depositor, .id =
keylet.key, .amount = asset(1000)});
250 testcase(prefix +
" deposit some more");
252 vault.deposit({.depositor = depositor, .id =
keylet.key, .amount = asset(100)});
255 BEAST_EXPECT(env.balance(depositor, shares) == share(200 *
scale));
259 testcase(prefix +
" clawback some");
261 auto const tx = vault.clawback(
262 {.issuer = issuer, .id =
keylet.key, .holder = depositor, .amount = asset(10)});
265 if (!asset.raw().native())
267 BEAST_EXPECT(env.balance(depositor, shares) == share(190 *
scale));
275 vault.clawback({.issuer = issuer, .id =
keylet.key, .holder = depositor});
278 if (!asset.raw().native())
280 BEAST_EXPECT(env.balance(depositor, shares) == share(0));
283 auto const tx = vault.clawback({
294 auto const tx = vault.withdraw(
295 {.depositor = depositor, .id =
keylet.key, .amount = asset(10)});
302 if (!asset.raw().native())
304 testcase(prefix +
" deposit again");
306 vault.deposit({.depositor = depositor, .id =
keylet.key, .amount = asset(200)});
309 BEAST_EXPECT(env.balance(depositor, shares) == share(200 *
scale));
313 testcase(prefix +
" deposit/withdrawal same or less than fee");
314 auto const amount = env.current()->fees().base;
317 vault.deposit({.depositor = depositor, .id =
keylet.key, .amount = amount});
321 tx = vault.withdraw({.depositor = depositor, .id =
keylet.key, .amount = amount});
325 tx = vault.deposit({.depositor = depositor, .id =
keylet.key, .amount = amount});
330 tx = vault.withdraw({.depositor = depositor, .id =
keylet.key, .amount = amount});
331 tx[sfDestination] = charlie.human();
336 vault.deposit({.depositor = depositor, .id =
keylet.key, .amount = amount - 1});
341 {.depositor = depositor, .id =
keylet.key, .amount = amount - 1});
347 testcase(prefix +
" fail to withdraw to 3rd party lsfDepositAuth");
348 auto tx = vault.withdraw(
349 {.depositor = depositor, .id =
keylet.key, .amount = asset(100)});
350 tx[sfDestination] = alice.human();
356 testcase(prefix +
" fail to withdraw to zero destination");
357 auto tx = vault.withdraw(
358 {.depositor = depositor, .id =
keylet.key, .amount = asset(1000)});
359 tx[sfDestination] =
"0";
364 if (!asset.raw().native())
366 testcase(prefix +
" fail to withdraw to 3rd party no authorization");
367 auto tx = vault.withdraw(
368 {.depositor = depositor, .id =
keylet.key, .amount = asset(100)});
369 tx[sfDestination] = erin.human();
375 testcase(prefix +
" fail to withdraw to 3rd party lsfRequireDestTag");
376 auto tx = vault.withdraw(
377 {.depositor = depositor, .id =
keylet.key, .amount = asset(100)});
378 tx[sfDestination] = dave.human();
384 testcase(prefix +
" withdraw to 3rd party lsfRequireDestTag");
386 vault.withdraw({.depositor = depositor, .id =
keylet.key, .amount = asset(50)});
387 tx[sfDestination] = dave.human();
388 tx[sfDestinationTag] =
"0";
394 testcase(prefix +
" deposit again");
396 vault.deposit({.depositor = dave, .id =
keylet.key, .amount = asset(50)});
402 testcase(prefix +
" fail to withdraw lsfRequireDestTag");
404 vault.withdraw({.depositor = dave, .id =
keylet.key, .amount = asset(50)});
410 testcase(prefix +
" withdraw with tag");
412 vault.withdraw({.depositor = dave, .id =
keylet.key, .amount = asset(50)});
413 tx[sfDestinationTag] =
"0";
419 testcase(prefix +
" withdraw to authorized 3rd party");
421 vault.withdraw({.depositor = depositor, .id =
keylet.key, .amount = asset(50)});
422 tx[sfDestination] = charlie.human();
425 BEAST_EXPECT(env.balance(depositor, shares) == share(100 *
scale));
429 testcase(prefix +
" withdraw to issuer");
431 vault.withdraw({.depositor = depositor, .id =
keylet.key, .amount = asset(50)});
432 tx[sfDestination] = issuer.human();
435 BEAST_EXPECT(env.balance(depositor, shares) == share(50 *
scale));
438 if (!asset.raw().native())
440 testcase(prefix +
" issuer deposits");
442 vault.deposit({.depositor = issuer, .id =
keylet.key, .amount = asset(10)});
445 BEAST_EXPECT(env.balance(issuer, shares) == share(10 *
scale));
447 testcase(prefix +
" issuer withdraws");
449 {.depositor = issuer, .id =
keylet.key, .amount = share(10 *
scale)});
452 BEAST_EXPECT(env.balance(issuer, shares) == share(0 *
scale));
456 testcase(prefix +
" withdraw remaining assets");
458 vault.withdraw({.depositor = depositor, .id =
keylet.key, .amount = asset(50)});
461 BEAST_EXPECT(env.balance(depositor, shares) == share(0));
463 if (!asset.raw().native())
465 auto const tx = vault.clawback({
476 auto const tx = vault.withdraw(
477 {.depositor = depositor, .id =
keylet.key, .amount = share(10)});
483 if (!asset.integral())
485 testcase(prefix +
" temporary authorization for 3rd party");
486 env(trust(erin, asset(1000)));
487 env(trust(issuer, asset(0), erin, tfSetfAuth));
488 env(pay(issuer, erin, asset(10)));
491 auto tx = vault.deposit({.depositor = erin, .id =
keylet.key, .amount = asset(10)});
495 auto const tx = pay(erin, depositor, share(10 *
scale));
503 {.depositor = depositor, .id = keylet.key, .amount = asset(1)}));
510 testcase(prefix +
" withdraw to authorized 3rd party");
513 vault.withdraw({.depositor = depositor, .id =
keylet.key, .amount = asset(10)});
514 tx[sfDestination] = erin.human();
519 env(pay(erin, issuer, asset(10)));
522 testcase(prefix +
" fail to pay to unauthorized 3rd party");
523 env(trust(erin, asset(0)));
527 env(pay(depositor, erin, share(1)), Ter{
tecNO_LINE});
531 tx = vault.withdraw({.depositor = depositor, .id =
keylet.key, .amount = asset(1)});
537 testcase(prefix +
" fail to delete because wrong owner");
538 auto const tx = vault.del({.owner = issuer, .id =
keylet.key});
544 testcase(prefix +
" delete empty vault");
545 auto const tx = vault.del({.owner = owner, .id =
keylet.key});
548 BEAST_EXPECT(!env.le(
keylet));
552 auto const testCases =
554 Env env{*
this, testableAmendments()};
557 env.fund(XRP(1000), issuer, owner, depositor, charlie, dave);
559 env(fset(issuer, asfAllowTrustLineClawback));
560 env(fset(issuer, asfRequireAuth));
561 env(fset(dave, asfRequireDest));
563 env.require(Flags(issuer, asfAllowTrustLineClawback));
564 env.require(Flags(issuer, asfRequireAuth));
567 testSequence(prefix, env, vault, asset);
572 testCases(
"IOU", [&](Env& env) ->
Asset {
574 env(trust(owner, asset(1000)));
575 env(trust(depositor, asset(1000)));
576 env(trust(charlie, asset(1000)));
577 env(trust(dave, asset(1000)));
578 env(trust(issuer, asset(0), owner, tfSetfAuth));
579 env(trust(issuer, asset(0), depositor, tfSetfAuth));
580 env(trust(issuer, asset(0), charlie, tfSetfAuth));
581 env(trust(issuer, asset(0), dave, tfSetfAuth));
582 env(pay(issuer, depositor, asset(1000)));
587 testCases(
"MPT", [&](Env& env) ->
Asset {
588 MPTTester mptt{env, issuer, kMptInitNoFund};
589 mptt.create({.flags = tfMPTCanClawback | tfMPTCanTransfer | tfMPTCanLock});
591 mptt.authorize({.account = depositor});
592 mptt.authorize({.account = charlie});
593 mptt.authorize({.account = dave});
594 env(pay(issuer, depositor, asset(1000)));
607 bool enableClawback =
true;
609 int initialXRP = 1000;
614 auto const testCase = [
this](
622 MPTTester& mptt)>
test,
623 CaseArgs args = {}) {
624 Env env{*
this, args.features};
625 Account const issuer{
"issuer"};
627 Account const depositor{
"depositor"};
628 env.fund(XRP(args.initialXRP), issuer, owner, depositor);
632 MPTTester mptt{env, issuer, kMptInitNoFund};
635 .transferFee = args.transferFee,
636 .flags = tfMPTCanTransfer | tfMPTCanLock |
637 (args.enableClawback ? tfMPTCanClawback : kNone) |
638 (args.requireAuth ? tfMPTRequireAuth : kNone),
641 mptt.authorize({.account = owner});
642 mptt.authorize({.account = depositor});
643 if (args.requireAuth)
645 mptt.authorize({.account = issuer, .holder = owner});
646 mptt.authorize({.account = issuer, .holder = depositor});
649 env(pay(issuer, depositor, asset(1000)));
652 test(env, issuer, owner, depositor, asset, vault, mptt);
656 auto const feeArgs = CaseArgs{.transferFee = 25'000};
658 auto const testTransferFeeGate = [&](
FeatureBitset const& features) {
668 bool const feeCharged = features[fixCleanup3_5_0];
670 feeCharged ?
"MPT transfer fee on third-party withdrawal"
671 :
"MPT transfer fee waived pre-fixCleanup3_5_0");
675 auto tx = vault.withdraw({
676 .depositor = depositor,
677 .id = funded.keylet.key,
678 .amount = funded.shares(100),
680 tx[sfDestination] = owner.human();
684 auto const expected = feeCharged ? 80 : 100;
685 BEAST_EXPECT(mptt.checkMPTokenAmount(depositor, 900));
686 BEAST_EXPECT(mptt.checkMPTokenAmount(owner, expected));
687 BEAST_EXPECT(mptt.checkMPTokenOutstandingAmount(900 + expected));
689 env.balance(funded.account, asset.
raw().
get<
MPTIssue>()) == asset(0));
691 env(vault.del({.owner = owner, .id = funded.keylet.key}));
694 CaseArgs{.transferFee = 25'000, .features = features});
696 testTransferFeeGate(testableAmendments() - fixCleanup3_5_0);
697 testTransferFeeGate(testableAmendments());
708 testcase(
"MPT transfer fee on fixed-asset third-party withdrawal");
712 auto const shareIssue = funded.shares.raw().get<
MPTIssue>();
714 auto tx = vault.withdraw(
715 {.depositor = depositor, .id = funded.keylet.key, .amount = asset(40)});
716 tx[sfDestination] = owner.human();
721 BEAST_EXPECT(mptt.checkMPTokenAmount(owner, 40));
722 BEAST_EXPECT(env.balance(funded.account, mptIssue) == asset(50));
723 BEAST_EXPECT(env.balance(depositor, shareIssue) == funded.shares(50));
724 BEAST_EXPECT(mptt.checkMPTokenOutstandingAmount(990));
737 testcase(
"MPT transfer fee on fixed-share third-party withdrawal");
741 auto const shareIssue = funded.shares.raw().get<
MPTIssue>();
743 auto tx = vault.withdraw(
744 {.depositor = depositor, .id = funded.keylet.key, .amount = funded.shares(25)});
745 tx[sfDestination] = owner.human();
750 BEAST_EXPECT(mptt.checkMPTokenAmount(owner, 20));
751 BEAST_EXPECT(env.balance(funded.account, mptIssue) == asset(75));
752 BEAST_EXPECT(env.balance(depositor, shareIssue) == funded.shares(75));
753 BEAST_EXPECT(mptt.checkMPTokenOutstandingAmount(995));
766 testcase(
"MPT no transfer fee on withdrawal to issuer");
770 auto const shareIssue = funded.shares.raw().get<
MPTIssue>();
772 auto tx = vault.withdraw(
773 {.depositor = depositor, .id = funded.keylet.key, .amount = asset(10)});
774 tx[sfDestination] = issuer.human();
778 BEAST_EXPECT(env.balance(funded.account, mptIssue) == asset(90));
779 BEAST_EXPECT(env.balance(depositor, shareIssue) == funded.shares(90));
780 BEAST_EXPECT(mptt.checkMPTokenOutstandingAmount(990));
793 testcase(
"MPT no transfer fee on self-withdrawal");
799 {.depositor = depositor, .id = funded.keylet.key, .amount = asset(10)}));
802 BEAST_EXPECT(mptt.checkMPTokenAmount(depositor, 910));
803 BEAST_EXPECT(env.balance(funded.account, mptIssue) == asset(90));
804 BEAST_EXPECT(mptt.checkMPTokenOutstandingAmount(1000));
817 testcase(
"MPT transfer fee must fit in the vault position");
821 auto const shareIssue = funded.shares.raw().get<
MPTIssue>();
824 auto tx = vault.withdraw(
825 {.depositor = depositor, .id = funded.keylet.key, .amount = asset(81)});
826 tx[sfDestination] = owner.human();
832 {.depositor = depositor, .id = funded.keylet.key, .amount = asset(80)});
833 tx[sfDestination] = owner.human();
837 BEAST_EXPECT(mptt.checkMPTokenAmount(owner, 80));
838 BEAST_EXPECT(env.balance(funded.account, mptIssue) == asset(0));
839 BEAST_EXPECT(env.balance(depositor, shareIssue) == funded.shares(0));
840 BEAST_EXPECT(mptt.checkMPTokenOutstandingAmount(980));
842 env(vault.del({.owner = owner, .id = funded.keylet.key}));
848 auto const testTransferFeeRoundsDown = [&](
FeatureBitset const& features) {
859 features[featureMPTokensV2]
860 ?
"MPT transfer fee rounds the payout down to zero"
861 :
"MPT transfer fee rounds the payout down to zero without "
867 auto tx = vault.withdraw({
868 .depositor = depositor,
869 .id = funded.keylet.key,
870 .amount = funded.shares(1),
872 tx[sfDestination] = owner.human();
878 .depositor = depositor,
879 .id = funded.keylet.key,
880 .amount = funded.shares(1),
884 BEAST_EXPECT(mptt.checkMPTokenAmount(depositor, 1000));
885 BEAST_EXPECT(env.balance(funded.account, mptIssue) == asset(0));
887 env(vault.del({.owner = owner, .id = funded.keylet.key}));
890 CaseArgs{.transferFee = 25'000, .features = features});
892 testTransferFeeRoundsDown(testableAmendments());
893 testTransferFeeRoundsDown(testableAmendments() - featureMPTokensV2);
904 testcase(
"MPT transfer fee leaves other depositors whole");
906 Account const charlie{
"charlie"};
907 env.fund(XRP(1000), charlie);
909 mptt.authorize({.account = charlie});
910 mptt.authorize({.account = issuer, .holder = charlie});
911 env(pay(issuer, owner, asset(100)));
916 {.depositor = owner, .id = funded.keylet.key, .amount = asset(100)}));
918 auto const shareIssue = funded.shares.raw().get<
MPTIssue>();
920 auto const vaultBefore = env.le(funded.keylet);
921 Number const assetsTotalBefore = vaultBefore->at(sfAssetsTotal);
922 Number const assetsAvailableBefore = vaultBefore->at(sfAssetsAvailable);
925 auto tx = vault.withdraw(
926 {.depositor = depositor, .id = funded.keylet.key, .amount = asset(40)});
927 tx[sfDestination] = charlie.human();
931 BEAST_EXPECT(mptt.checkMPTokenAmount(charlie, 40));
932 auto const vaultAfter = env.le(funded.keylet);
933 BEAST_EXPECT(vaultAfter->at(sfAssetsTotal) == assetsTotalBefore - 50);
934 BEAST_EXPECT(vaultAfter->at(sfAssetsAvailable) == assetsAvailableBefore - 50);
937 BEAST_EXPECT(env.balance(owner, shareIssue) == funded.shares(100));
939 {.depositor = owner, .id = funded.keylet.key, .amount = funded.shares(100)}));
941 BEAST_EXPECT(mptt.checkMPTokenAmount(owner, 100));
954 testcase(
"MPT no transfer fee on issuer withdrawal to a third party");
958 auto const shareIssue = funded.shares.raw().get<
MPTIssue>();
960 auto tx = vault.withdraw(
961 {.depositor = issuer, .id = funded.keylet.key, .amount = asset(40)});
962 tx[sfDestination] = depositor.human();
966 BEAST_EXPECT(mptt.checkMPTokenAmount(depositor, 1040));
967 BEAST_EXPECT(env.balance(funded.account, mptIssue) == asset(60));
968 BEAST_EXPECT(env.balance(issuer, shareIssue) == funded.shares(60));
969 BEAST_EXPECT(mptt.checkMPTokenOutstandingAmount(1100));
981 testcase(
"MPT nothing to clawback from");
982 auto const tx = vault.clawback({
999 testcase(
"MPT global lock blocks create");
1000 mptt.set({.account = issuer, .flags = tfMPTLock});
1001 auto [tx,
keylet] = vault.create({.owner = owner, .asset = asset});
1013 testcase(
"MPT only issuer can clawback");
1015 auto [tx,
keylet] = vault.create({.owner = owner, .asset = asset});
1019 tx = vault.deposit({.depositor = depositor, .id =
keylet.key, .amount = asset(100)});
1024 auto const tx = vault.clawback({
1025 .issuer = depositor,
1027 .holder = depositor,
1033 auto const tx = vault.clawback({
1036 .holder = depositor,
1051 testcase(
"MPT depositor without MPToken, auth required");
1053 auto [tx,
keylet] = vault.create({.owner = owner, .asset = asset});
1058 {.depositor = depositor, .id =
keylet.key, .amount = asset(1000)});
1064 mptt.authorize({.account = depositor, .flags = tfMPTUnauthorize});
1068 auto const sleMPT1 = env.le(mptoken);
1069 BEAST_EXPECT(sleMPT1 ==
nullptr);
1071 tx = vault.withdraw(
1072 {.depositor = depositor, .id =
keylet.key, .amount = asset(100)});
1076 auto const sleMPT2 = env.le(mptoken);
1077 BEAST_EXPECT(sleMPT2 ==
nullptr);
1082 Account const charlie{
"charlie"};
1083 env.fund(XRP(1000), charlie);
1086 tx = vault.withdraw(
1087 {.depositor = depositor, .id =
keylet.key, .amount = asset(100)});
1088 tx[sfDestination] = charlie.human();
1092 {.requireAuth =
true});
1103 testcase(
"MPT depositor without MPToken, no auth required");
1105 auto [tx,
keylet] = vault.create({.owner = owner, .asset = asset});
1108 auto const v = env.le(
keylet);
1111 tx = vault.deposit({
1112 .depositor = depositor,
1114 .amount = asset(1000),
1121 mptt.authorize({.account = depositor, .flags = tfMPTUnauthorize});
1125 auto const sleMPT1 = env.le(mptoken);
1126 BEAST_EXPECT(sleMPT1 ==
nullptr);
1128 tx = vault.withdraw(
1129 {.depositor = depositor, .id =
keylet.key, .amount = asset(100)});
1133 auto const sleMPT2 = env.le(mptoken);
1134 BEAST_EXPECT(sleMPT2 !=
nullptr);
1135 BEAST_EXPECT(sleMPT2->at(sfMPTAmount) == 100);
1140 mptt.authorize({.account = owner, .flags = tfMPTUnauthorize});
1144 auto const sleMPT1 = env.le(mptoken);
1145 BEAST_EXPECT(sleMPT1 ==
nullptr);
1147 tx = vault.withdraw(
1148 {.depositor = depositor, .id =
keylet.key, .amount = asset(100)});
1149 tx[sfDestination] = owner.human();
1153 auto const sleMPT2 = env.le(mptoken);
1154 BEAST_EXPECT(sleMPT2 ==
nullptr);
1157 {.requireAuth =
false});
1159 auto const redeemAllNoAssetMpt = [
this](
TER expected) {
1160 return [
this, expected](
1168 testcase <<
"MPT non-owner redeems all shares with no asset MPToken"
1169 << (
isTesSuccess(expected) ?
"" :
" pre-fixCleanup3_4_0");
1171 auto [tx,
keylet] = vault.create({.owner = owner, .asset = asset});
1175 tx = vault.deposit({
1176 .depositor = depositor,
1178 .amount = asset(1000),
1183 auto const vaultSle = env.le(
keylet);
1184 if (!BEAST_EXPECT(vaultSle))
1186 auto const shareMPTID = vaultSle->at(sfShareMPTID);
1189 mptt.authorize({.account = depositor, .flags = tfMPTUnauthorize});
1195 auto const sleShareBefore = env.le(shareKeylet);
1196 if (!BEAST_EXPECT(sleShareBefore))
1198 auto const shareAmountBefore = sleShareBefore->at(sfMPTAmount);
1199 auto const assetsTotalBefore = vaultSle->at(sfAssetsTotal);
1200 auto const assetsAvailableBefore = vaultSle->at(sfAssetsAvailable);
1204 tx = vault.withdraw(
1205 {.depositor = depositor, .id =
keylet.key, .amount = asset(1000)});
1206 env(tx, Ter{expected});
1209 auto const sleAsset = env.le(mptoken);
1210 auto const sleShare = env.le(shareKeylet);
1211 auto const vaultAfter = env.le(
keylet);
1212 if (!BEAST_EXPECT(vaultAfter))
1216 if (!BEAST_EXPECT(sleAsset))
1218 BEAST_EXPECT(sleAsset->at(sfMPTAmount) == 1000);
1219 BEAST_EXPECT(!sleShare);
1220 BEAST_EXPECT(vaultAfter->at(sfAssetsTotal) ==
beast::kZero);
1221 BEAST_EXPECT(vaultAfter->at(sfAssetsAvailable) ==
beast::kZero);
1225 BEAST_EXPECT(!sleAsset);
1226 if (!BEAST_EXPECT(sleShare))
1228 BEAST_EXPECT(sleShare->at(sfMPTAmount) == shareAmountBefore);
1229 BEAST_EXPECT(vaultAfter->at(sfAssetsTotal) == assetsTotalBefore);
1230 BEAST_EXPECT(vaultAfter->at(sfAssetsAvailable) == assetsAvailableBefore);
1235 testCase(redeemAllNoAssetMpt(
tesSUCCESS), {.requireAuth =
false});
1238 {.requireAuth =
false, .features = testableAmendments() - fixCleanup3_4_0});
1241 Env
const env{*
this, testableAmendments()};
1243 env.current()->fees().accountReserve(0, 1).drops() /
kDropsPerXrp.drops(),
1244 env.current()->fees().increment.drops() /
kDropsPerXrp.drops()};
1256 testcase(
"MPT fail reserve to re-create MPToken");
1258 auto [tx,
keylet] = vault.create({.owner = owner, .asset = asset});
1261 auto const v = env.le(
keylet);
1264 env(pay(depositor, owner, asset(1000)));
1267 tx = vault.deposit({
1270 .amount = asset(1000),
1277 mptt.authorize({.account = owner, .flags = tfMPTUnauthorize});
1281 auto const sleMPT = env.le(mptoken);
1282 BEAST_EXPECT(sleMPT ==
nullptr);
1285 env(ticket::create(owner, 1));
1289 tx = vault.withdraw(
1290 {.depositor = owner, .id =
keylet.key, .amount = asset(100)});
1294 env(pay(depositor, owner, XRP(incReserve)));
1302 {.requireAuth =
false, .initialXRP = acctReserve + (incReserve * 4) + 1});
1314 auto [tx,
keylet] = vault.create({.owner = owner, .asset = asset});
1318 tx = vault.deposit({.depositor = depositor, .id =
keylet.key, .amount = asset(1000)});
1323 auto const tx = vault.clawback(
1324 {.issuer = issuer, .id =
keylet.key, .holder = depositor, .amount = asset(0)});
1328 mptt.destroy({.issuer = issuer, .id = mptt.issuanceID()});
1332 auto [tx,
keylet] = vault.create({.owner = depositor, .asset = asset});
1338 vault.deposit({.depositor = depositor, .id =
keylet.key, .amount = asset(10)});
1344 vault.withdraw({.depositor = depositor, .id =
keylet.key, .amount = asset(10)});
1349 auto const tx = vault.clawback(
1350 {.issuer = issuer, .id =
keylet.key, .holder = depositor, .amount = asset(0)});
1354 env(vault.del({.owner = owner, .id = keylet.key}));
1365 testcase(
"MPT vault owner can receive shares unless unauthorized");
1367 auto [tx,
keylet] = vault.create({.owner = owner, .asset = asset});
1371 tx = vault.deposit({.depositor = depositor, .id =
keylet.key, .amount = asset(1000)});
1376 auto const vault = env.le(
keylet);
1377 return vault->at(sfShareMPTID);
1383 env(pay(depositor, owner, shares(1)));
1386 tx = vault.withdraw({.depositor = owner, .id =
keylet.key, .amount = shares(1)});
1391 env(pay(depositor, owner, shares(1)));
1394 tx = vault.clawback(
1395 {.issuer = issuer, .id =
keylet.key, .holder = owner, .amount = asset(0)});
1400 env(pay(depositor, owner, shares(1)));
1404 env(pay(owner, depositor, shares(1)));
1410 jv[sfAccount] = owner.human();
1411 jv[sfMPTokenIssuanceID] =
to_string(issuanceId);
1412 jv[sfFlags] = tfMPTUnauthorize;
1413 jv[sfTransactionType] = jss::MPTokenAuthorize;
1419 tx = pay(depositor, owner, shares(1));
1424 tx = vault.clawback(
1425 {.issuer = issuer, .id =
keylet.key, .holder = depositor, .amount = asset(0)});
1430 env(vault.del({.owner = owner, .id = keylet.key}));
1446 auto [tx,
keylet] = vault.create({.owner = owner, .asset = asset});
1451 {.depositor = depositor, .id =
keylet.key, .amount = asset(1000)});
1456 auto const tx = vault.clawback({
1459 .holder = depositor,
1465 {.enableClawback =
false});
1476 auto [tx,
keylet] = vault.create({.owner = owner, .asset = asset});
1479 tx = vault.deposit({.depositor = depositor, .id =
keylet.key, .amount = asset(1000)});
1483 mptt.authorize({.account = issuer, .holder = depositor, .flags = tfMPTUnauthorize});
1487 auto tx = vault.withdraw(
1488 {.depositor = depositor, .id =
keylet.key, .amount = asset(100)});
1492 tx[sfDestination] = issuer.human();
1496 tx[sfDestination] = owner.human();
1504 vault.deposit({.depositor = depositor, .id =
keylet.key, .amount = asset(100)});
1510 tx = vault.clawback(
1511 {.issuer = issuer, .id =
keylet.key, .holder = issuer, .amount = asset(800)});
1515 tx = vault.clawback(
1516 {.issuer = issuer, .id =
keylet.key, .holder = depositor, .amount = asset(800)});
1520 env(vault.del({.owner = owner, .id = keylet.key}));
1526 Env env{*
this, testableAmendments()};
1528 Account const issuer{
"issuer"};
1529 env.fund(XRP(1000000), owner, issuer);
1531 Vault const vault{env};
1533 MPTTester mptt{env, issuer, kMptInitNoFund};
1535 {.flags = tfMPTCanTransfer | tfMPTCanLock | lsfMPTCanClawback | tfMPTRequireAuth});
1536 mptt.authorize({.account = owner});
1537 mptt.authorize({.account = issuer, .holder = owner});
1539 env(pay(issuer, owner, asset(100)));
1540 auto [tx1, k1] = vault.create({.owner = owner, .asset = asset});
1544 auto const shares = [&env,
keylet = k1,
this] ->
Asset {
1545 auto const vault = env.le(
keylet);
1546 BEAST_EXPECT(vault !=
nullptr);
1547 return MPTIssue(vault->at(sfShareMPTID));
1550 auto [tx2, k2] = vault.create({.owner = owner, .asset = shares});
1556 testcase(
"MPT locked: vault shares inherit underlying lock");
1558 Env env{*
this, testableAmendments()};
1559 Account const issuer{
"issuer"};
1564 env.fund(XRP(10'000), issuer, owner, alice, bob, carol);
1566 Vault const vault{env};
1571 .holders = {owner, alice, bob, carol},
1572 .flags = tfMPTCanTransfer | tfMPTCanTrade | tfMPTCanLock,
1574 env(pay(issuer, alice, asset(1'000)));
1575 env(pay(issuer, bob, asset(1'000)));
1578 auto [tx,
keylet] = vault.create({.owner = owner, .asset = asset});
1582 env(vault.deposit({.depositor = alice, .id = keylet.key, .amount = asset(500)}));
1584 env(vault.deposit({.depositor = bob, .id = keylet.key, .amount = asset(500)}));
1588 auto const sle = env.le(
keylet);
1589 BEAST_EXPECT(sle !=
nullptr);
1590 return MPTIssue(sle->at(sfShareMPTID));
1592 auto const shareMptID = shares.raw().get<
MPTIssue>().getMptID();
1593 auto const shareBalance = [&](
Account const& account) {
1595 return sle ? sle->at(sfMPTAmount) : 0;
1600 env(pay(alice, bob, shares(1)));
1605 env(offer(alice, XRP(1), shares(1)));
1609 asset.set({.account = issuer, .flags = tfMPTLock});
1615 BEAST_EXPECT(shareBalance(alice) == 499);
1616 BEAST_EXPECT(shareBalance(bob) == 501);
1617 env(pay(alice, bob, shares(1)), Ter{
tecPATH_DRY});
1619 BEAST_EXPECT(shareBalance(alice) == 499);
1620 BEAST_EXPECT(shareBalance(bob) == 501);
1626 env(pay(carol, bob, shares(1)),
1628 Path(BookSpec{shares.raw()}),
1631 BEAST_EXPECT(shareBalance(alice) == 499);
1632 BEAST_EXPECT(shareBalance(bob) == 501);
1633 BEAST_EXPECT(expectOffers(env, alice, 1));
1640 auto const testShareDEXEndpointFrozen =
1648 Vault const vault{env};
1649 auto [tx,
keylet] = vault.create({.owner = owner, .asset = asset});
1653 env(vault.deposit({.depositor = alice, .id = keylet.key, .amount = asset(500)}));
1654 env(vault.deposit({.depositor = bob, .id = keylet.key, .amount = asset(500)}));
1659 auto const shareBalance = [&](
Account const& account) {
1661 return sle ? sle->at(sfMPTAmount) : 0;
1666 env(offer(bob, shares(1), XRP(1)));
1667 env(offer(bob, XRP(2), shares(1)));
1670 setAliceFrozen(
true);
1672 auto const aliceShares = shareBalance(alice);
1673 auto const bobShares = shareBalance(bob);
1674 auto const expectUnchanged = [&] {
1675 BEAST_EXPECT(shareBalance(alice) == aliceShares);
1676 BEAST_EXPECT(shareBalance(bob) == bobShares);
1677 BEAST_EXPECT(expectOffers(env, bob, 2));
1681 env(pay(alice, carol, XRP(1)),
1684 Txflags(tfNoRippleDirect),
1691 env(pay(carol, alice, shares(1)),
1693 Path(BookSpec{shares.
raw()}),
1694 Txflags(tfNoRippleDirect),
1700 setAliceFrozen(
false);
1702 env(pay(alice, carol, XRP(1)),
1705 Txflags(tfNoRippleDirect));
1707 BEAST_EXPECT(shareBalance(bob) == bobShares + 1);
1709 env(pay(carol, alice, shares(1)),
1711 Path(BookSpec{shares.
raw()}),
1712 Txflags(tfNoRippleDirect));
1714 BEAST_EXPECT(shareBalance(alice) == aliceShares);
1715 BEAST_EXPECT(shareBalance(bob) == bobShares);
1716 BEAST_EXPECT(expectOffers(env, bob, 0));
1722 auto const testShareDEXMiddleFrozen = [&](Env& env,
1729 Vault const vault{env};
1730 auto [tx,
keylet] = vault.create({.owner = owner, .asset = asset});
1734 env(vault.deposit({.depositor = alice, .id = keylet.key, .amount = asset(500)}));
1735 env(vault.deposit({.depositor = bob, .id = keylet.key, .amount = asset(500)}));
1740 auto const shareBalance = [&](
Account const& account) {
1742 return sle ? sle->at(sfMPTAmount) : 0;
1747 env(offer(alice, XRP(1), shares(1)));
1748 env(offer(bob, shares(1), asset(1)));
1751 setAliceFrozen(
true);
1753 auto const aliceShares = shareBalance(alice);
1754 auto const bobShares = shareBalance(bob);
1755 env(pay(carol, owner, asset(1)),
1757 Path(BookSpec{shares.
raw()}, BookSpec{asset.raw()}),
1758 Txflags(tfNoRippleDirect),
1761 BEAST_EXPECT(shareBalance(alice) == aliceShares);
1762 BEAST_EXPECT(shareBalance(bob) == bobShares);
1764 setAliceFrozen(
false);
1766 env(pay(carol, owner, asset(1)),
1768 Path(BookSpec{shares.
raw()}, BookSpec{asset.raw()}),
1769 Txflags(tfNoRippleDirect));
1771 BEAST_EXPECT(shareBalance(alice) == aliceShares - 1);
1772 BEAST_EXPECT(shareBalance(bob) == bobShares + 1);
1773 BEAST_EXPECT(expectOffers(env, alice, 0));
1774 BEAST_EXPECT(expectOffers(env, bob, 0));
1779 env(offer(bob, asset(1), shares(1)));
1780 env(offer(alice, shares(1), XRP(1)));
1783 setAliceFrozen(
true);
1785 auto const aliceShares = shareBalance(alice);
1786 auto const bobShares = shareBalance(bob);
1787 env(pay(owner, carol, XRP(1)),
1789 Path(BookSpec{shares.
raw()}, ~XRP),
1790 Txflags(tfNoRippleDirect),
1793 BEAST_EXPECT(shareBalance(alice) == aliceShares);
1794 BEAST_EXPECT(shareBalance(bob) == bobShares);
1796 setAliceFrozen(
false);
1798 env(pay(owner, carol, XRP(1)),
1800 Path(BookSpec{shares.
raw()}, ~XRP),
1801 Txflags(tfNoRippleDirect));
1803 BEAST_EXPECT(shareBalance(alice) == aliceShares + 1);
1804 BEAST_EXPECT(shareBalance(bob) == bobShares - 1);
1805 BEAST_EXPECT(expectOffers(env, alice, 0));
1806 BEAST_EXPECT(expectOffers(env, bob, 0));
1811 testcase(
"MPT individually locked: vault share DEX inherits underlying lock");
1813 Env env{*
this, testableAmendments()};
1814 Account const issuer{
"issuer"};
1819 env.fund(XRP(10'000), issuer, owner, alice, bob, carol);
1825 .holders = {owner, alice, bob},
1826 .flags = tfMPTCanTransfer | tfMPTCanTrade | tfMPTCanLock,
1828 env(pay(issuer, owner, asset(1'000)));
1829 env(pay(issuer, alice, asset(2'000)));
1830 env(pay(issuer, bob, asset(2'000)));
1833 auto const setAliceFrozen = [&](
bool frozen) {
1834 asset.set({.holder = alice, .flags = frozen ? tfMPTLock : tfMPTUnlock});
1837 testShareDEXEndpointFrozen(env, asset, owner, alice, bob, carol, setAliceFrozen);
1838 testShareDEXMiddleFrozen(env, asset, owner, alice, bob, carol, setAliceFrozen);
1842 testcase(
"IOU individually frozen: vault share DEX inherits underlying freeze");
1844 Env env{*
this, testableAmendments()};
1845 Account const issuer{
"issuer"};
1850 env.fund(XRP(10'000), issuer, owner, alice, bob, carol);
1854 env(fset(issuer, asfDefaultRipple));
1856 env.trust(asset(10'000), owner, alice, bob);
1857 env(pay(issuer, owner, asset(1'000)));
1858 env(pay(issuer, alice, asset(2'000)));
1859 env(pay(issuer, bob, asset(2'000)));
1862 auto const setAliceFrozen = [&](
bool frozen) {
1863 env(trust(issuer, asset(0), alice, frozen ? tfSetFreeze : tfClearFreeze));
1866 testShareDEXEndpointFrozen(env, asset, owner, alice, bob, carol, setAliceFrozen);
1867 testShareDEXMiddleFrozen(env, asset, owner, alice, bob, carol, setAliceFrozen);
1871 testcase(
"MPT CanTrade governance: share inherits underlying on DEX and AMM");
1873 Env env{*
this, testableAmendments()};
1874 Account const issuer{
"issuer"};
1878 env.fund(XRP(100'000), issuer, owner, alice, bob);
1880 Vault const vault{env};
1882 MPTTester mptt{env, issuer, kMptInitNoFund};
1883 mptt.create({.flags = tfMPTCanTransfer | tfMPTCanLock});
1885 mptt.authorize({.account = owner});
1886 mptt.authorize({.account = alice});
1887 mptt.authorize({.account = bob});
1888 env(pay(issuer, alice, asset(10'000)));
1889 env(pay(issuer, bob, asset(10'000)));
1892 auto [tx,
keylet] = vault.create({.owner = owner, .asset = asset});
1897 env(vault.deposit({.depositor = alice, .id = keylet.key, .amount = asset(5'000)}));
1898 env(vault.deposit({.depositor = bob, .id = keylet.key, .amount = asset(5'000)}));
1902 auto const sle = env.le(
keylet);
1903 BEAST_EXPECT(sle !=
nullptr);
1904 return MPTIssue(sle->at(sfShareMPTID));
1914 env(vault.deposit({.depositor = alice, .id = keylet.key, .amount = asset(100)}));
1919 env(pay(alice, bob, shares(1)));
1923 env(vault.withdraw({.depositor = alice, .id = keylet.key, .amount = asset(100)}));
1927 mptt.set({.flags = tfMPTSetCanTrade});
1930 env(offer(alice, XRP(1), asset(10)));
1931 env(offer(alice, XRP(1), shares(1)));
1934 AMM
const ammUnderlying(env, alice, XRP(1'000), asset(1'000));
1938 testcase(
"MPT OutstandingAmount > MaximumAmount");
1940 Env env{*
this, testableAmendments() | featureSingleAssetVault};
1942 Account const issuer{
"issuer"};
1943 env.fund(XRP(1'000), alice, issuer);
1945 Vault const vault{env};
1947 MPTTester
const btc({.env = env, .issuer = issuer, .holders = {alice}, .maxAmt = 100});
1949 auto [tx, k] = vault.create({.owner = issuer, .asset = btc});
1953 tx = vault.deposit({.depositor = issuer, .id = k.key, .amount = btc(110)});
1960 env(pay(issuer, alice, btc(100)));
1963 tx = vault.deposit({.depositor = issuer, .id = k.key, .amount = btc(100)});
1968 tx = vault.deposit({.depositor = alice, .id = k.key, .amount = btc(100)});
1982 int initialXRP = 1000;
1985 bool charlieRipple =
true;
1989 auto const testCase = [&,
this](
1999 CaseArgs args = {}) {
2000 Env env{*
this, args.features};
2002 Account const issuer{
"issuer"};
2003 Account const charlie{
"charlie"};
2005 env.fund(XRP(args.initialXRP), issuer, owner, charlie);
2006 env(fset(issuer, asfAllowTrustLineClawback));
2010 env.trust(asset(1000), owner);
2011 env(pay(issuer, owner, asset(args.initialIOU)));
2013 if (!args.charlieRipple)
2015 env(fset(issuer, 0, asfDefaultRipple));
2017 env.trust(asset(1000), charlie);
2019 env(pay(issuer, charlie, asset(args.initialIOU)));
2021 env(fset(issuer, asfDefaultRipple));
2025 env.trust(asset(1000), charlie);
2028 env(rate(issuer, args.transferRate));
2035 return env.le(
keylet)->at(sfShareMPTID);
2038 test(env, owner, issuer, charlie, vaultAccount, vault, asset, issuanceId);
2050 testcase(
"IOU cannot use different asset");
2053 auto [tx,
keylet] = vault.create({.owner = owner, .asset = asset});
2059 auto const tx = [&, account = vaultAccount(
keylet)] {
2061 jv[jss::Account] = issuer.human();
2063 auto& ja = jv[jss::LimitAmount] =
2065 ja[jss::issuer] =
toBase58(account);
2067 jv[jss::TransactionType] = jss::TrustSet;
2068 jv[jss::Flags] = tfSetFreeze;
2077 vault.deposit({.depositor = issuer, .id =
keylet.key, .amount = foo(20)});
2084 vault.withdraw({.depositor = issuer, .id =
keylet.key, .amount = foo(20)});
2089 env(vault.del({.owner = owner, .id = keylet.key}));
2094 auto const feeArgs = CaseArgs{.transferRate = 1.25};
2096 auto const testTransferFeeGate = [&](
FeatureBitset const& features) {
2107 bool const feeCharged = features[fixCleanup3_5_0];
2109 feeCharged ?
"IOU transfer fee on third-party withdrawal"
2110 :
"IOU transfer fee waived pre-fixCleanup3_5_0");
2116 BEAST_EXPECT(env.balance(owner, issue) == asset(100));
2117 BEAST_EXPECT(env.balance(funded.account, issue) == asset(100));
2119 env(vault.clawback({
2121 .id = funded.keylet.key,
2123 .amount = asset(50),
2128 BEAST_EXPECT(env.balance(owner, issue) == asset(100));
2129 BEAST_EXPECT(env.balance(funded.account, issue) == asset(50));
2131 env(vault.withdraw({
2133 .id = funded.keylet.key,
2134 .amount = funded.shares(20'000'000),
2139 BEAST_EXPECT(env.balance(owner, issue) == asset(120));
2140 BEAST_EXPECT(env.balance(funded.account, issue) == asset(30));
2142 auto tx = vault.withdraw({
2144 .id = funded.keylet.key,
2145 .amount = funded.shares(30'000'000),
2147 tx[sfDestination] = charlie.human();
2151 auto const expected = feeCharged ? asset(24) : asset(30);
2152 BEAST_EXPECT(env.balance(owner, issue) == asset(120));
2153 BEAST_EXPECT(env.balance(charlie, issue) == expected);
2154 BEAST_EXPECT(env.balance(funded.account, issue) == asset(0));
2156 env(vault.del({.owner = owner, .id = funded.keylet.key}));
2159 CaseArgs{.transferRate = 1.25, .features = features});
2161 testTransferFeeGate(testableAmendments() - fixCleanup3_5_0);
2162 testTransferFeeGate(testableAmendments());
2174 testcase(
"IOU transfer fee on fixed-asset third-party withdrawal");
2178 auto const shareIssue = funded.shares.raw().get<
MPTIssue>();
2180 auto tx = vault.withdraw(
2181 {.depositor = owner, .id = funded.keylet.key, .amount = asset(40)});
2182 tx[sfDestination] = charlie.human();
2187 BEAST_EXPECT(env.balance(charlie, issue) == asset(40));
2188 BEAST_EXPECT(env.balance(funded.account, issue) == asset(50));
2189 BEAST_EXPECT(env.balance(owner, shareIssue) == funded.shares(50'000'000));
2190 BEAST_EXPECT(env.balance(owner, issue) == asset(100));
2204 testcase(
"IOU transfer fee on fixed-share third-party withdrawal");
2208 auto const shareIssue = funded.shares.raw().get<
MPTIssue>();
2210 auto tx = vault.withdraw({
2212 .id = funded.keylet.key,
2213 .amount = funded.shares(25'000'000),
2215 tx[sfDestination] = charlie.human();
2220 BEAST_EXPECT(env.balance(charlie, issue) == asset(20));
2221 BEAST_EXPECT(env.balance(funded.account, issue) == asset(75));
2222 BEAST_EXPECT(env.balance(owner, shareIssue) == funded.shares(75'000'000));
2236 testcase(
"IOU no transfer fee on withdrawal to issuer");
2241 auto tx = vault.withdraw(
2242 {.depositor = owner, .id = funded.keylet.key, .amount = asset(10)});
2243 tx[sfDestination] = issuer.human();
2247 BEAST_EXPECT(env.balance(funded.account, issue) == asset(90));
2248 BEAST_EXPECT(env.balance(owner, issue) == asset(100));
2262 testcase(
"IOU no transfer fee on self-withdrawal");
2268 {.depositor = owner, .id = funded.keylet.key, .amount = asset(10)}));
2271 BEAST_EXPECT(env.balance(owner, issue) == asset(110));
2272 BEAST_EXPECT(env.balance(funded.account, issue) == asset(90));
2286 testcase(
"IOU transfer fee must fit in the vault position");
2292 auto tx = vault.withdraw(
2293 {.depositor = owner, .id = funded.keylet.key, .amount = asset(81)});
2294 tx[sfDestination] = charlie.human();
2299 tx = vault.withdraw(
2300 {.depositor = owner, .id = funded.keylet.key, .amount = asset(80)});
2301 tx[sfDestination] = charlie.human();
2305 BEAST_EXPECT(env.balance(charlie, issue) == asset(80));
2306 BEAST_EXPECT(env.balance(funded.account, issue) == asset(0));
2308 env(vault.del({.owner = owner, .id = funded.keylet.key}));
2323 testcase(
"IOU no transfer fee on issuer withdrawal to a third party");
2328 auto tx = vault.withdraw(
2329 {.depositor = issuer, .id = funded.keylet.key, .amount = asset(40)});
2330 tx[sfDestination] = charlie.human();
2334 BEAST_EXPECT(env.balance(charlie, issue) == asset(40));
2335 BEAST_EXPECT(env.balance(funded.account, issue) == asset(60));
2349 testcase(
"IOU receiver limit applies to the net amount");
2352 env(trust(charlie, asset(40)));
2358 auto tx = vault.withdraw(
2359 {.depositor = owner, .id = funded.keylet.key, .amount = asset(40)});
2360 tx[sfDestination] = charlie.human();
2364 BEAST_EXPECT(env.balance(charlie, issue) == asset(40));
2365 BEAST_EXPECT(env.balance(funded.account, issue) == asset(50));
2378 testcase(
"IOU no trust line to 3rd party");
2380 auto [tx,
keylet] = vault.create({.owner = owner, .asset = asset});
2384 env(vault.deposit({.depositor = owner, .id = keylet.key, .amount = asset(100)}));
2388 env.fund(XRP(1000), erin);
2394 vault.withdraw({.depositor = owner, .id =
keylet.key, .amount = asset(10)});
2395 tx[sfDestination] = erin.human();
2410 testcase(
"IOU no trust line to depositor");
2412 auto [tx,
keylet] = vault.create({.owner = owner, .asset = asset});
2417 env.trust(asset(0), owner);
2420 env(vault.deposit({.depositor = owner, .id = keylet.key, .amount = asset(200)}));
2424 BEAST_EXPECT(trustline ==
nullptr);
2428 return vault.withdraw({.depositor = owner, .id =
keylet.key, .amount = asset(10)});
2445 auto [tx,
keylet] = vault.create({.owner = owner, .asset = asset});
2452 env(trust(issuer, vaultAccount(
keylet)[
"IOU"], tfSetNoRipple));
2456 auto const tx = vault.deposit(
2457 {.depositor = charlie, .id =
keylet.key, .amount = asset(100)});
2465 vault.deposit({.depositor = owner, .id =
keylet.key, .amount = asset(100)});
2470 auto tx2 = vault.withdraw(
2471 {.depositor = owner, .id =
keylet.key, .amount = shares(100)});
2472 tx2[sfDestination] = charlie.human();
2479 tx[sfAccount] = charlie.human();
2480 tx[sfMPTokenIssuanceID] =
2482 tx[sfTransactionType] = jss::MPTokenAuthorize;
2496 env(pay(owner, charlie, shares(100)), Ter{
tecPATH_DRY});
2500 tx = vault.withdraw({.depositor = owner, .id =
keylet.key, .amount = asset(100)});
2505 env(vault.del({.owner = owner, .id = keylet.key}));
2507 {.charlieRipple =
false});
2515 auto const& vaultAccount,
2519 testcase(
"IOU calculation rounding");
2521 auto [tx,
keylet] = vault.create({.owner = owner, .asset = asset});
2526 auto const startingOwnerBalance = env.balance(owner, asset);
2527 BEAST_EXPECT((startingOwnerBalance.value() ==
STAmount{asset, 11875, -2}));
2533 env(vault.deposit({.depositor = owner, .id = keylet.key, .amount = asset(100)}));
2535 auto const tx1 = vault.deposit(
2536 {.depositor = owner, .id =
keylet.key, .amount = asset(
Number(375, -2))});
2537 for (
auto i = 0; i < 5; ++i)
2544 STAmount const xfer{asset, 1185, -1};
2545 BEAST_EXPECT(env.balance(owner, asset) == startingOwnerBalance.value() - xfer);
2546 BEAST_EXPECT(env.balance(vaultAccount(
keylet), asset) == xfer);
2548 auto const vault = env.le(
keylet);
2549 BEAST_EXPECT(vault->at(sfAssetsAvailable) == xfer);
2550 BEAST_EXPECT(vault->at(sfAssetsTotal) == xfer);
2556 env(vault.withdraw({
2559 .amount = asset(Number(1000 + (37 * 5), -1)),
2563 BEAST_EXPECT(env.balance(owner, asset) == startingOwnerBalance.value());
2565 auto const vault = env.le(
keylet);
2566 BEAST_EXPECT(vault->at(sfAssetsAvailable) ==
beast::kZero);
2567 BEAST_EXPECT(vault->at(sfAssetsTotal) ==
beast::kZero);
2570 env(vault.del({.owner = owner, .id = keylet.key}));
2573 {.initialIOU =
Number(11875, -2)});
2576 Env
const env{*
this, testableAmendments()};
2578 env.current()->fees().accountReserve(0, 1).drops() /
kDropsPerXrp.drops(),
2579 env.current()->fees().increment.drops() /
kDropsPerXrp.drops()};
2592 testcase(
"IOU no trust line to depositor no reserve");
2593 auto [tx,
keylet] = vault.create({.owner = owner, .asset = asset});
2599 env.trust(asset(0), owner);
2602 env(vault.deposit({.depositor = owner, .id = keylet.key, .amount = asset(200)}));
2606 BEAST_EXPECT(trustline ==
nullptr);
2608 env(ticket::create(owner, 1));
2612 tx = vault.withdraw({.depositor = owner, .id =
keylet.key, .amount = asset(10)});
2616 env(pay(charlie, owner, XRP(incReserve)));
2623 CaseArgs{.initialXRP = acctReserve + (incReserve * 4) + 1});
2635 testcase(
"IOU no reserve for share MPToken");
2636 auto [tx,
keylet] = vault.create({.owner = owner, .asset = asset});
2640 env(pay(owner, charlie, asset(100)));
2643 env(ticket::create(charlie, 3));
2647 tx = vault.deposit({.depositor = charlie, .id =
keylet.key, .amount = asset(100)});
2651 env(pay(issuer, charlie, XRP(incReserve)));
2658 CaseArgs{.initialXRP = acctReserve + (incReserve * 4) + 1});