912 auto const mpTokensV2 = features[featureMPTokensV2];
918 Env env{*
this, features - featureMPTokensV1};
931 Env env{*
this, features - featureMPTokensV1};
934 auto const usd = alice[
"USD"];
941 jv[jss::secret] = alice.
name();
942 jv[jss::tx_json] =
pay(alice, carol, mpt);
944 auto const jrr = env.
rpc(
"json",
"submit",
to_string(jv));
945 BEAST_EXPECT(jrr[jss::result][jss::engine_result] ==
"temDISABLED");
950 Env env{*
this, features};
952 MPTTester mptAlice(env, alice, {.holders = {bob}});
954 mptAlice.
create({.ownerCount = 1, .holderCount = 0});
955 auto const mpt = mptAlice[
"MPT"];
957 mptAlice.authorize({.account = bob});
960 env(
pay(alice, bob, mpt(10)),
Txflags(tfNoRippleDirect), err);
962 env(
pay(alice, bob, mpt(10)),
Txflags(tfLimitQuality), err);
967 Env env{*
this, features};
971 MPTTester mptAlice(env, alice, {.holders = {carol}});
974 {.ownerCount = 1, .holderCount = 0, .flags = tfMPTCanTransfer | tfMPTCanTrade});
976 mptAlice.authorize({.account = carol});
980 auto const mpt = mptAlice[
"MPT"];
985 auto const usd = alice[
"USD"];
987 env(
pay(alice, carol, usd(100)),
Sendmax(mpt(100)), err);
995 env(
pay(alice, carol, mpT1(100)),
Sendmax(mpt(100)), err);
999 env(
pay(alice, carol, mpt(100)),
Path(~usd), err);
1004 Env env{*
this, features - featureMPTokensV2};
1008 MPTTester mptAlice(env, alice, {.holders = {bob, carol}});
1010 mptAlice.
create({.ownerCount = 1, .holderCount = 0});
1011 auto const mpt = mptAlice[
"MPT"];
1013 mptAlice.authorize({.account = carol});
1016 payment[jss::secret] = alice.
name();
1017 payment[jss::tx_json] =
pay(alice, carol, mpt(100));
1019 payment[jss::build_path] =
true;
1020 auto jrr = env.
rpc(
"json",
"submit",
to_string(payment));
1021 BEAST_EXPECT(jrr[jss::result][jss::error] ==
"invalidParams");
1024 jrr[jss::result][jss::error_message] ==
1025 "Field 'build_path' not allowed in this context.");
1030 Env env{*
this, features};
1032 MPTTester mptAlice(env, alice, {.holders = {bob, carol}});
1034 mptAlice.
create({.ownerCount = 1, .holderCount = 0});
1035 auto const mpt = mptAlice[
"MPT"];
1037 mptAlice.authorize({.account = bob});
1038 mptAlice.authorize({.account = carol});
1051 Env env{*
this, features};
1053 MPTTester mptAlice(env, alice, {.holders = {bob}});
1055 mptAlice.
create({.ownerCount = 1, .holderCount = 0});
1057 mptAlice.authorize({.account = bob});
1066 Env env{*
this, features};
1068 MPTTester mptAlice(env, alice, {.holders = {bob}});
1070 mptAlice.
create({.ownerCount = 1, .holderCount = 0});
1072 mptAlice.authorize({.account = bob});
1085 Env env{*
this, features};
1087 MPTTester mptAlice(env, alice, {.holders = {bob}});
1090 {.ownerCount = 1, .holderCount = 0, .flags = tfMPTRequireAuth | tfMPTCanTransfer});
1092 mptAlice.authorize({.account = bob});
1100 Env env{*
this, features};
1102 MPTTester mptAlice(env, alice, {.holders = {bob}});
1105 {.ownerCount = 1, .holderCount = 0, .flags = tfMPTRequireAuth | tfMPTCanTransfer});
1108 mptAlice.authorize({.account = bob});
1111 mptAlice.authorize({.account = alice, .holder = bob});
1114 mptAlice.pay(alice, bob, 100);
1117 mptAlice.authorize({.account = alice, .holder = bob, .flags = tfMPTUnauthorize});
1124 if (features[featureSingleAssetVault] && features[featurePermissionedDomains])
1128 Env env{*
this, features};
1130 Account const credIssuer1{
"credIssuer1"};
1131 env.
fund(
XRP(1000), credIssuer1, bob);
1133 auto const domainId1 = [&] {
1135 {.issuer = credIssuer1, .credType = credType},
1155 .flags = tfMPTRequireAuth | tfMPTCanTransfer,
1156 .domainID = domainId1,
1159 mptAlice.authorize({.account = bob});
1163 mptAlice.pay(alice, bob, 100);
1164 mptAlice.set({.domainID =
UInt256{}});
1171 Env env{*
this, features};
1173 Account const credIssuer1{
"credIssuer1"};
1174 env.
fund(
XRP(1000), credIssuer1, bob);
1176 auto const domainId1 = [&] {
1178 {.issuer = credIssuer1, .credType = credType},
1198 .flags = tfMPTRequireAuth | tfMPTCanTransfer,
1199 .domainID = domainId1,
1203 mptAlice.authorize({.account = bob});
1206 mptAlice.authorize({.account = alice, .holder = bob});
1209 mptAlice.pay(alice, bob, 100);
1212 mptAlice.authorize({.account = alice, .holder = bob, .flags = tfMPTUnauthorize});
1215 mptAlice.pay(bob, alice, 10);
1217 mptAlice.set({.domainID =
UInt256{}});
1225 Env env{*
this, features};
1228 Account const credIssuer1{
"credIssuer1"};
1231 Account const credIssuer2{
"credIssuer2"};
1232 env.
fund(
XRP(1000), credIssuer1, credIssuer2, bob, carol);
1234 auto const domainId1 = [&] {
1236 {.issuer = credIssuer1, .credType = credType},
1246 auto const domainId2 = [&] {
1248 {.issuer = credIssuer1, .credType = credType},
1249 {.issuer = credIssuer2, .credType = credType},
1277 .flags = tfMPTRequireAuth | tfMPTCanTransfer,
1278 .domainID = domainId1,
1282 mptAlice.authorize({.account = bob});
1283 mptAlice.authorize({.account = carol});
1287 mptAlice.pay(alice, bob, 50);
1298 mptAlice.set({.domainID = domainId2});
1300 mptAlice.pay(alice, carol, 10);
1305 mptAlice.pay(bob, carol, 10);
1319 Env env(*
this, features);
1324 MPTTester mptAlice(env, alice, {.holders = {bob, cindy}});
1327 mptAlice.
create({.ownerCount = 1, .holderCount = 0});
1330 mptAlice.authorize({.account = bob});
1333 mptAlice.authorize({.account = cindy});
1336 mptAlice.pay(alice, bob, 100);
1343 mptAlice.pay(bob, alice, 10);
1348 Env env{*
this, features};
1350 MPTTester mptAlice(env, alice, {.holders = {bob, carol}});
1352 mptAlice.
create({.ownerCount = 1, .holderCount = 0, .flags = tfMPTCanTransfer});
1366 Env env{*
this, features};
1368 MPTTester mptAlice(env, alice, {.holders = {bob, carol}});
1370 mptAlice.
create({.ownerCount = 1, .flags = tfMPTCanTransfer});
1372 mptAlice.authorize({.account = bob});
1373 mptAlice.authorize({.account = carol});
1375 mptAlice.pay(alice, bob, 100);
1386 Env env{*
this, features};
1388 MPTTester mptAlice(env, alice, {.holders = {bob, carol}});
1390 mptAlice.
create({.ownerCount = 1, .flags = tfMPTCanLock | tfMPTCanTransfer});
1392 mptAlice.authorize({.account = bob});
1393 mptAlice.authorize({.account = carol});
1395 mptAlice.pay(alice, bob, 100);
1396 mptAlice.pay(alice, carol, 100);
1402 mptAlice.set({.account = alice, .flags = tfMPTLock});
1404 mptAlice.pay(bob, carol, 1, err);
1405 mptAlice.pay(carol, bob, 2, err);
1407 mptAlice.pay(alice, bob, 3);
1409 mptAlice.pay(bob, alice, 4);
1412 mptAlice.set({.account = alice, .flags = tfMPTUnlock});
1414 mptAlice.set({.account = alice, .holder = bob, .flags = tfMPTLock});
1416 mptAlice.pay(bob, carol, 5, err);
1417 mptAlice.pay(carol, bob, 6, err);
1419 mptAlice.pay(alice, bob, 7);
1421 mptAlice.pay(bob, alice, 8);
1426 Env env{*
this, features};
1428 MPTTester mptAlice(env, alice, {.holders = {bob, carol}});
1432 .transferFee = 10'000,
1435 .flags = tfMPTCanTransfer,
1439 mptAlice.authorize({.account = bob});
1440 mptAlice.authorize({.account = carol});
1443 mptAlice.pay(alice, bob, 2'000);
1446 mptAlice.pay(bob, alice, 1'000);
1447 BEAST_EXPECT(mptAlice.checkMPTokenAmount(bob, 1'000));
1457 auto const mpt = mptAlice[
"MPT"];
1463 env(
pay(bob, carol, mpt(100)),
Sendmax(mpt(110)));
1465 env(
pay(bob, carol, mpt(100)),
Sendmax(mpt(115)));
1466 BEAST_EXPECT(mptAlice.checkMPTokenAmount(bob, 780));
1467 BEAST_EXPECT(mptAlice.checkMPTokenAmount(carol, 200));
1473 BEAST_EXPECT(mptAlice.checkMPTokenAmount(bob, 690));
1477 mptAlice.checkMPTokenAmount(carol, !features[featureMPTokensV2] ? 282 : 281));
1482 Env env{*
this, features};
1484 MPTTester mptAlice(env, alice, {.holders = {bob, carol}});
1486 mptAlice.
create({.ownerCount = 1, .holderCount = 0, .flags = tfMPTCanTransfer});
1489 mptAlice.authorize({.account = bob});
1490 mptAlice.authorize({.account = carol});
1491 mptAlice.pay(alice, bob, 1'000);
1493 auto const mpt = mptAlice[
"MPT"];
1499 env(
pay(bob, carol, mpt(100)),
Sendmax(mpt(100)));
1500 BEAST_EXPECT(mptAlice.checkMPTokenAmount(carol, 100));
1503 BEAST_EXPECT(mptAlice.checkMPTokenAmount(carol, 199));
1508 Env env{*
this, features};
1510 MPTTester mptAlice(env, alice, {.holders = {bob, carol}});
1512 mptAlice.
create({.ownerCount = 1, .holderCount = 0, .flags = tfMPTCanTransfer});
1515 mptAlice.authorize({.account = bob});
1516 mptAlice.authorize({.account = carol});
1517 mptAlice.pay(alice, bob, 1'000);
1519 auto const mpt = mptAlice[
"MPT"];
1522 env(
pay(bob, alice, mpt(100)),
1528 env(
pay(bob, alice, mpt(100)),
1536 Env env{*
this, features};
1538 MPTTester mptAlice(env, alice, {.holders = {bob}});
1541 {.maxAmt = 100, .ownerCount = 1, .holderCount = 0, .flags = tfMPTCanTransfer});
1543 mptAlice.authorize({.account = bob});
1546 mptAlice.pay(alice, bob, 100);
1550 mptAlice.pay(alice, bob, 1, err);
1556 Env env{*
this, features};
1558 MPTTester mptAlice(env, alice, {.holders = {bob}});
1560 mptAlice.
create({.ownerCount = 1, .holderCount = 0});
1562 mptAlice.authorize({.account = bob});
1569 mptAlice.pay(alice, bob, 1, err);
1575 Env env{*
this, features};
1576 env.
fund(
XRP(1'000), alice, bob);
1579 jv[jss::secret] = alice.
name();
1580 jv[jss::tx_json] =
pay(alice, bob, mpt);
1582 auto const jrr = env.
rpc(
"json",
"submit",
to_string(jv));
1583 BEAST_EXPECT(jrr[jss::result][jss::error] ==
"invalidParams");
1585 BEAST_EXPECT(jrr[jss::result][jss::error_message] ==
"Invalid field 'tx_json.Amount'.");
1591 Env env{*
this, features};
1593 MPTTester mptAlice(env, alice, {.holders = {bob, carol}});
1600 .flags = tfMPTCanTransfer,
1602 auto const mpt = mptAlice[
"MPT"];
1604 mptAlice.authorize({.account = bob});
1605 mptAlice.authorize({.account = carol});
1608 mptAlice.pay(alice, bob, 10'000);
1611 env(
pay(bob, carol, mpt(10'000)),
Sendmax(mpt(10'000)),
Txflags(tfPartialPayment));
1617 meta[0u][sfModifiedNode.fieldName][sfFinalFields.fieldName]
1618 [sfOutstandingAmount.fieldName] ==
"9990");
1621 meta[1u][sfModifiedNode.fieldName][sfFinalFields.fieldName]
1622 [sfMPTAmount.fieldName] ==
"9990");
1625 meta[2u][sfModifiedNode.fieldName][sfPreviousFields.fieldName]
1626 [sfMPTAmount.fieldName] ==
"10000");
1627 BEAST_EXPECT(!meta[2u][sfModifiedNode.fieldName][sfFinalFields.fieldName].isMember(
1628 sfMPTAmount.fieldName));
1633 env(
pay(bob, carol, mpt(10'000)),
Sendmax(mpt(10'000)),
Ter(err));
1638 Env env{*
this, features};
1640 MPTTester mptAlice(env, alice, {.holders = {bob, carol}});
1646 .flags = tfMPTCanTransfer,
1648 auto const mpt = mptAlice[
"MPT"];
1650 mptAlice.authorize({.account = bob});
1651 mptAlice.authorize({.account = carol});
1662 BEAST_EXPECT(mptAlice.checkMPTokenOutstandingAmount(0));
1667 Env env{*
this, features};
1669 MPTTester mptAlice(env, alice, {.holders = {bob}});
1671 mptAlice.
create({.ownerCount = 1, .holderCount = 0});
1673 mptAlice.authorize({.account = bob});
1676 mptAlice.destroy({.ownerCount = 0});
1685 Env env{*
this, features};
1687 env.
fund(
XRP(1'000), alice, bob);
1692 env(
pay(alice, bob, mpt), err);
1698 Env env{*
this, features};
1700 MPTTester mptAlice(env, alice, {.holders = {bob}});
1702 mptAlice.
create({.ownerCount = 1, .holderCount = 0});
1705 mptAlice.destroy({.ownerCount = 0});
1715 Env env{*
this, features};
1720 MPTTester mptAlice(env, alice, {.holders = {bob, carol}});
1722 mptAlice.
create({.maxAmt = 100, .ownerCount = 1, .flags = tfMPTCanTransfer});
1724 mptAlice.authorize({.account = bob});
1725 mptAlice.authorize({.account = carol});
1727 mptAlice.pay(alice, bob, 100);
1730 mptAlice.pay(bob, carol, 100);
1735 Env env{*
this, features};
1737 MPTTester mptAlice(env, alice, {.holders = {bob, carol}});
1739 mptAlice.
create({.ownerCount = 1, .holderCount = 0, .flags = tfMPTCanTransfer});
1741 mptAlice.authorize({.account = bob});
1742 mptAlice.authorize({.account = carol});
1745 mptAlice.pay(alice, bob, 100);
1748 mptAlice.pay(bob, alice, 100);
1751 mptAlice.pay(alice, bob, 100);
1752 mptAlice.pay(bob, carol, 50);
2104 FeatureBitset const withoutFix = features - fixCleanup3_2_0;
2106 FeatureBitset const withoutFixAndV2 = withoutFix - featureMPTokensV2;
2107 FeatureBitset const withFixAndWithoutV2 = withFix - featureMPTokensV2;
2118 MPTValue
const alice0 = 10'000;
2119 MPTValue
const gw0 = -20'000;
2131 TER issuerToHolderPreFixTer;
2132 TER holderSourcePreFixTer;
2133 MPTValue issuerToHolderAliceAfterPreFix;
2134 MPTValue issuerToHolderIssuerAfterPreFix;
2135 MPTValue issuerToHolderAliceAfterPostFix;
2136 MPTValue issuerToHolderIssuerAfterPostFix;
2140 { .name=
"INT64_MAX + 1", .mantissa=firstInvalidMPTMantissa, .negative=
false, .mptValue=mptMin, .issuerToHolderPreFixTer=invariantFailed, .holderSourcePreFixTer=pathPartial, .issuerToHolderAliceAfterPreFix=alice0, .issuerToHolderIssuerAfterPreFix=gw0, .issuerToHolderAliceAfterPostFix=alice0 - 1, .issuerToHolderIssuerAfterPostFix=gw0 + 1},
2141 { .name=
"INT64_MAX + 10", .mantissa=firstInvalidMPTMantissa + 9, .negative=
false, .mptValue=mptMin + 9, .issuerToHolderPreFixTer=invariantFailed, .holderSourcePreFixTer=pathPartial, .issuerToHolderAliceAfterPreFix=alice0, .issuerToHolderIssuerAfterPreFix=gw0, .issuerToHolderAliceAfterPostFix=alice0 - 1, .issuerToHolderIssuerAfterPostFix=gw0 + 1},
2142 { .name=
"UINT64_MAX - 9998", .mantissa=u64Max - 9'998, .negative=
false, .mptValue=MPTValue{-9'999}, .issuerToHolderPreFixTer=success, .holderSourcePreFixTer=pathPartial, .issuerToHolderAliceAfterPreFix=alice0 - 9'999, .issuerToHolderIssuerAfterPreFix=gw0 + 9'999, .issuerToHolderAliceAfterPostFix=alice0 - 10'000, .issuerToHolderIssuerAfterPostFix=gw0 + 10'000},
2143 { .name=
"UINT64_MAX - 9", .mantissa=u64Max - 9, .negative=
false, .mptValue=MPTValue{-10}, .issuerToHolderPreFixTer=success, .holderSourcePreFixTer=pathPartial, .issuerToHolderAliceAfterPreFix=alice0 - 10, .issuerToHolderIssuerAfterPreFix=gw0 + 10, .issuerToHolderAliceAfterPostFix=alice0 - 11, .issuerToHolderIssuerAfterPostFix=gw0 + 11},
2144 { .name=
"UINT64_MAX - 1", .mantissa=u64Max - 1, .negative=
false, .mptValue=MPTValue{-2}, .issuerToHolderPreFixTer=success, .holderSourcePreFixTer=pathPartial, .issuerToHolderAliceAfterPreFix=alice0 - 2, .issuerToHolderIssuerAfterPreFix=gw0 + 2, .issuerToHolderAliceAfterPostFix=alice0 - 3, .issuerToHolderIssuerAfterPostFix=gw0 + 3},
2145 { .name=
"UINT64_MAX", .mantissa=u64Max, .negative=
false, .mptValue=MPTValue{-1}, .issuerToHolderPreFixTer=success, .holderSourcePreFixTer=pathPartial, .issuerToHolderAliceAfterPreFix=alice0 - 1, .issuerToHolderIssuerAfterPreFix=gw0 + 1, .issuerToHolderAliceAfterPostFix=alice0 - 2, .issuerToHolderIssuerAfterPostFix=gw0 + 2},
2146 { .name=
"-2", .mantissa=
std::uint64_t{2}, .negative=
true, .mptValue=MPTValue{-2}, .issuerToHolderPreFixTer=badAmountTer, .holderSourcePreFixTer=badAmountTer, .issuerToHolderAliceAfterPreFix=alice0, .issuerToHolderIssuerAfterPreFix=gw0, .issuerToHolderAliceAfterPostFix=alice0 - 1, .issuerToHolderIssuerAfterPostFix=gw0 + 1},
2149 auto const badMPTAmount = [&](
MPTIssue const& issue, BadMPTAmount
const& bad) {
2152 auto const makeIssue = [&](
Env& env) {
2156 .holders = {alice, bob},
2158 .flags = tfMPTCanTransfer | tfMPTCanTrade | tfMPTCanEscrow | tfMPTCanClawback,
2162 auto const withNonCanonicalMPTAmount =
2166 tx.
sign(signer.pk(), signer.sk());
2170 auto const roundTrip = [](
STTx const& tx) {
2176 auto const expectRoundTripBadMPT =
2177 [&](
JTx const& jt,
SField const& field, BadMPTAmount
const& bad) {
2178 auto const roundTripped = roundTrip(*jt.
stx);
2179 auto const persisted = roundTripped.getFieldAmount(field);
2180 BEAST_EXPECT(persisted.holds<
MPTIssue>());
2181 BEAST_EXPECT(persisted.mantissa() == bad.mantissa);
2182 BEAST_EXPECT(persisted.exponent() == 0);
2183 BEAST_EXPECT(persisted.negative() == bad.negative);
2184 BEAST_EXPECT(persisted.mpt().value() == bad.mptValue);
2189 for (
auto const& bad : badMPTAmounts)
2191 testcase(
"fixCleanup3_2_0 rejects non-canonical MPT Payment amounts");
2193 Env env{*
this, withoutFixAndV2};
2194 env.
fund(
XRP(100'000), alice, bob, gw);
2196 auto const issue = makeIssue(env);
2198 auto const badAmount = badMPTAmount(issue, bad);
2199 auto malformedHolderToHolder = withNonCanonicalMPTAmount(
2204 expectRoundTripBadMPT(malformedHolderToHolder, sfAmount, bad);
2205 malformedHolderToHolder.ter = bad.holderSourcePreFixTer;
2206 env.
submit(malformedHolderToHolder);
2211 (env.balance(bob, issue).value() ==
STAmount{MPTAmount{10'000}, issue}));
2213 (env.balance(gw, issue).value() ==
STAmount{MPTAmount{-20'000}, issue}));
2215 env.enableFeature(fixCleanup3_2_0);
2220 (env.balance(alice, issue).value() == STAmount{MPTAmount{10'001}, issue}));
2222 (env.balance(bob, issue).value() == STAmount{MPTAmount{9'999}, issue}));
2224 (env.balance(gw, issue).value() == STAmount{MPTAmount{-20'000}, issue}));
2228 env.fund(
XRP(100'000), alice, bob, gw);
2230 auto const issue = makeIssue(env);
2232 auto const badAmount = badMPTAmount(issue, bad);
2233 auto malformedIssuerToHolder = withNonCanonicalMPTAmount(
2238 expectRoundTripBadMPT(malformedIssuerToHolder, sfAmount, bad);
2239 malformedIssuerToHolder.ter = bad.issuerToHolderPreFixTer;
2240 env.submit(malformedIssuerToHolder);
2243 (env.balance(alice, issue).value() ==
2244 STAmount{MPTAmount{bad.issuerToHolderAliceAfterPreFix}, issue}));
2246 (env.balance(bob, issue).value() == STAmount{MPTAmount{10'000}, issue}));
2248 (env.balance(gw, issue).value() ==
2249 STAmount{MPTAmount{bad.issuerToHolderIssuerAfterPreFix}, issue}));
2251 env.enableFeature(fixCleanup3_2_0);
2256 (env.balance(alice, issue).value() ==
2257 STAmount{MPTAmount{bad.issuerToHolderAliceAfterPostFix}, issue}));
2259 (env.balance(bob, issue).value() == STAmount{MPTAmount{10'000}, issue}));
2261 (env.balance(gw, issue).value() ==
2262 STAmount{MPTAmount{bad.issuerToHolderIssuerAfterPostFix}, issue}));
2265 Env env{*
this, withoutFixAndV2};
2266 env.fund(
XRP(100'000), alice, bob, gw);
2268 auto const issue = makeIssue(env);
2270 auto const badAmount = badMPTAmount(issue, bad);
2271 auto malformedHolderToIssuer = withNonCanonicalMPTAmount(
2276 expectRoundTripBadMPT(malformedHolderToIssuer, sfAmount, bad);
2277 malformedHolderToIssuer.ter = bad.holderSourcePreFixTer;
2278 env.submit(malformedHolderToIssuer);
2281 (env.balance(alice, issue).value() == STAmount{MPTAmount{10'000}, issue}));
2283 (env.balance(bob, issue).value() == STAmount{MPTAmount{10'000}, issue}));
2285 (env.balance(gw, issue).value() == STAmount{MPTAmount{-20'000}, issue}));
2287 env.enableFeature(fixCleanup3_2_0);
2292 (env.balance(alice, issue).value() == STAmount{MPTAmount{10'001}, issue}));
2294 (env.balance(bob, issue).value() == STAmount{MPTAmount{10'000}, issue}));
2296 (env.balance(gw, issue).value() == STAmount{MPTAmount{-20'001}, issue}));
2299 Env env{*
this, withFixAndWithoutV2};
2300 env.fund(
XRP(100'000), alice, bob, gw);
2302 auto const issue = makeIssue(env);
2304 auto const badAmount = badMPTAmount(issue, bad);
2305 auto tx = withNonCanonicalMPTAmount(
2314 Env env{*
this, withFixAndWithoutV2};
2315 env.fund(
XRP(100'000), alice, bob, gw);
2317 auto const issue = makeIssue(env);
2319 auto const badAmount = badMPTAmount(issue, bad);
2320 auto tx = withNonCanonicalMPTAmount(
2329 Env env{*
this, withFixAndWithoutV2};
2330 env.fund(
XRP(100'000), alice, bob, gw);
2332 auto const issue = makeIssue(env);
2334 auto const badAmount = badMPTAmount(issue, bad);
2335 auto tx = withNonCanonicalMPTAmount(
2344 testcase(
"fixCleanup3_2_0 rejects non-canonical MPT Check amounts");
2347 env.fund(
XRP(100'000), alice, bob, gw);
2349 auto const issue = makeIssue(env);
2351 auto const badSendMax = badMPTAmount(issue, bad);
2352 auto const checkSeq = env.seq(alice);
2353 auto tx = withNonCanonicalMPTAmount(
2354 env.jt(check::create(alice, bob, STAmount{issue, std::uint64_t{10}})),
2362 auto const checkKeylet = keylet::check(alice.id(), SeqProxy::rawSequence(checkSeq));
2363 auto const sleCheck = env.le(checkKeylet);
2364 BEAST_EXPECT((sleCheck !=
nullptr) == !bad.negative);
2365 if (sleCheck && !bad.negative)
2367 auto const persisted = sleCheck->getFieldAmount(sfSendMax);
2368 BEAST_EXPECT(persisted.holds<MPTIssue>());
2369 BEAST_EXPECT(persisted.mantissa() == bad.mantissa);
2370 BEAST_EXPECT(persisted.negative() == bad.negative);
2375 env.fund(
XRP(100'000), alice, bob, gw);
2377 auto const issue = makeIssue(env);
2379 auto const badSendMax = badMPTAmount(issue, bad);
2380 auto const checkSeq = env.seq(alice);
2381 auto tx = withNonCanonicalMPTAmount(
2382 env.jt(check::create(alice, bob, STAmount{issue, std::uint64_t{10}})),
2390 auto const checkKeylet = keylet::check(alice.id(), SeqProxy::rawSequence(checkSeq));
2391 BEAST_EXPECT((env.le(checkKeylet) !=
nullptr) == !bad.negative);
2396 env(env.jt(check::cancel(alice, checkKeylet.key)), Ter{tesSUCCESS});
2398 BEAST_EXPECT(env.le(checkKeylet) ==
nullptr);
2403 env.fund(
XRP(100'000), alice, bob, gw);
2405 auto const issue = makeIssue(env);
2407 auto const badSendMax = badMPTAmount(issue, bad);
2408 auto const checkSeq = env.seq(alice);
2409 auto tx = withNonCanonicalMPTAmount(
2410 env.jt(check::create(alice, bob, STAmount{issue, std::uint64_t{10}})),
2418 auto const checkKeylet = keylet::check(alice.id(), SeqProxy::rawSequence(checkSeq));
2419 BEAST_EXPECT((env.le(checkKeylet) !=
nullptr) == !bad.negative);
2422 env.enableFeature(fixCleanup3_2_0);
2427 env(env.jt(check::cancel(alice, checkKeylet.key)), Ter{tesSUCCESS});
2429 BEAST_EXPECT(env.le(checkKeylet) ==
nullptr);
2434 env.fund(
XRP(100'000), alice, bob, gw);
2436 auto const issue = makeIssue(env);
2438 auto const badSendMax = badMPTAmount(issue, bad);
2439 auto const checkSeq = env.seq(alice);
2440 auto tx = withNonCanonicalMPTAmount(
2441 env.jt(check::create(alice, bob, STAmount{issue, std::uint64_t{10}})),
2449 auto const checkKeylet = keylet::check(alice.id(), SeqProxy::rawSequence(checkSeq));
2450 BEAST_EXPECT((env.le(checkKeylet) !=
nullptr) == !bad.negative);
2453 env.enableFeature(fixCleanup3_2_0);
2456 auto const cashAmount = STAmount{sfAmount, issue,
std::uint64_t{1}, 0,
false};
2457 env(env.jt(check::cash(bob, checkKeylet.key, cashAmount)), Ter{tefBAD_LEDGER});
2459 BEAST_EXPECT(env.le(checkKeylet) !=
nullptr);
2463 Env env{*
this, withoutFix};
2464 env.fund(
XRP(100'000), alice, bob, gw);
2466 auto const issue = makeIssue(env);
2468 auto const sendMax = STAmount{sfSendMax, issue,
std::uint64_t{10}, 0,
false};
2469 auto const checkSeq = env.seq(alice);
2470 env(env.jt(check::create(alice, bob, sendMax)), Ter{tesSUCCESS});
2473 auto const badCashAmount = badMPTAmount(issue, bad);
2474 auto tx = withNonCanonicalMPTAmount(
2478 keylet::check(alice.id(), SeqProxy::rawSequence(checkSeq)).key,
2479 STAmount{issue, std::uint64_t{1}})),
2483 expectRoundTripBadMPT(tx, sfAmount, bad);
2484 tx.ter = bad.holderSourcePreFixTer;
2488 env.le(keylet::check(alice.id(), SeqProxy::rawSequence(checkSeq))) !=
nullptr);
2490 (env.balance(alice, issue).value() == STAmount{MPTAmount{10'000}, issue}));
2492 (env.balance(bob, issue).value() == STAmount{MPTAmount{10'000}, issue}));
2494 (env.balance(gw, issue).value() == STAmount{MPTAmount{-20'000}, issue}));
2497 Env env{*
this, withFix};
2498 env.fund(
XRP(100'000), alice, bob, gw);
2500 auto const issue = makeIssue(env);
2502 auto const sendMax = STAmount{sfSendMax, issue,
std::uint64_t{10}, 0,
false};
2503 auto const checkSeq = env.seq(alice);
2504 env(env.jt(check::create(alice, bob, sendMax)), Ter{tesSUCCESS});
2507 auto const badCashAmount = badMPTAmount(issue, bad);
2508 auto tx = withNonCanonicalMPTAmount(
2512 keylet::check(alice.id(), SeqProxy::rawSequence(checkSeq)).key,
2513 STAmount{issue, std::uint64_t{1}})),
2521 testcase(
"fixCleanup3_2_0 rejects non-canonical MPT Escrow amounts");
2523 Env env{*
this, withoutFix};
2524 env.fund(
XRP(100'000), alice, bob, gw);
2526 auto const issue = makeIssue(env);
2528 auto const escrowSeq = env.seq(alice);
2529 auto const badAmount = badMPTAmount(issue, bad);
2530 auto tx = withNonCanonicalMPTAmount(
2532 escrow::create(alice, bob, STAmount{issue, std::uint64_t{1}}),
2533 escrow::kFinishTime(env.now() + 1s)),
2541 env.le(keylet::escrow(alice.id(), SeqProxy::rawSequence(escrowSeq))) ==
2545 Env env{*
this, withFix};
2546 env.fund(
XRP(100'000), alice, bob, gw);
2548 auto const issue = makeIssue(env);
2550 auto const badAmount = badMPTAmount(issue, bad);
2551 auto tx = withNonCanonicalMPTAmount(
2553 escrow::create(alice, bob, STAmount{issue, std::uint64_t{1}}),
2554 escrow::kFinishTime(env.now() + 1s)),
2562 testcase(
"fixCleanup3_2_0 rejects non-canonical MPT Clawback amounts");
2564 Env env{*
this, withoutFix};
2565 env.fund(
XRP(100'000), alice, bob, gw);
2567 auto const issue = makeIssue(env);
2569 auto const badAmount = badMPTAmount(issue, bad);
2570 auto tx = withNonCanonicalMPTAmount(
2575 expectRoundTripBadMPT(tx, sfAmount, bad);
2580 MPTValue
const bobAfter = bad.negative ? MPTValue{10'000} : MPTValue{0};
2581 MPTValue
const gwAfter = bad.negative ? MPTValue{-20'000} : MPTValue{-10'000};
2583 (env.balance(alice, issue).value() == STAmount{MPTAmount{10'000}, issue}));
2585 (env.balance(bob, issue).value() == STAmount{MPTAmount{bobAfter}, issue}));
2587 (env.balance(gw, issue).value() == STAmount{MPTAmount{gwAfter}, issue}));
2590 Env env{*
this, withFix};
2591 env.fund(
XRP(100'000), alice, bob, gw);
2593 auto const issue = makeIssue(env);
2595 auto const badAmount = badMPTAmount(issue, bad);
2596 auto tx = withNonCanonicalMPTAmount(
2606 (env.balance(alice, issue).value() == STAmount{MPTAmount{10'000}, issue}));
2608 (env.balance(bob, issue).value() == STAmount{MPTAmount{10'000}, issue}));
2610 (env.balance(gw, issue).value() == STAmount{MPTAmount{-20'000}, issue}));
2613 testcase(
"featureMPTokensV2 disabled rejects MPT OfferCreate amounts");
2615 Env env{*
this, withoutFixAndV2};
2616 env.fund(
XRP(100'000), alice, bob, gw);
2618 auto const issue = makeIssue(env);
2620 auto const badTakerPays = badMPTAmount(issue, bad);
2621 auto tx = withNonCanonicalMPTAmount(
2626 expectRoundTripBadMPT(tx, sfTakerPays, bad);
2631 Env env{*
this, withFixAndWithoutV2};
2632 env.fund(
XRP(100'000), alice, bob, gw);
2634 auto const issue = makeIssue(env);
2636 auto const badTakerPays = badMPTAmount(issue, bad);
2637 auto tx = withNonCanonicalMPTAmount(
2649 Env env{*
this, withFix};
2650 env.fund(
XRP(100'000), alice, bob, gw);
2652 auto const issue = makeIssue(env);
2654 auto const badTakerPays = badMPTAmount(issue, bad);
2655 auto tx = withNonCanonicalMPTAmount(
2667 Env env{*
this, withFix};
2668 env.fund(
XRP(100'000), alice, bob, gw);
2670 auto const issue = makeIssue(env);
2672 auto const badTakerGets = badMPTAmount(issue, bad);
2673 auto tx = withNonCanonicalMPTAmount(
2682 testcase(
"featureMPTokensV2 disabled rejects MPT AMMCreate amounts");
2684 Env env{*
this, withoutFixAndV2};
2685 env.fund(
XRP(100'000), alice, bob, gw);
2687 auto const issue = makeIssue(env);
2689 auto const badAmount = badMPTAmount(issue, bad);
2690 auto tx = withNonCanonicalMPTAmount(
2692 AMM::createJv(alice.id(), STAmount{issue, std::uint64_t{1}},
XRP(1), 0),
2693 Fee(
static_cast<std::uint64_t>(env.current()->fees().increment.drops()))),
2697 expectRoundTripBadMPT(tx, sfAmount, bad);
2702 Env env{*
this, withFixAndWithoutV2};
2703 env.fund(
XRP(100'000), alice, bob, gw);
2705 auto const issue = makeIssue(env);
2707 auto const badAmount = badMPTAmount(issue, bad);
2708 auto tx = withNonCanonicalMPTAmount(
2710 AMM::createJv(alice.id(), STAmount{issue, std::uint64_t{1}},
XRP(1), 0),
2711 Fee(
static_cast<std::uint64_t>(env.current()->fees().increment.drops()))),
2720 Env env{*
this, withFix};
2721 env.fund(
XRP(100'000), alice, bob, gw);
2723 auto const issue = makeIssue(env);
2725 auto const badAmount = badMPTAmount(issue, bad);
2726 auto tx = withNonCanonicalMPTAmount(
2728 AMM::createJv(alice.id(), STAmount{issue, std::uint64_t{1}},
XRP(1), 0),
2729 Fee(
static_cast<std::uint64_t>(env.current()->fees().increment.drops()))),
2737 testcase(
"featureMPTokensV2 disabled rejects MPT AMMDeposit amounts");
2739 Env env{*
this, withoutFixAndV2};
2740 env.fund(
XRP(100'000), alice, bob, gw);
2742 auto const issue = makeIssue(env);
2744 auto const badAmount = badMPTAmount(issue, bad);
2745 auto tx = withNonCanonicalMPTAmount(
2749 .asset1In = STAmount{issue, std::uint64_t{1}},
2752 Fee(
static_cast<std::uint64_t>(env.current()->fees().increment.drops()))),
2756 expectRoundTripBadMPT(tx, sfAmount, bad);
2761 Env env{*
this, withFixAndWithoutV2};
2762 env.fund(
XRP(100'000), alice, bob, gw);
2764 auto const issue = makeIssue(env);
2766 auto const badAmount = badMPTAmount(issue, bad);
2767 auto tx = withNonCanonicalMPTAmount(
2771 .asset1In = STAmount{issue, std::uint64_t{1}},
2774 Fee(
static_cast<std::uint64_t>(env.current()->fees().increment.drops()))),
2783 Env env{*
this, withFix};
2784 env.fund(
XRP(100'000), alice, bob, gw);
2786 auto const issue = makeIssue(env);
2788 auto const badAmount = badMPTAmount(issue, bad);
2789 auto tx = withNonCanonicalMPTAmount(
2793 .asset1In = STAmount{issue, std::uint64_t{1}},
2796 Fee(
static_cast<std::uint64_t>(env.current()->fees().increment.drops()))),
2804 testcase(
"featureMPTokensV2 disabled rejects MPT AMMWithdraw amounts");
2806 Env env{*
this, withoutFixAndV2};
2807 env.fund(
XRP(100'000), alice, bob, gw);
2809 auto const issue = makeIssue(env);
2811 auto const badAmount = badMPTAmount(issue, bad);
2812 auto tx = withNonCanonicalMPTAmount(
2816 .asset1Out = STAmount{issue, std::uint64_t{1}},
2819 Fee(
static_cast<std::uint64_t>(env.current()->fees().increment.drops()))),
2823 expectRoundTripBadMPT(tx, sfAmount, bad);
2828 Env env{*
this, withFixAndWithoutV2};
2829 env.fund(
XRP(100'000), alice, bob, gw);
2831 auto const issue = makeIssue(env);
2833 auto const badAmount = badMPTAmount(issue, bad);
2834 auto tx = withNonCanonicalMPTAmount(
2838 .asset1Out = STAmount{issue, std::uint64_t{1}},
2841 Fee(
static_cast<std::uint64_t>(env.current()->fees().increment.drops()))),
2850 Env env{*
this, withFix};
2851 env.fund(
XRP(100'000), alice, bob, gw);
2853 auto const issue = makeIssue(env);
2855 auto const badAmount = badMPTAmount(issue, bad);
2856 auto tx = withNonCanonicalMPTAmount(
2860 .asset1Out = STAmount{issue, std::uint64_t{1}},
2863 Fee(
static_cast<std::uint64_t>(env.current()->fees().increment.drops()))),
2871 testcase(
"featureMPTokensV2 disabled rejects MPT AMMClawback amounts");
2873 Env env{*
this, withoutFixAndV2};
2874 env.fund(
XRP(100'000), alice, bob, gw);
2876 auto const issue = makeIssue(env);
2878 auto const badAmount = badMPTAmount(issue, bad);
2879 auto tx = withNonCanonicalMPTAmount(
2887 Fee(
static_cast<std::uint64_t>(env.current()->fees().increment.drops()))),
2891 expectRoundTripBadMPT(tx, sfAmount, bad);
2896 Env env{*
this, withFixAndWithoutV2};
2897 env.fund(
XRP(100'000), alice, bob, gw);
2899 auto const issue = makeIssue(env);
2901 auto const badAmount = badMPTAmount(issue, bad);
2902 auto tx = withNonCanonicalMPTAmount(
2910 Fee(
static_cast<std::uint64_t>(env.current()->fees().increment.drops()))),
2919 Env env{*
this, withFix};
2920 env.fund(
XRP(100'000), alice, bob, gw);
2922 auto const issue = makeIssue(env);
2924 auto const badAmount = badMPTAmount(issue, bad);
2925 auto tx = withNonCanonicalMPTAmount(
2933 Fee(
static_cast<std::uint64_t>(env.current()->fees().increment.drops()))),
2941 testcase(
"fixCleanup3_2_0 rejects non-canonical MPT VaultClawback amounts");
2943 Env env{*
this, withFix};
2944 env.fund(
XRP(100'000), alice, bob, gw);
2946 auto const issue = makeIssue(env);
2948 auto const badAmount = badMPTAmount(issue, bad);
2949 UInt256 const fakeVaultId = keylet::vault(gw.id(), SeqProxy::rawSequence(1)).key;
2950 auto tx = withNonCanonicalMPTAmount(
2956 .amount = STAmount{issue, std::uint64_t{1}},
2958 Fee(
static_cast<std::uint64_t>(env.current()->fees().increment.drops()))),
4161 auto const usd = gw[
"USD"];
4164 auto const blockingFlags = {
4165 tfMPTCanTrade | tfMPTCanLock | tfMPTCanClawback,
4166 tfMPTCanTrade | tfMPTRequireAuth,
4168 tfMPTCanTrade | tfMPTCanLock,
4171 for (
auto flags : blockingFlags)
4173 Env env{*
this, features};
4174 env.
fund(
XRP(1'000), gw, alice);
4178 bool const lockMPToken = (flags & (tfMPTCanLock | tfMPTCanClawback)) == tfMPTCanLock;
4179 bool const lockMPTIssue =
4180 (flags & (tfMPTCanLock | tfMPTCanClawback)) == (tfMPTCanLock | tfMPTCanClawback);
4181 bool const requireAuth = (flags & tfMPTRequireAuth) != 0u;
4191 MPT const btc = mptTester;
4194 mptTester.authorize({.account = gw, .holder = alice, .flags = tfMPTUnauthorize});
4197 mptTester.set({.holder = alice, .flags = tfMPTLock});
4199 else if (lockMPTIssue)
4201 mptTester.set({.flags = tfMPTLock});
4205 [&](
Account const& account,
auto const& buy,
auto const& sell,
bool buyUSD) {
4206 auto error = [&](
auto const err) ->
TER {
4221 if (flags & tfMPTCanTransfer)
4226 auto const err = buyUSD ? errBuy : errSell;
4228 auto seq(env.
seq(account));
4229 env(
offer(account, buy(10), sell(10)),
Ter(err));
4234 auto const testOffers = [&](
Account const& account) {
4235 testOffer(account,
XRP, btc,
false);
4236 testOffer(account, btc,
XRP,
true);
4244 Env env{*
this, features - featureMPTokensV2};
4246 MPTTester mptTester(env, gw, {.holders = {alice}});
4248 mptTester.
create({.ownerCount = 1, .holderCount = 0, .flags = tfMPTCanTransfer});
4250 mptTester.authorize({.account = alice});
4251 mptTester.pay(gw, alice, 200);
4260 env.
fund(
XRP(1'000), gw, alice);
4262 MPT const btc =
MPTTester({.env = env, .issuer = gw, .holders = {alice}, .pay = 100});
4263 MPT const eth =
MPT(gw, 1);
4272 env.
fund(
XRP(1'000), gw, alice);
4273 MPTTester const btc({.env = env, .issuer = gw, .holders = {alice}, .pay = 100});
4274 MPTTester const eth({.env = env, .issuer = gw});
4276 env(
offer(alice, eth(10), btc(10)));
4289 env.
fund(
XRP(1'000), gw, gw2, alice, carol, bob, dan);
4293 .holders = {alice, carol, bob, dan, gw},
4300 .holders = {alice, carol, bob, dan, gw2},
4312 btc.set({.holder = alice, .flags = tfMPTLock});
4314 btc.set({.holder = alice, .flags = tfMPTUnlock});
4316 btc.set({.holder = carol, .flags = tfMPTLock});
4318 btc.set({.holder = carol, .flags = tfMPTUnlock});
4320 env(
offer(gw2, eth(1), btc(1)));
4324 eth.set({.holder = alice, .flags = tfMPTLock});
4326 eth.set({.holder = alice, .flags = tfMPTUnlock});
4328 eth.set({.holder = carol, .flags = tfMPTLock});
4330 eth.set({.holder = carol, .flags = tfMPTUnlock});
4332 env(
offer(gw, btc(1), eth(1)));
4337 btc.set({.flags = tfMPTLock});
4341 btc.set({.flags = tfMPTUnlock});
4344 eth.set({.flags = tfMPTLock});
4348 eth.set({.flags = tfMPTUnlock});
4351 env(
offer(alice, eth(1), btc(1)));
4352 env(
offer(carol, btc(1), eth(1)));
4358 env.
fund(
XRP(1'000), gw, alice);
4376 btc.
authorize({.account = gw, .holder = alice, .flags = tfMPTUnauthorize});
4382 env(
offer(gw, eth(10), btc(10)));
4389 env.
fund(
XRP(1'000), gw, alice, carol);
4393 .holders = {alice, carol},
4395 .flags = tfMPTCanTrade | tfMPTCanTransfer,
4400 .holders = {alice, carol},
4402 .flags = tfMPTCanTrade,
4406 env(
offer(alice, eth(10), btc(10)),
Txflags(tfPassive));
4414 env(
offer(carol, btc(10), eth(10)));
4419 env(
offer(alice, eth(10), btc(10)),
Txflags(tfPassive));
4420 env(
offer(carol, btc(10), eth(10)));
4428 env.
fund(
XRP(1'000), gw, alice, carol);
4432 .holders = {alice, carol},
4434 .flags = tfMPTCanTransfer,
4440 .holders = {alice, carol},
4442 .flags = tfMPTCanTrade,
4453 Env env{*
this, features};
4455 MPTTester mptTester(env, gw, {.holders = {alice, carol}});
4458 {.ownerCount = 1, .holderCount = 0, .flags = tfMPTCanTransfer | tfMPTCanTrade});
4459 auto const mpt = mptTester[
"MPT"];
4461 mptTester.authorize({.account = alice});
4462 mptTester.pay(gw, alice, 200);
4464 mptTester.authorize({.account = carol});
4465 mptTester.pay(gw, carol, 200);
4467 env(
offer(alice,
XRP(100), mpt(101)));
4471 env(
offer(carol, mpt(101),
XRP(100)));
4475 BEAST_EXPECT(mptTester.checkMPTokenOutstandingAmount(400));
4476 BEAST_EXPECT(mptTester.checkMPTokenAmount(alice, 99));
4477 BEAST_EXPECT(mptTester.checkMPTokenAmount(carol, 301));
4482 Env env{*
this, features};
4484 MPTTester mptTester(env, gw, {.holders = {alice, carol}});
4487 {.ownerCount = 1, .holderCount = 0, .flags = tfMPTCanTransfer | tfMPTCanTrade});
4488 auto const mpt = mptTester[
"MPT"];
4490 env(
trust(alice, usd(2'000)));
4491 env(
pay(gw, alice, usd(1'000)));
4494 env(
trust(carol, usd(2'000)));
4495 env(
pay(gw, carol, usd(1'000)));
4498 mptTester.authorize({.account = alice});
4499 mptTester.pay(gw, alice, 200);
4501 mptTester.authorize({.account = carol});
4502 mptTester.pay(gw, carol, 200);
4504 env(
offer(alice, usd(100), mpt(101)));
4508 env(
offer(carol, mpt(101), usd(100)));
4511 BEAST_EXPECT(env.
balance(alice, usd) == usd(1'100));
4512 BEAST_EXPECT(env.
balance(carol, usd) == usd(900));
4515 BEAST_EXPECT(mptTester.checkMPTokenOutstandingAmount(400));
4516 BEAST_EXPECT(mptTester.checkMPTokenAmount(alice, 99));
4517 BEAST_EXPECT(mptTester.checkMPTokenAmount(carol, 301));
4522 Env env{*
this, features};
4524 MPTTester mptTester1(env, gw, {.holders = {alice, carol}});
4526 {.ownerCount = 1, .holderCount = 0, .flags = tfMPTCanTransfer | tfMPTCanTrade});
4527 auto const mpt1 = mptTester1[
"MPT1"];
4529 MPTTester mptTester2(env, gw, {.holders = {alice, carol}, .fund =
false});
4531 {.ownerCount = 2, .holderCount = 0, .flags = tfMPTCanTransfer | tfMPTCanTrade});
4532 auto const mpt2 = mptTester2[
"MPT2"];
4534 mptTester1.authorize({.account = alice});
4535 mptTester1.authorize({.account = carol});
4536 mptTester1.pay(gw, alice, 200);
4537 mptTester1.pay(gw, carol, 200);
4539 mptTester2.authorize({.account = alice});
4540 mptTester2.authorize({.account = carol});
4541 mptTester2.pay(gw, alice, 200);
4542 mptTester2.pay(gw, carol, 200);
4544 env(
offer(alice, mpt2(100), mpt1(101)));
4548 env(
offer(carol, mpt1(101), mpt2(100)));
4553 BEAST_EXPECT(mptTester1.checkMPTokenOutstandingAmount(400));
4554 BEAST_EXPECT(mptTester1.checkMPTokenAmount(alice, 99));
4555 BEAST_EXPECT(mptTester1.checkMPTokenAmount(carol, 301));
4556 BEAST_EXPECT(mptTester2.checkMPTokenOutstandingAmount(400));
4557 BEAST_EXPECT(mptTester2.checkMPTokenAmount(alice, 300));
4558 BEAST_EXPECT(mptTester2.checkMPTokenAmount(carol, 100));
4572 auto const usd = gw[
"USD"];
4576 Env env{*
this, features};
4577 MPTTester mptTester(env, gw, {.holders = {carol, bob}});
4580 {.ownerCount = 1, .holderCount = 0, .flags = tfMPTCanTransfer | tfMPTCanTrade});
4581 auto const mpt = mptTester[
"MPT"];
4583 mptTester.authorize({.account = carol});
4584 mptTester.pay(gw, carol, 200);
4586 mptTester.authorize({.account = bob});
4589 env(
pay(carol, bob, mpt(1)),
4597 env(
pay(gw, bob, mpt(1)),
4605 env(
pay(bob, gw, mpt(1)),
4615 Env env{*
this, features};
4616 MPTTester mptTester(env, gw, {.holders = {carol, bob}});
4619 {.ownerCount = 1, .holderCount = 0, .flags = tfMPTCanTransfer | tfMPTCanTrade});
4620 auto const mpt = mptTester[
"MPT"];
4622 mptTester.authorize({.account = carol});
4623 mptTester.pay(gw, carol, 200);
4625 mptTester.authorize({.account = bob});
4628 env(
pay(carol, bob, mpt(1)),
4636 env(
pay(gw, bob, mpt(1)),
4644 env(
pay(bob, gw, mpt(1)),
4654 Env env{*
this, features - featureMPTokensV2};
4656 MPTTester mptTester(env, gw, {.holders = {alice}});
4659 {.ownerCount = 1, .holderCount = 0, .flags = tfMPTCanTransfer | tfMPTCanTrade});
4660 auto const mpt = mptTester[
"MPT"];
4662 mptTester.authorize({.account = alice});
4664 env(
pay(gw, alice, mpt(101)),
4672 auto const ed =
Account{
"ed"};
4673 Env env{*
this, features};
4674 env.
fund(
XRP(1'000), gw, alice, carol, bob, ed);
4678 .holders = {alice, carol, bob},
4685 .holders = {alice, carol, bob},
4692 .holders = {alice, carol, bob},
4699 .holders = {alice, carol, bob},
4704 env(
offer(bob, eth(1'000), btc(1'000)),
Txflags(tfPassive));
4706 env(
offer(bob, btc(1'000), eth(1'000)),
Txflags(tfPassive));
4727 btc.authorize({.account = ed});
4728 eth.authorize({.account = ed});
4729 env(
pay(gw, ed, eth(100)));
4730 env(
pay(gw, ed, btc(100)));
4732 btc.set({.flags = tfMPTSetRequireAuth});
4734 btc.authorize({.account = gw, .holder = bob});
4752 auto const ed =
Account{
"ed"};
4753 Env env{*
this, features};
4754 env.
fund(
XRP(1'000), gw, alice, carol, bob, ed);
4758 .holders = {alice, carol, bob, ed},
4760 .flags = tfMPTCanTrade,
4765 .holders = {alice, carol, bob, ed},
4770 env(
offer(bob, eth(1'000), btc(1'000)),
Txflags(tfPassive));
4772 env(
offer(bob, btc(1'000), eth(1'000)),
Txflags(tfPassive));
4788 env(
offer(gw, eth(100), btc(100)),
Txflags(tfPassive));
4790 env(
offer(gw, btc(100), eth(100)),
Txflags(tfPassive));
4815 enum class NoTransferMPT { BTC, ETH, USD, CAD };
4818 auto const testMultiStepMPTCanTransfer = [&](NoTransferMPT
const noTransferMPT,
4820 auto const getFlags = [&](NoTransferMPT
const mpt) {
4821 return mpt == noTransferMPT ? tfMPTCanTrade :
kMptDexFlags;
4824 Env env{*
this, features};
4825 env.
fund(
XRP(1'000), gw, alice, carol, bob);
4830 .holders = {alice, carol, bob},
4832 .flags = getFlags(NoTransferMPT::BTC),
4837 .holders = {alice, carol, bob},
4839 .flags = getFlags(NoTransferMPT::ETH),
4844 .holders = {alice, carol, bob},
4846 .flags = getFlags(NoTransferMPT::USD),
4851 .holders = {alice, carol, bob},
4853 .flags = getFlags(NoTransferMPT::CAD),
4856 env(
offer(bob, cad(100), usd(100)),
Txflags(tfPassive));
4857 env(
offer(bob, usd(100), btc(100)),
Txflags(tfPassive));
4858 env(
offer(bob, btc(100), eth(100)),
Txflags(tfPassive));
4861 test(env, btc, eth, usd, cad);
4865 testMultiStepMPTCanTransfer(
4875 env(
pay(alice, carol, eth(1)),
4876 Path(~usd, ~btc, ~eth),
4880 auto seq(env.
seq(gw));
4884 env(
pay(alice, carol, eth(1)),
4885 Path(~usd, ~btc, ~eth),
4894 env(
pay(alice, carol, eth(1)),
Path(~usd, ~btc, ~eth),
Sendmax(cad(1)));
4898 env(
offer(bob, cad(100), usd(100)),
Txflags(tfPassive));
4903 testMultiStepMPTCanTransfer(
4911 env(
pay(alice, carol, eth(1)),
4912 Path(~usd, ~btc, ~eth),
4919 env(
pay(alice, gw, eth(1)),
Path(~usd, ~btc, ~eth),
Sendmax(cad(1)));
4925 testMultiStepMPTCanTransfer(
4933 env(
pay(alice, carol, eth(1)),
4934 Path(~usd, ~btc, ~eth),
4938 env(
pay(gw, carol, eth(1)),
Path(~usd, ~btc, ~eth),
Sendmax(cad(1)));
4943 env(
pay(alice, carol, eth(1)),
Path(~usd, ~btc, ~eth),
Sendmax(cad(1)));
4950 testMultiStepMPTCanTransfer(
4960 env(
pay(alice, carol, eth(1)),
Path(~usd, ~btc, ~eth),
Sendmax(cad(1)));
4968 Env env{*
this, features};
4969 env.
fund(
XRP(1'000), gw, alice, carol, bob);
4974 .holders = {alice, carol, bob},
4976 .flags = tfMPTCanTransfer,
4981 .holders = {alice, carol, bob},
4988 .holders = {alice, carol, bob},
4998 btc.set({.flags = tfMPTSetCanTrade});
5000 env(
offer(bob, btc(1), eth(1)));
5001 env(
offer(bob, eth(1), usd(1)));
5005 env(
pay(gw, carol, usd(1)),
5006 Path(~btc, ~eth, ~usd),
5008 Txflags(tfPartialPayment | tfNoRippleDirect));
5015 enum class LockType { Global, Individual,
None };
5021 LockType srcFlag = LockType::None;
5022 LockType dstFlag = LockType::None;
5023 LockType offerFlagBuy = LockType::None;
5024 LockType offerFlagSell = LockType::None;
5025 LockType globalFlagBuy = LockType::None;
5026 LockType globalFlagSell = LockType::None;
5030 auto getErr = [&]<
typename Token>(Token
const&, TestArg
const&
arg) {
5033 return arg.errIOU.value_or(
arg.err);
5040 auto const getMPT = [&](
Env& env) {
5044 .holders = {alice, carol, bob, gw},
5051 .holders = {alice, carol, bob, gw2},
5057 auto const getIOU = [&](
Env& env) {
5058 for (
auto const& a : {alice, carol, bob})
5060 env(
fset(a, asfDefaultRipple));
5062 env(
trust(a, gw[
"ETH"](200)));
5063 env(
pay(gw, a, gw[
"ETH"](100)));
5064 env(
trust(a, gw2[
"BTC"](200)));
5065 env(
pay(gw2, a, gw2[
"BTC"](100)));
5070 env(
trust(gw2, gw[
"ETH"](200)));
5071 env(
trust(gw, gw2[
"BTC"](200)));
5072 env(
pay(gw2, gw, gw2[
"BTC"](100)));
5076 auto lock = [&]<
typename Token>(
5078 if (
lock == LockType::None)
5082 if (
lock == LockType::Global)
5084 env(
fset(
token.account, asfGlobalFreeze));
5088 IOU const iou{account,
token.currency};
5089 env(
trust(
token.account, iou(0), tfSetFreeze));
5094 if (
lock == LockType::Global)
5096 token.set({.flags = tfMPTLock});
5098 else if (
token.issuer() != account)
5100 token.set({.holder = account, .flags = tfMPTLock});
5104 auto const test = [&](
auto&& getTokens, TestArg
const&
arg) {
5106 env.
fund(
XRP(1'000), gw, gw2, alice, carol, bob);
5108 auto [btc, eth] = getTokens(env);
5113 if (
arg.globalFlagBuy != LockType::None)
5115 lock(env, gw, eth, LockType::Global);
5119 lock(env,
arg.offerOwner, eth,
arg.offerFlagBuy);
5122 if (
arg.globalFlagSell != LockType::None)
5124 lock(env, gw2, btc, LockType::Global);
5128 lock(env,
arg.offerOwner, btc,
arg.offerFlagSell);
5132 auto const err = getErr(eth,
arg);
5144 {.src = alice, .dst = carol, .offerOwner = bob, .srcFlag = LockType::Individual, .err =
tecPATH_DRY},
5146 {.src = alice, .dst = carol, .offerOwner = bob, .dstFlag = LockType::Individual, .err =
tecPATH_DRY, .errIOU =
tesSUCCESS},
5148 {.src = alice, .dst = carol, .offerOwner = bob, .globalFlagBuy = LockType::Global, .err =
tecPATH_DRY},
5150 {.src = alice, .dst = carol, .offerOwner = bob, .globalFlagSell = LockType::Global, .err =
tecPATH_PARTIAL},
5152 {.src = alice, .dst = carol, .offerOwner = bob, .offerFlagBuy = LockType::Individual, .err =
tecPATH_PARTIAL, .errIOU =
tesSUCCESS},
5154 {.src = alice, .dst = carol, .offerOwner = bob, .offerFlagSell = LockType::Individual, .err =
tecPATH_PARTIAL},
5157 {.src = alice, .dst = carol, .offerOwner = gw2, .srcFlag = LockType::Individual, .err =
tecPATH_DRY},
5159 {.src = alice, .dst = carol, .offerOwner = gw2, .dstFlag = LockType::Individual, .err =
tecPATH_DRY, .errIOU =
tesSUCCESS},
5161 {.src = alice, .dst = carol, .offerOwner = gw2, .globalFlagBuy = LockType::Global, .err =
tecPATH_DRY},
5163 {.src = alice, .dst = carol, .offerOwner = gw2, .globalFlagSell = LockType::Global, .err =
tesSUCCESS},
5166 {.src = alice, .dst = carol, .offerOwner = gw, .srcFlag = LockType::Individual, .err =
tecPATH_DRY},
5168 {.src = alice, .dst = carol, .offerOwner = gw, .dstFlag = LockType::Individual, .err =
tecPATH_DRY, .errIOU =
tesSUCCESS},
5170 {.src = alice, .dst = carol, .offerOwner = gw, .globalFlagBuy = LockType::Global, .err =
tecPATH_DRY},
5172 {.src = alice, .dst = carol, .offerOwner = gw, .globalFlagSell = LockType::Global, .err =
tecPATH_PARTIAL},
5176 {.src = gw, .dst = carol, .offerOwner = bob, .srcFlag = LockType::Global, .err =
tecPATH_PARTIAL, .errIOU =
tesSUCCESS},
5178 {.src = gw, .dst = carol, .offerOwner = bob, .dstFlag = LockType::Global, .err =
tecPATH_PARTIAL},
5180 {.src = gw, .dst = carol, .offerOwner = bob, .dstFlag = LockType::Individual, .err =
tecPATH_DRY, .errIOU =
tesSUCCESS},
5182 {.src = gw, .dst = carol, .offerOwner = bob, .offerFlagBuy = LockType::Individual, .err =
tecPATH_PARTIAL, .errIOU =
tesSUCCESS},
5184 {.src = gw, .dst = carol, .offerOwner = bob, .offerFlagSell = LockType::Individual, .err =
tecPATH_PARTIAL},
5187 {.src = alice, .dst = gw2, .offerOwner = bob, .srcFlag = LockType::Individual, .err =
tecPATH_DRY},
5189 {.src = alice, .dst = gw2, .offerOwner = bob, .dstFlag = LockType::Global, .err =
tecPATH_PARTIAL},
5191 {.src = alice, .dst = gw2, .offerOwner = bob, .offerFlagBuy = LockType::Individual, .err =
tecPATH_PARTIAL, .errIOU =
tesSUCCESS},
5193 {.src = alice, .dst = gw2, .offerOwner = bob, .offerFlagSell = LockType::Individual, .err =
tecPATH_PARTIAL},
5197 for (
auto const& t :
tests)
5205 auto const usd = gw[
"USD"];
5206 env.
fund(
XRP(1'000), gw, alice, carol, bob);
5210 .holders = {alice, carol, bob},
5217 .holders = {alice, carol, bob},
5222 env(
trust(alice, usd(100)));
5223 env(
pay(gw, alice, usd(100)));
5224 env(
trust(carol, usd(100)));
5226 env(
offer(alice,
XRP(10), eth(10)));
5227 env(
offer(bob, eth(10), btc(10)));
5228 env(
offer(alice, btc(10), usd(10)));
5231 btc.set({.holder = bob, .flags = tfMPTLock});
5234 env(
pay(alice, carol, usd(1)),
5236 Txflags(tfNoRippleDirect | tfPartialPayment),
5241 btc.set({.holder = bob, .flags = tfMPTUnlock});
5242 eth.set({.holder = bob, .flags = tfMPTLock});
5244 env(
pay(alice, carol, usd(1)),
5246 Txflags(tfNoRippleDirect | tfPartialPayment),
5254 Env env(*
this, features);
5255 Account const domainOwner(
"DomainOwner");
5256 env.
fund(
XRP(1'000), gw, alice, carol, bob);
5257 auto const domainID =
5258 setupDomain(env, {alice, bob, carol, gw}, domainOwner,
"permdex-cred");
5260 MPTTester btc({.env = env, .issuer = gw, .holders = {alice, carol, bob}, .pay = 100});
5261 MPTTester eth({.env = env, .issuer = gw, .holders = {alice, carol, bob}, .pay = 100});
5263 auto const test = [&](
bool withDomain) {
5266 env(
offer(bob, eth(1), btc(1)),
Domain(domainID));
5270 env(
offer(bob, eth(1), btc(1)));
5274 env(
pay(alice, carol, btc(1)),
5288 Env env(*
this, features);
5289 Account const domainOwner(
"DomainOwner");
5290 env.
fund(
XRP(1'000), gw, alice, carol, bob);
5291 auto const domainID =
5292 setupDomain(env, {alice, bob, carol, gw}, domainOwner,
"permdex-cred");
5294 MPTTester btc({.env = env, .issuer = gw, .holders = {alice, carol, bob}, .pay = 100});
5295 MPTTester eth({.env = env, .issuer = gw, .holders = {alice, carol, bob}, .pay = 100});
5297 auto const test = [&](
bool isHybrid) {
5298 auto const flags = isHybrid ? tfHybrid : 0;
5302 env(
pay(alice, carol, btc(1)),
5314 Env env{*
this, features};
5315 MPTTester mptTester(env, gw, {.holders = {alice, carol, bob}});
5318 {.ownerCount = 1, .holderCount = 0, .flags = tfMPTCanTransfer | tfMPTCanTrade});
5319 auto const mpt = mptTester[
"MPT"];
5321 mptTester.authorize({.account = alice});
5322 mptTester.pay(gw, alice, 200);
5324 mptTester.authorize({.account = carol});
5325 mptTester.pay(gw, carol, 200);
5327 mptTester.authorize({.account = bob});
5329 env(
offer(alice,
XRP(100), mpt(101)));
5333 env(
pay(carol, bob, mpt(101)),
5340 BEAST_EXPECT(mptTester.checkMPTokenOutstandingAmount(400));
5341 BEAST_EXPECT(mptTester.checkMPTokenAmount(alice, 99));
5342 BEAST_EXPECT(mptTester.checkMPTokenAmount(bob, 101));
5347 Env env{*
this, features};
5349 MPTTester mptTester(env, gw, {.holders = {alice, carol, bob}});
5352 {.ownerCount = 1, .holderCount = 0, .flags = tfMPTCanTransfer | tfMPTCanTrade});
5353 auto const mpt = mptTester[
"MPT"];
5355 env(
trust(alice, usd(2'000)));
5356 env(
pay(gw, alice, usd(1'000)));
5357 env(
trust(bob, usd(2'000)));
5358 env(
pay(gw, bob, usd(1'000)));
5359 env(
trust(carol, usd(2'000)));
5360 env(
pay(gw, carol, usd(1'000)));
5363 mptTester.authorize({.account = alice});
5364 mptTester.pay(gw, alice, 200);
5366 mptTester.authorize({.account = carol});
5367 mptTester.pay(gw, carol, 200);
5369 mptTester.authorize({.account = bob});
5371 env(
offer(alice, usd(100), mpt(101)));
5375 env(
pay(carol, bob, mpt(101)),
5382 BEAST_EXPECT(env.
balance(carol, usd) == usd(900));
5383 BEAST_EXPECT(mptTester.checkMPTokenOutstandingAmount(400));
5384 BEAST_EXPECT(mptTester.checkMPTokenAmount(alice, 99));
5385 BEAST_EXPECT(mptTester.checkMPTokenAmount(bob, 101));
5390 Env env{*
this, features};
5392 MPTTester mptTester(env, gw, {.holders = {alice, carol, bob}});
5395 {.ownerCount = 1, .holderCount = 0, .flags = tfMPTCanTransfer | tfMPTCanTrade});
5396 auto const mpt = mptTester[
"MPT"];
5398 env(
trust(alice, usd(2'000)),
Txflags(tfClearNoRipple));
5399 env(
pay(gw, alice, usd(1'000)));
5403 mptTester.authorize({.account = alice});
5404 env(
pay(gw, alice, mpt(200)));
5406 mptTester.authorize({.account = carol});
5407 env(
pay(gw, carol, mpt(200)));
5409 env(
offer(alice, mpt(101), usd(100)));
5413 env(
pay(carol, bob, usd(100)),
5416 Txflags(tfPartialPayment | tfNoRippleDirect));
5420 BEAST_EXPECT(env.
balance(alice, usd) == usd(900));
5421 BEAST_EXPECT(mptTester.checkMPTokenAmount(alice, 301));
5422 BEAST_EXPECT(mptTester.checkMPTokenOutstandingAmount(400));
5423 BEAST_EXPECT(mptTester.checkMPTokenAmount(carol, 99));
5424 BEAST_EXPECT(env.
balance(bob, usd) == usd(100));
5429 Env env{*
this, features};
5431 MPTTester mptTester1(env, gw, {.holders = {alice, carol, bob}});
5433 {.ownerCount = 1, .holderCount = 0, .flags = tfMPTCanTransfer | tfMPTCanTrade});
5434 auto const mpt1 = mptTester1[
"MPT1"];
5436 MPTTester mptTester2(env, gw, {.holders = {alice, carol, bob}, .fund =
false});
5438 {.ownerCount = 2, .holderCount = 0, .flags = tfMPTCanTransfer | tfMPTCanTrade});
5439 auto const mpt2 = mptTester2[
"MPT2"];
5441 mptTester1.authorize({.account = alice});
5442 mptTester1.pay(gw, alice, 200);
5443 mptTester2.authorize({.account = alice});
5445 mptTester2.authorize({.account = carol});
5446 mptTester2.pay(gw, carol, 200);
5448 mptTester1.authorize({.account = bob});
5449 mptTester2.authorize({.account = bob});
5450 mptTester2.pay(gw, bob, 200);
5452 env(
offer(alice, mpt2(100), mpt1(100)));
5458 env(
pay(carol, bob, mpt1(10)),
5465 BEAST_EXPECT(mptTester1.checkMPTokenAmount(alice, 190));
5466 BEAST_EXPECT(mptTester2.checkMPTokenAmount(alice, 10));
5467 BEAST_EXPECT(mptTester1.checkMPTokenOutstandingAmount(200));
5468 BEAST_EXPECT(mptTester2.checkMPTokenOutstandingAmount(400));
5469 BEAST_EXPECT(mptTester2.checkMPTokenAmount(carol, 190));
5470 BEAST_EXPECT(mptTester1.checkMPTokenAmount(bob, 10));
5473 env(
pay(gw, bob, mpt1(20)),
5480 BEAST_EXPECT(mptTester1.checkMPTokenAmount(alice, 170));
5481 BEAST_EXPECT(mptTester2.checkMPTokenAmount(alice, 30));
5482 BEAST_EXPECT(mptTester1.checkMPTokenOutstandingAmount(200));
5483 BEAST_EXPECT(mptTester2.checkMPTokenOutstandingAmount(420));
5484 BEAST_EXPECT(mptTester2.checkMPTokenAmount(carol, 190));
5485 BEAST_EXPECT(mptTester1.checkMPTokenAmount(bob, 30));
5488 env(
pay(bob, gw, mpt1(70)),
5495 BEAST_EXPECT(mptTester1.checkMPTokenAmount(alice, 100));
5496 BEAST_EXPECT(mptTester2.checkMPTokenAmount(alice, 100));
5497 BEAST_EXPECT(mptTester1.checkMPTokenOutstandingAmount(130));
5498 BEAST_EXPECT(mptTester2.checkMPTokenOutstandingAmount(420));
5499 BEAST_EXPECT(mptTester2.checkMPTokenAmount(carol, 190));
5500 BEAST_EXPECT(mptTester1.checkMPTokenAmount(bob, 30));
5501 BEAST_EXPECT(mptTester2.checkMPTokenAmount(bob, 130));
5506 Env env{*
this, features};
5508 MPTTester mptTester1(env, gw, {.holders = {carol, bob}});
5510 {.ownerCount = 1, .holderCount = 0, .flags = tfMPTCanTransfer | tfMPTCanTrade});
5511 auto const mpt1 = mptTester1[
"MPT1"];
5513 MPTTester mptTester2(env, gw, {.holders = {carol, bob}, .fund =
false});
5515 {.ownerCount = 2, .holderCount = 0, .flags = tfMPTCanTransfer | tfMPTCanTrade});
5516 auto const mpt2 = mptTester2[
"MPT2"];
5518 mptTester2.authorize({.account = carol});
5519 mptTester2.pay(gw, carol, 200);
5521 mptTester1.authorize({.account = bob});
5522 mptTester2.authorize({.account = bob});
5523 mptTester2.pay(gw, bob, 200);
5525 env(
offer(gw, mpt2(100), mpt1(100)));
5530 env(
pay(carol, bob, mpt1(10)),
5537 BEAST_EXPECT(mptTester1.checkMPTokenOutstandingAmount(10));
5538 BEAST_EXPECT(mptTester2.checkMPTokenOutstandingAmount(390));
5539 BEAST_EXPECT(mptTester2.checkMPTokenAmount(carol, 190));
5540 BEAST_EXPECT(mptTester1.checkMPTokenAmount(bob, 10));
5543 env(
pay(gw, bob, mpt1(20)),
5550 BEAST_EXPECT(mptTester1.checkMPTokenOutstandingAmount(30));
5551 BEAST_EXPECT(mptTester2.checkMPTokenOutstandingAmount(390));
5552 BEAST_EXPECT(mptTester2.checkMPTokenAmount(carol, 190));
5553 BEAST_EXPECT(mptTester1.checkMPTokenAmount(bob, 30));
5556 env(
pay(bob, gw, mpt1(70)),
5563 BEAST_EXPECT(mptTester1.checkMPTokenOutstandingAmount(30));
5564 BEAST_EXPECT(mptTester2.checkMPTokenOutstandingAmount(320));
5565 BEAST_EXPECT(mptTester2.checkMPTokenAmount(carol, 190));
5566 BEAST_EXPECT(mptTester1.checkMPTokenAmount(bob, 30));
5567 BEAST_EXPECT(mptTester2.checkMPTokenAmount(bob, 130));
5572 Env env{*
this, features};
5575 MPTTester mptTester1(env, gw, {.holders = {alice, carol, bob}});
5577 {.ownerCount = 1, .holderCount = 0, .flags = tfMPTCanTransfer | tfMPTCanTrade});
5578 auto const mpt1 = mptTester1[
"MPT1"];
5581 MPTTester mptTester2(env, gw1, {.holders = {alice, carol, bob}, .fund =
false});
5583 {.ownerCount = 1, .holderCount = 0, .flags = tfMPTCanTransfer | tfMPTCanTrade});
5584 auto const mpt2 = mptTester2[
"MPT2"];
5586 mptTester1.authorize({.account = alice});
5587 mptTester1.pay(gw, alice, 200);
5588 mptTester2.authorize({.account = alice});
5590 mptTester2.authorize({.account = carol});
5591 mptTester2.pay(gw1, carol, 200);
5593 mptTester1.authorize({.account = bob});
5594 mptTester1.pay(gw, bob, 200);
5595 mptTester2.authorize({.account = bob});
5596 mptTester2.pay(gw1, bob, 200);
5598 mptTester1.authorize({.account = gw1});
5599 mptTester1.pay(gw, gw1, 200);
5601 mptTester2.authorize({.account = gw});
5602 mptTester2.pay(gw1, gw, 200);
5604 env(
offer(alice, mpt2(100), mpt1(100)));
5608 env(
pay(carol, bob, mpt1(10)),
5614 BEAST_EXPECT(mptTester1.checkMPTokenOutstandingAmount(600));
5615 BEAST_EXPECT(mptTester2.checkMPTokenOutstandingAmount(600));
5616 BEAST_EXPECT(mptTester1.checkMPTokenAmount(gw1, 200));
5617 BEAST_EXPECT(mptTester2.checkMPTokenAmount(gw, 200));
5618 BEAST_EXPECT(mptTester2.checkMPTokenAmount(carol, 190));
5619 BEAST_EXPECT(mptTester1.checkMPTokenAmount(bob, 210));
5620 BEAST_EXPECT(mptTester2.checkMPTokenAmount(bob, 200));
5621 BEAST_EXPECT(mptTester1.checkMPTokenAmount(alice, 190));
5622 BEAST_EXPECT(mptTester2.checkMPTokenAmount(alice, 10));
5624 env(
pay(bob, gw, mpt1(10)),
5630 BEAST_EXPECT(mptTester1.checkMPTokenOutstandingAmount(590));
5631 BEAST_EXPECT(mptTester2.checkMPTokenOutstandingAmount(600));
5632 BEAST_EXPECT(mptTester1.checkMPTokenAmount(gw1, 200));
5633 BEAST_EXPECT(mptTester2.checkMPTokenAmount(gw, 200));
5634 BEAST_EXPECT(mptTester1.checkMPTokenAmount(bob, 210));
5635 BEAST_EXPECT(mptTester2.checkMPTokenAmount(bob, 190));
5636 BEAST_EXPECT(mptTester1.checkMPTokenAmount(alice, 180));
5637 BEAST_EXPECT(mptTester2.checkMPTokenAmount(alice, 20));
5639 env(
pay(gw, bob, mpt1(10)),
5645 BEAST_EXPECT(mptTester1.checkMPTokenOutstandingAmount(590));
5646 BEAST_EXPECT(mptTester2.checkMPTokenOutstandingAmount(600));
5647 BEAST_EXPECT(mptTester1.checkMPTokenAmount(gw1, 200));
5648 BEAST_EXPECT(mptTester2.checkMPTokenAmount(gw, 190));
5649 BEAST_EXPECT(mptTester1.checkMPTokenAmount(bob, 220));
5650 BEAST_EXPECT(mptTester2.checkMPTokenAmount(bob, 190));
5651 BEAST_EXPECT(mptTester1.checkMPTokenAmount(alice, 170));
5652 BEAST_EXPECT(mptTester2.checkMPTokenAmount(alice, 30));
5654 env(
pay(bob, gw1, mpt1(10)),
5660 BEAST_EXPECT(mptTester1.checkMPTokenOutstandingAmount(590));
5661 BEAST_EXPECT(mptTester2.checkMPTokenOutstandingAmount(600));
5662 BEAST_EXPECT(mptTester1.checkMPTokenAmount(gw1, 210));
5663 BEAST_EXPECT(mptTester2.checkMPTokenAmount(gw, 190));
5664 BEAST_EXPECT(mptTester1.checkMPTokenAmount(bob, 220));
5665 BEAST_EXPECT(mptTester2.checkMPTokenAmount(bob, 180));
5666 BEAST_EXPECT(mptTester1.checkMPTokenAmount(alice, 160));
5667 BEAST_EXPECT(mptTester2.checkMPTokenAmount(alice, 40));
5669 env(
pay(gw1, bob, mpt1(10)),
5675 BEAST_EXPECT(mptTester1.checkMPTokenOutstandingAmount(590));
5676 BEAST_EXPECT(mptTester2.checkMPTokenOutstandingAmount(610));
5677 BEAST_EXPECT(mptTester1.checkMPTokenAmount(gw1, 210));
5678 BEAST_EXPECT(mptTester2.checkMPTokenAmount(gw, 190));
5679 BEAST_EXPECT(mptTester1.checkMPTokenAmount(bob, 230));
5680 BEAST_EXPECT(mptTester2.checkMPTokenAmount(bob, 180));
5681 BEAST_EXPECT(mptTester1.checkMPTokenAmount(alice, 150));
5682 BEAST_EXPECT(mptTester2.checkMPTokenAmount(alice, 50));
5684 env(
pay(gw, gw1, mpt1(10)),
5690 BEAST_EXPECT(mptTester1.checkMPTokenOutstandingAmount(590));
5691 BEAST_EXPECT(mptTester2.checkMPTokenOutstandingAmount(610));
5692 BEAST_EXPECT(mptTester1.checkMPTokenAmount(gw1, 220));
5693 BEAST_EXPECT(mptTester2.checkMPTokenAmount(gw, 180));
5694 BEAST_EXPECT(mptTester1.checkMPTokenAmount(alice, 140));
5695 BEAST_EXPECT(mptTester2.checkMPTokenAmount(alice, 60));
5697 env(
pay(gw1, gw, mpt1(40)),
5703 BEAST_EXPECT(mptTester1.checkMPTokenOutstandingAmount(550));
5704 BEAST_EXPECT(mptTester2.checkMPTokenOutstandingAmount(650));
5705 BEAST_EXPECT(mptTester1.checkMPTokenAmount(gw1, 220));
5706 BEAST_EXPECT(mptTester2.checkMPTokenAmount(gw, 180));
5707 BEAST_EXPECT(mptTester1.checkMPTokenAmount(alice, 100));
5708 BEAST_EXPECT(mptTester2.checkMPTokenAmount(alice, 100));
5718 auto const usd = gw2[
"USD"];
5720 MPTTester mptTester(env, gw, {.holders = {alice, carol}});
5722 {.ownerCount = 1, .holderCount = 0, .flags = tfMPTCanTransfer | tfMPTCanTrade});
5723 auto const mpt = mptTester[
"MPT"];
5724 mptTester.authorize({.account = alice});
5725 mptTester.authorize({.account = carol});
5726 mptTester.pay(gw, carol, 200);
5728 MPTTester mptTester1(env, gw1, {.holders = {bob, dan}});
5730 {.ownerCount = 1, .holderCount = 0, .flags = tfMPTCanTransfer | tfMPTCanTrade});
5731 auto const mpt1 = mptTester1[
"MPT1"];
5732 mptTester1.authorize({.account = bob});
5733 mptTester1.pay(gw1, bob, 200);
5734 mptTester1.authorize({.account = dan});
5736 env(
trust(alice, usd(400)));
5737 env(
pay(gw2, alice, usd(200)));
5738 env(
trust(bob, usd(400)));
5740 env(
offer(alice, mpt(100), usd(100)));
5741 env(
offer(bob, usd(100), mpt1(100)));
5744 env(
pay(carol, dan, mpt1(100)),
5747 Txflags(tfPartialPayment | tfNoRippleDirect));
5751 BEAST_EXPECT(mptTester.checkMPTokenAmount(carol, 100));
5752 BEAST_EXPECT(mptTester1.checkMPTokenAmount(dan, 100));
5757 Env env{*
this, features};
5759 fund(env, gw, {alice, carol, bob},
XRP(11'000), {usd(20'000)});
5761 MPTTester mptTester(env, gw, {.fund =
false});
5764 {.ownerCount = 1, .holderCount = 0, .flags = tfMPTCanTransfer | tfMPTCanTrade});
5765 auto const mpt = mptTester[
"MPT"];
5767 mptTester.authorize({.account = alice});
5768 mptTester.authorize({.account = bob});
5769 mptTester.pay(gw, alice, 10'100);
5771 AMM const amm(env, alice,
XRP(10'000), mpt(10'100));
5773 env(
pay(carol, bob, mpt(100)),
5776 Txflags(tfPartialPayment | tfNoRippleDirect));
5779 BEAST_EXPECT(
amm.expectBalances(
XRP(10'100), mpt(10'000),
amm.tokens()));
5780 BEAST_EXPECT(mptTester.checkMPTokenAmount(bob, 100));
5785 Env env{*
this, features};
5787 fund(env, gw, {alice, carol, bob},
XRP(11'000), {usd(20'000)});
5789 MPTTester mptTester(env, gw, {.fund =
false});
5792 {.ownerCount = 1, .holderCount = 0, .flags = tfMPTCanTransfer | tfMPTCanTrade});
5793 auto const mpt = mptTester[
"MPT"];
5795 mptTester.authorize({.account = alice});
5796 mptTester.authorize({.account = bob});
5797 mptTester.pay(gw, alice, 10'100);
5799 AMM const amm(env, alice, usd(10'000), mpt(10'100));
5801 env(
pay(carol, bob, mpt(100)),
5804 Txflags(tfPartialPayment | tfNoRippleDirect));
5807 BEAST_EXPECT(
amm.expectBalances(usd(10'100), mpt(10'000),
amm.tokens()));
5808 BEAST_EXPECT(mptTester.checkMPTokenAmount(bob, 100));
5813 Env env{*
this, features};
5814 env.
fund(
XRP(20'000), gw, alice, carol, bob);
5817 MPTTester mptTester1(env, gw, {.fund =
false});
5818 mptTester1.
create({.flags = tfMPTCanTransfer | tfMPTCanTrade});
5819 auto const mpt1 = mptTester1[
"MPT1"];
5820 mptTester1.authorize({.account = alice});
5821 mptTester1.authorize({.account = bob});
5822 mptTester1.pay(gw, alice, 10'100);
5824 MPTTester mptTester2(env, gw, {.fund =
false});
5825 mptTester2.
create({.flags = tfMPTCanTransfer | tfMPTCanTrade});
5826 auto const mpt2 = mptTester2[
"MPT1"];
5827 mptTester2.authorize({.account = alice});
5828 mptTester2.authorize({.account = bob});
5829 mptTester2.authorize({.account = carol});
5830 mptTester2.pay(gw, alice, 10'100);
5831 mptTester2.pay(gw, carol, 100);
5833 AMM const amm(env, alice, mpt2(10'000), mpt1(10'100));
5835 env(
pay(carol, bob, mpt1(100)),
5838 Txflags(tfPartialPayment | tfNoRippleDirect));
5841 BEAST_EXPECT(
amm.expectBalances(mpt2(10'100), mpt1(10'000),
amm.tokens()));
5842 BEAST_EXPECT(mptTester1.checkMPTokenAmount(bob, 100));
5848 Env env{*
this, features};
5849 auto const usd = gw[
"USD"];
5850 auto const eur = gw[
"EUR"];
5851 auto const crn = gw[
"CRN"];
5852 auto const yan = gw[
"YAN"];
5857 {alice, carol, bob},
5859 {usd(1'000), eur(1'000), crn(2'000), yan(1'000)});
5862 MPTTester mptTester(env, gw, {.fund =
false});
5863 mptTester.
create({.flags = tfMPTCanTransfer | tfMPTCanTrade});
5864 mptTester.authorize({.account = alice});
5865 mptTester.pay(gw, alice, 2'000);
5866 return {mptTester, mptTester[
"MPT"]};
5869 auto const [mptTester1, mpt1] = createMPT();
5870 auto const [mptTester2, mpt2] = createMPT();
5871 auto const [mptTester3, mpt3] = createMPT();
5873 env(
offer(alice, eur(100), mpt1(101)));
5874 env(
offer(alice, mpt1(101), mpt2(102)));
5875 env(
offer(alice, mpt2(102), usd(103)));
5876 env(
offer(alice, usd(103), crn(104)));
5878 AMM const amm(env, alice, crn(1'000), mpt3(1'104));
5879 env(
offer(alice, mpt3(104), yan(100)));
5881 env(
pay(carol, bob, yan(100)),
5884 Txflags(tfPartialPayment | tfNoRippleDirect));
5887 BEAST_EXPECT(env.
balance(carol, eur) == eur(900));
5888 BEAST_EXPECT(env.
balance(bob, yan) == yan(1'100));
5889 BEAST_EXPECT(
amm.expectBalances(crn(1'104), mpt3(1'000),
amm.tokens()));
5896 Env env{*
this, features};
5897 auto const usd = gw[
"USD"];
5898 auto const eur = gw[
"EUR"];
5899 auto const crn = gw[
"CRN"];
5901 fund(env, gw, {alice, carol, bob},
XRP(1'000), {usd(1'000), eur(1'000), crn(2'000)});
5904 MPTTester mptTester(env, gw, {.fund =
false});
5905 mptTester.
create({.flags = tfMPTCanTransfer | tfMPTCanTrade});
5906 mptTester.authorize({.account = alice});
5907 mptTester.pay(gw, alice, 2'000);
5908 return {mptTester, mptTester[
"MPT"]};
5911 auto const [mptTester1, mpt1] = createMPT();
5912 auto const [mptTester2, mpt2] = createMPT();
5913 auto const [mptTester3, mpt3] = createMPT();
5914 auto [mptTester4, mpt4] = createMPT();
5915 mptTester4.authorize({.account = bob});
5917 env(
offer(alice, eur(100), mpt1(101)));
5918 env(
offer(alice, mpt1(101), mpt2(102)));
5919 env(
offer(alice, mpt2(102), usd(103)));
5920 env(
offer(alice, usd(103), crn(104)));
5922 AMM const amm(env, alice, crn(1'000), mpt3(1'104));
5923 env(
offer(alice, mpt3(104), mpt4(100)));
5925 env(
pay(carol, bob, mpt4(100)),
5928 Txflags(tfPartialPayment | tfNoRippleDirect));
5931 BEAST_EXPECT(env.
balance(carol, eur) == eur(900));
5932 BEAST_EXPECT(mptTester4.checkMPTokenAmount(bob, 100));
5933 BEAST_EXPECT(
amm.expectBalances(crn(1'104), mpt3(1'000),
amm.tokens()));
5940 Env env(*
this, features);
5942 env.
fund(
XRP(1'000), gw, alice, carol, bob);
5944 MPTTester usdTester(env, gw, {.holders = {alice, carol, bob}, .fund =
false});
5948 .pay = {{{alice}, 1'000}},
5949 .flags = tfMPTCanTransfer | tfMPTCanTrade,
5951 auto const usd = usdTester[
"USD"];
5953 MPTTester eurTester(env, gw, {.holders = {alice, carol, bob}, .fund =
false});
5956 .authorize = {{alice, carol}},
5957 .pay = {{{carol}, 100}},
5958 .flags = tfMPTCanTransfer | tfMPTCanTrade,
5960 auto const eur = eurTester[
"EUR"];
5962 env(
offer(alice, eur(10), usd(10)));
5964 env(
pay(carol, bob, usd(10)),
5967 Txflags(tfNoRippleDirect | tfPartialPayment));
5970 Env env(*
this, features);
5971 env.
fund(
XRP(1'000), gw, alice, carol, bob);
5974 {.env = env, .issuer = gw, .holders = {alice, carol, bob}, .maxAmt = 1'000});
5975 MPT const usd = musd;
5976 env(
pay(gw, alice, usd(800)));
5977 env(
offer(gw,
XRP(300), usd(300)));
5978 env(
pay(carol, bob, usd(300)),
5982 BEAST_EXPECT(musd.checkMPTokenAmount(bob, 200));
5983 BEAST_EXPECT(musd.checkMPTokenOutstandingAmount(1'000));
5988 Env env(*
this, features);
5989 auto const eur = gw[
"EUR"];
5990 env.
fund(
XRP(1'000), gw, alice, carol, bob);
5993 env(
trust(alice, eur(1'000)));
5994 env(
pay(gw, alice, eur(300)));
5995 env(
trust(bob, eur(1'000)));
5998 {.env = env, .issuer = gw, .holders = {alice, carol, bob}, .maxAmt = 1'000});
5999 MPT const usd = musd;
6001 env(
pay(gw, alice, usd(800)));
6002 env(
offer(gw,
XRP(300), usd(300)));
6003 env(
offer(alice, usd(300), eur(300)));
6004 env(
pay(carol, bob, eur(300)),
6008 BEAST_EXPECT(musd.checkMPTokenAmount(alice, 1'000));
6009 BEAST_EXPECT(musd.checkMPTokenOutstandingAmount(1'000));
6012 BEAST_EXPECT(env.
balance(bob, eur) == eur(200));
6027 auto const usd = gw[
"USD"];
6028 auto const eur = gw1[
"EUR"];
6036 MPTTester mptTester(env, gw, {.holders = {dan, carol}});
6038 {.ownerCount = 1, .holderCount = 0, .flags = tfMPTCanTransfer | tfMPTCanTrade});
6039 auto const mpt = mptTester[
"MPT"];
6040 mptTester.authorize({.account = dan});
6041 mptTester.authorize({.account = carol});
6042 mptTester.pay(gw, carol, 200);
6044 auto const [pathSet, srcAmt, dstAmt] =
findPaths(env, carol, dan, mpt(-1));
6045 BEAST_EXPECT(srcAmt == mpt(200));
6046 BEAST_EXPECT(dstAmt == mpt(200));
6048 BEAST_EXPECT(pathSet.empty());
6057 MPTTester mptTester(env, gw, {.holders = {alice, dan}});
6060 {.ownerCount = 1, .holderCount = 0, .flags = tfMPTCanTransfer | tfMPTCanTrade});
6061 auto const mpt = mptTester[
"MPT"];
6063 mptTester.authorize({.account = alice});
6064 mptTester.authorize({.account = dan});
6065 mptTester.pay(gw, alice, 200);
6067 env(
offer(alice,
XRP(100), mpt(100)));
6070 auto const [pathSet, srcAmt, dstAmt] =
findPaths(env, carol, dan, mpt(-1));
6071 BEAST_EXPECT(srcAmt ==
XRP(100));
6072 BEAST_EXPECT(dstAmt == mpt(100));
6073 if (BEAST_EXPECT(
same(pathSet,
stpath(
ipe(mptTester.issuanceID())))))
6076 env(
pay(carol, dan, mpt(10)),
6079 Txflags(tfNoRippleDirect | tfPartialPayment));
6090 MPTTester mptTester(env, gw1, {.holders = {alice, dan}});
6093 {.ownerCount = 1, .holderCount = 0, .flags = tfMPTCanTransfer | tfMPTCanTrade});
6094 auto const mpt = mptTester[
"MPT"];
6096 mptTester.authorize({.account = alice});
6097 mptTester.authorize({.account = dan});
6098 mptTester.pay(gw1, alice, 200);
6100 env(
trust(alice, usd(400)));
6101 env(
trust(carol, usd(400)));
6102 env(
pay(gw, carol, usd(200)));
6104 env(
offer(alice, usd(100), mpt(100)));
6112 BEAST_EXPECT(srcAmt == usd(100));
6113 BEAST_EXPECT(dstAmt == mpt(100));
6118 env(
pay(carol, dan, mpt(10)),
6121 Txflags(tfNoRippleDirect | tfPartialPayment));
6125 std::tie(pathSet, srcAmt, dstAmt) =
findPaths(env, carol, dan, mpt(-1), usd(-1));
6126 BEAST_EXPECT(srcAmt == usd(90));
6127 BEAST_EXPECT(dstAmt == mpt(90));
6132 env(
pay(carol, dan, mpt(10)),
6135 Txflags(tfNoRippleDirect | tfPartialPayment));
6139 std::tie(pathSet, srcAmt, dstAmt) =
6140 findPaths(env, carol, dan, mpt(-1), std::nullopt, usd.currency);
6141 BEAST_EXPECT(srcAmt == usd(80));
6142 BEAST_EXPECT(dstAmt == mpt(80));
6147 env(
pay(carol, dan, mpt(10)),
6150 Txflags(tfNoRippleDirect | tfPartialPayment));
6161 MPTTester mptTester(env, gw1, {.holders = {carol, alice}});
6164 {.ownerCount = 1, .holderCount = 0, .flags = tfMPTCanTransfer | tfMPTCanTrade});
6165 auto const mpt = mptTester[
"MPT"];
6167 mptTester.authorize({.account = carol});
6168 mptTester.authorize({.account = alice});
6169 mptTester.pay(gw1, carol, 200);
6171 env(
trust(dan, usd(400)));
6172 env(
trust(alice, usd(400)));
6173 env(
pay(gw, alice, usd(200)));
6175 env(
offer(alice, mpt(100), usd(100)));
6183 BEAST_EXPECT(srcAmt == mpt(100));
6184 BEAST_EXPECT(dstAmt == usd(100));
6188 env(
pay(carol, dan, usd(10)),
6191 Txflags(tfNoRippleDirect | tfPartialPayment));
6195 std::tie(pathSet, srcAmt, dstAmt) =
findPaths(env, carol, dan, usd(-1), mpt(-1));
6196 BEAST_EXPECT(srcAmt == mpt(90));
6197 BEAST_EXPECT(dstAmt == usd(90));
6201 env(
pay(carol, dan, usd(10)),
6204 Txflags(tfNoRippleDirect | tfPartialPayment));
6208 std::tie(pathSet, srcAmt, dstAmt) =
6209 findPaths(env, carol, dan, usd(-1), std::nullopt, mpt.mpt());
6210 BEAST_EXPECT(srcAmt == mpt(80));
6211 BEAST_EXPECT(dstAmt == usd(80));
6215 env(
pay(carol, dan, usd(10)),
6218 Txflags(tfNoRippleDirect | tfPartialPayment));
6226 MPTTester mptTester(env, gw, {.holders = {alice, dan}});
6227 MPTTester mptTester1(env, gw1, {.holders = {carol}});
6230 {.ownerCount = 1, .holderCount = 0, .flags = tfMPTCanTransfer | tfMPTCanTrade});
6231 auto const mpt = mptTester[
"MPT"];
6233 {.ownerCount = 1, .holderCount = 0, .flags = tfMPTCanTransfer | tfMPTCanTrade});
6234 auto const mpt1 = mptTester1[
"MPT1"];
6236 mptTester.authorize({.account = alice});
6237 mptTester.authorize({.account = dan});
6238 mptTester.pay(gw, alice, 200);
6240 mptTester1.authorize({.account = carol});
6241 mptTester1.authorize({.account = alice});
6242 mptTester1.pay(gw1, carol, 200);
6244 env(
offer(alice, mpt1(100), mpt(100)));
6252 BEAST_EXPECT(srcAmt == mpt1(100));
6253 BEAST_EXPECT(dstAmt == mpt(100));
6258 env(
pay(carol, dan, mpt(10)),
6261 Txflags(tfNoRippleDirect | tfPartialPayment));
6265 std::tie(pathSet, srcAmt, dstAmt) =
findPaths(env, carol, dan, mpt(-1), mpt1(-1));
6266 BEAST_EXPECT(srcAmt == mpt1(90));
6267 BEAST_EXPECT(dstAmt == mpt(90));
6272 env(
pay(carol, dan, mpt(10)),
6275 Txflags(tfNoRippleDirect | tfPartialPayment));
6279 std::tie(pathSet, srcAmt, dstAmt) =
6280 findPaths(env, carol, dan, mpt(-1), std::nullopt, mpt1.mpt());
6281 BEAST_EXPECT(srcAmt == mpt1(80));
6282 BEAST_EXPECT(dstAmt == mpt(80));
6287 env(
pay(carol, dan, mpt(10)),
6290 Txflags(tfNoRippleDirect | tfPartialPayment));
6301 MPTTester mptTester(env, gw, {.holders = {alice, bob}});
6304 {.ownerCount = 1, .holderCount = 0, .flags = tfMPTCanTransfer | tfMPTCanTrade});
6305 auto const mpt = mptTester[
"MPT"];
6307 mptTester.authorize({.account = alice});
6308 mptTester.authorize({.account = bob});
6309 mptTester.pay(gw, alice, 200);
6310 mptTester.pay(gw, bob, 200);
6312 env(
trust(bob, usd(200)));
6313 env(
pay(gw, bob, usd(100)));
6314 env(
trust(dan, usd(200)));
6315 env(
trust(alice, usd(200)));
6317 env(
offer(alice,
XRP(100), mpt(100)));
6318 env(
offer(bob, mpt(100), usd(100)));
6326 BEAST_EXPECT(srcAmt ==
XRP(100));
6327 BEAST_EXPECT(dstAmt == usd(100));
6329 pathSet.
size() == 1 &&
6333 env(
pay(carol, dan, usd(10)),
6336 Txflags(tfNoRippleDirect | tfPartialPayment));
6341 BEAST_EXPECT(srcAmt ==
XRP(90));
6342 BEAST_EXPECT(dstAmt == usd(90));
6344 pathSet.
size() == 1 &&
6348 env(
pay(carol, dan, usd(10)),
6351 Txflags(tfNoRippleDirect | tfPartialPayment));
6361 auto const usd2 = gw2[
"USD"];
6363 MPTTester mptTester(env, gw, {.holders = {alice, carol}});
6365 {.ownerCount = 1, .holderCount = 0, .flags = tfMPTCanTransfer | tfMPTCanTrade});
6366 auto const mpt = mptTester[
"MPT"];
6367 mptTester.authorize({.account = alice});
6368 mptTester.authorize({.account = carol});
6369 mptTester.pay(gw, carol, 200);
6371 MPTTester mptTester1(env, gw1, {.holders = {bob, dan}});
6373 {.ownerCount = 1, .holderCount = 0, .flags = tfMPTCanTransfer | tfMPTCanTrade});
6374 auto const mpt1 = mptTester1[
"MPT1"];
6375 mptTester1.authorize({.account = bob});
6376 mptTester1.pay(gw1, bob, 200);
6377 mptTester1.authorize({.account = dan});
6379 env(
trust(alice, usd2(400)));
6380 env(
pay(gw2, alice, usd2(200)));
6381 env(
trust(bob, usd2(400)));
6383 env(
offer(alice, mpt(100), usd2(100)));
6384 env(
offer(bob, usd2(100), mpt1(100)));
6392 BEAST_EXPECT(srcAmt == mpt(100));
6393 BEAST_EXPECT(dstAmt == mpt1(100));
6395 pathSet.
size() == 1 &&
6399 env(
pay(carol, dan, mpt1(10)),
6402 Txflags(tfNoRippleDirect | tfPartialPayment));
6406 std::tie(pathSet, srcAmt, dstAmt) =
findPaths(env, carol, dan, mpt1(-1), mpt(-1));
6407 BEAST_EXPECT(srcAmt == mpt(90));
6408 BEAST_EXPECT(dstAmt == mpt1(90));
6410 pathSet.
size() == 1 &&
6414 env(
pay(carol, dan, mpt1(10)),
6417 Txflags(tfNoRippleDirect | tfPartialPayment));
6421 std::tie(pathSet, srcAmt, dstAmt) =
6422 findPaths(env, carol, dan, mpt1(-1), std::nullopt, mpt.mpt());
6423 BEAST_EXPECT(srcAmt == mpt(80));
6424 BEAST_EXPECT(dstAmt == mpt1(80));
6426 pathSet.
size() == 1 &&
6430 env(
pay(carol, dan, mpt1(10)),
6433 Txflags(tfNoRippleDirect | tfPartialPayment));
6443 env.
fund(
XRP(1'000), gw, gw1, gw2, alice, bob, carol, dan);
6445 MPTTester mptTester(env, gw, {.holders = {alice, carol}, .fund =
false});
6447 {.ownerCount = 1, .holderCount = 0, .flags = tfMPTCanTransfer | tfMPTCanTrade});
6448 auto const mpt = mptTester[
"MPT"];
6449 mptTester.authorize({.account = alice});
6450 mptTester.authorize({.account = carol});
6451 mptTester.pay(gw, carol, 200);
6453 MPTTester mptTester1(env, gw1, {.holders = {bob, alice}, .fund =
false});
6454 mptTester1.
create({.ownerCount = 1, .flags = tfMPTCanTransfer | tfMPTCanTrade});
6455 auto const mpt1 = mptTester1[
"MPT1"];
6456 mptTester1.authorize({.account = alice});
6457 mptTester1.pay(gw1, alice, 200);
6458 mptTester1.authorize({.account = bob});
6460 MPTTester mptTester2(env, gw2, {.holders = {bob, dan}, .fund =
false});
6461 mptTester2.
create({.ownerCount = 1, .flags = tfMPTCanTransfer | tfMPTCanTrade});
6462 auto const mpt2 = mptTester2[
"MPT2"];
6463 mptTester2.authorize({.account = bob});
6464 mptTester2.pay(gw2, bob, 200);
6465 mptTester2.authorize({.account = dan});
6467 env(
offer(alice, mpt(100), mpt1(100)));
6468 env(
offer(bob, mpt1(100), mpt2(100)));
6476 BEAST_EXPECT(srcAmt == mpt(100));
6477 BEAST_EXPECT(dstAmt == mpt2(100));
6479 pathSet.
size() == 1 &&
6482 stpath(
ipe(mptTester1.issuanceID()),
ipe(mptTester2.issuanceID())))))
6485 env(
pay(carol, dan, mpt2(10)),
6488 Txflags(tfNoRippleDirect | tfPartialPayment));
6492 std::tie(pathSet, srcAmt, dstAmt) =
findPaths(env, carol, dan, mpt2(-1), mpt(-1));
6493 BEAST_EXPECT(srcAmt == mpt(90));
6494 BEAST_EXPECT(dstAmt == mpt2(90));
6496 pathSet.
size() == 1 &&
6499 stpath(
ipe(mptTester1.issuanceID()),
ipe(mptTester2.issuanceID())))))
6502 env(
pay(carol, dan, mpt2(10)),
6505 Txflags(tfNoRippleDirect | tfPartialPayment));
6509 std::tie(pathSet, srcAmt, dstAmt) =
6510 findPaths(env, carol, dan, mpt2(-1), std::nullopt, mpt.mpt());
6511 BEAST_EXPECT(srcAmt == mpt(80));
6512 BEAST_EXPECT(dstAmt == mpt2(80));
6514 pathSet.
size() == 1 &&
6517 stpath(
ipe(mptTester1.issuanceID()),
ipe(mptTester2.issuanceID())))))
6520 env(
pay(carol, dan, mpt2(10)),
6523 Txflags(tfNoRippleDirect | tfPartialPayment));
6539 env.
fund(
XRP(1'000'000), gw1);
6540 env.
fund(
XRP(1'000'000), carol);
6541 env.
fund(
XRP(1'000'000), dan);
6542 env.
fund(
XRP(1'000'000), bob);
6543 env.
fund(
XRP(1'000'000), john);
6544 env.
fund(
XRP(1'000'000), sean);
6547 MPTTester usdTester(env, gw, {.holders = {carol, dan}, .fund =
false});
6551 .flags = tfMPTCanTransfer | tfMPTCanTrade,
6553 auto const usd = usdTester[
"USD"];
6554 env(
offer(carol,
XRP(100), usd(100)));
6556 MPTTester gbpTester(env, gw, {.holders = {bob, sean}, .fund =
false});
6559 .pay = {{{bob}, 100}},
6560 .flags = tfMPTCanTransfer | tfMPTCanTrade,
6562 auto const gbp = gbpTester[
"GBP"];
6564 MPTTester usd1(env, gw1, {.holders = {bob, dan}, .fund =
false});
6567 .pay = {{{dan}, 100}},
6568 .flags = tfMPTCanTransfer | tfMPTCanTrade,
6570 auto const usD1 = usd1[
"USD1"];
6571 env(
offer(bob, usd1(100), gbp(100)));
6575 auto const [pathSet, srcAmt, dstAmt] =
findPaths(env, john, sean, gbp(-1),
XRP(-1));
6576 BEAST_EXPECT(pathSet.empty());
6578 env(
pay(john, sean, gbp(10)),
6580 Path(~usd, dan, gw1, ~gbp),
6581 Txflags(tfNoRippleDirect | tfPartialPayment),
7159 using namespace jtx;
7164 auto const usd = gw[
"USD"];
7170 fund(env, gw, {alice, carol, bob},
XRP(1'000), {usd(1'000)});
7172 MPTTester mptTester(env, gw, {.fund =
false});
7173 mptTester.
create({.flags = tfMPTCanTransfer | tfMPTCanTrade});
7174 auto const mpt = mptTester[
"MPT"];
7175 mptTester.authorize({.account = alice});
7176 mptTester.authorize({.account = carol});
7177 mptTester.pay(gw, alice, 1'000);
7178 mptTester.pay(gw, carol, 1'000);
7180 MPTTester mptTester1(env, gw, {.fund =
false});
7181 mptTester1.
create({.flags = tfMPTCanTransfer | tfMPTCanTrade});
7182 auto const mpt1 = mptTester1[
"MPT1"];
7183 mptTester1.authorize({.account = alice});
7184 mptTester1.authorize({.account = carol});
7185 mptTester1.pay(gw, alice, 1'000);
7186 mptTester1.pay(gw, carol, 1'000);
7193 for (
auto& pool : pools)
7195 AMM amm(env, gw, std::get<0>(pool), std::get<1>(pool));
7196 amm.deposit(alice, std::get<2>(pool));
7197 amm.deposit(carol, std::get<2>(pool));
7202 .tokens = std::get<2>(pool),
7205 amm.withdrawAll(alice);
7206 amm.withdrawAll(carol);
7207 amm.withdrawAll(gw);
7208 BEAST_EXPECT(!
amm.ammExists());
7216 env.
fund(
XRP(1'000), gw, alice, carol);
7219 MPT const usd =
MPTTester({.env = env, .issuer = gw, .holders = {alice, carol}});
7220 MPT const eur =
MPTTester({.env = env, .issuer = gw, .holders = {alice, carol}});
7222 env(
pay(gw, alice, eur(100)));
7224 AMM const amm(env, gw, usd(1'100), eur(1'000));
7226 env(
pay(alice, carol, usd(100)),
Sendmax(eur(100)));
7228 BEAST_EXPECT(
amm.expectBalances(usd(1'000), eur(1'100),
amm.tokens()));
7229 BEAST_EXPECT(env.
balance(carol, usd) == usd(100));
7230 BEAST_EXPECT(env.
balance(alice, eur) == eur(0));
7237 env.
fund(
XRP(1'000), gw, alice, carol);
7240 MPT const usd =
MPTTester({.env = env, .issuer = gw, .holders = {alice, carol}});
7241 MPT const eur =
MPTTester({.env = env, .issuer = gw, .holders = {alice, carol}});
7242 MPT const btc =
MPTTester({.env = env, .issuer = gw, .holders = {alice, carol}});
7243 env(
pay(gw, alice, eur(100)));
7245 AMM const ammEurUsd(env, gw, eur(1'000), usd(1'100));
7246 AMM const ammUsdBtc(env, gw, usd(1'000), btc(1'100));
7248 env(
pay(alice, carol, btc(100)),
7255 BEAST_EXPECT(env.
balance(carol, btc) == btc(100));
7256 BEAST_EXPECT(env.
balance(alice, eur) == eur(0));
7263 env.
fund(
XRP(1'000), gw, alice);
7266 MPT const usd =
MPTTester({.env = env, .issuer = gw, .holders = {alice}});
7267 MPT const eur =
MPTTester({.env = env, .issuer = gw, .holders = {alice}});
7269 env(
pay(gw, alice, eur(1'000)));
7271 AMM const amm(env, gw, eur(1'000'000), usd(1'001'000));
7273 env(
offer(alice, usd(1'000), eur(1'000)));
7275 BEAST_EXPECT(
amm.expectBalances(usd(1'000'000), eur(1'001'000),
amm.tokens()));
7276 BEAST_EXPECT(env.
balance(alice, usd) == usd(1'000));
7277 BEAST_EXPECT(env.
balance(alice, eur) == eur(0));
7282 env.
fund(
XRP(1'000'000), gw, alice, carol);
7284 auto const increment = env.
current()->fees().increment;
7285 auto const txfee =
Fee(
drops(increment));
7288 auto const makeMPT =
7304 return makeMPT(tfMPTCanLock | tfMPTCanTrade, holders,
pay);
7308 return makeMPT(tfMPTCanLock | tfMPTCanTransfer, holders,
pay);
7313 auto usd = makeDexMPT();
7314 auto eur = makeDexMPT({alice}, 1'000'000);
7316 auto const createDeleteAMM = [&](
auto const& asset,
Account const& lp) {
7323 amm.withdrawAll(lp);
7324 BEAST_EXPECT(!
amm.ammExists());
7327 auto const createFail =
7328 [&](
auto const& asset,
Account const& account,
auto const& err) {
7329 auto const createJv =
AMM::createJv(account, asset(1'000), eur(1'000), 0);
7330 env(createJv, txfee,
Ter(err));
7341 usd.authorize({.account = alice});
7342 env(
pay(gw, alice, usd(1'000'000)), txfee);
7344 createDeleteAMM(usd, alice);
7348 usd.set({.flags = tfMPTLock});
7354 usd.set({.flags = tfMPTUnlock});
7355 usd.set({.flags = tfMPTSetRequireAuth});
7358 createDeleteAMM(usd, gw);
7361 usd.authorize({.account = gw, .holder = alice});
7362 createDeleteAMM(usd, alice);
7366 auto usd2 = makeNoTransferMPT({alice}, 1'000'000);
7371 createDeleteAMM(usd2, gw);
7372 usd2.set({.flags = tfMPTSetCanTransfer});
7374 createDeleteAMM(usd2, alice);
7379 auto usd3 = makeNoTradeMPT({alice}, 1'000'000);
7384 usd3.set({.flags = tfMPTSetCanTrade});
7386 createDeleteAMM(usd3, alice);
7392 auto usd = makeDexMPT();
7393 auto eur = makeDexMPT({alice}, 1'000'000);
7394 AMM amm(env, gw, usd(1'000), eur(1'000));
7414 usd.authorize({.account = carol});
7415 env(
pay(gw, carol, usd(1'000'000)));
7416 eur.authorize({.account = carol});
7417 env(
pay(gw, carol, eur(1'000'000)));
7421 usd.set({.flags = tfMPTLock});
7424 for (
auto const& account : {carol, gw})
7439 usd.set({.flags = tfMPTUnlock});
7443 usd.set({.flags = tfMPTSetRequireAuth});
7458 amm.deposit({.account = gw, .tokens = 1'000});
7460 usd.authorize({.account = gw, .holder = carol});
7461 amm.deposit({.account = carol, .tokens = 1'000});
7471 .flags = tfMPTUnauthorize,
7477 auto usd2 = makeNoTransferMPT({carol}, 1'000'000);
7478 AMM amm2(env, gw, usd2(1'000), eur(1'000));
7483 .asset1In = usd2(1),
7494 amm2.deposit({.account = gw, .tokens = 1'000});
7495 usd2.set({.flags = tfMPTSetCanTransfer});
7497 amm2.deposit({.account = carol, .tokens = 1'000});
7503 auto usd = makeDexMPT();
7504 auto const eur = makeDexMPT({carol}, 1'000'000);
7505 AMM amm(env, gw, usd(1'000), eur(1'000));
7507 usd.authorize({.account = carol});
7508 env(
pay(gw, carol, usd(1'000'000)));
7510 amm.deposit({.account = carol, .tokens = 1'000});
7517 .asset2Out = eur(1),
7526 usd.set({.flags = tfMPTLock});
7527 auto const fix330 = env.
current()->rules().enabled(fixCleanup3_3_0);
7532 .asset1Out = usd(1),
7533 .asset2Out = eur(1),
7536 amm.withdraw({.account = carol, .tokens = 1'000, .err =
Ter(
tecLOCKED)});
7539 {.account = carol, .asset1Out = eur(1), .assets =
std::make_pair(eur, usd)});
7545 auto const replenish = [&](
IOUAmount tokens) {
7546 usd.set({.flags = tfMPTUnlock});
7547 amm.deposit({.account = gw, .tokens = tokens});
7548 usd.set({.flags = tfMPTLock});
7552 {.account = gw, .asset1Out = usd(1), .asset2Out = eur(1), .err = gwLockErr});
7556 amm.withdraw({.account = gw, .tokens = 1'000, .err = gwLockErr});
7562 {.account = gw, .asset1Out = eur(1), .assets =
std::make_pair(eur, usd)});
7564 usd.set({.flags = tfMPTUnlock});
7567 usd.set({.flags = tfMPTSetRequireAuth});
7568 usd.authorize({.account = gw, .holder = carol, .flags = tfMPTUnauthorize});
7572 .asset1Out = usd(1),
7573 .asset2Out = eur(1),
7578 {.account = carol, .asset1Out = eur(1), .assets =
std::make_pair(eur, usd)});
7580 amm.withdraw({.account = gw, .asset1Out = usd(1), .asset2Out = eur(1)});
7582 usd.authorize({.account = gw, .holder = carol});
7583 amm.withdraw({.account = carol, .asset1Out = usd(1), .asset2Out = eur(1)});
7587 auto usd2 = makeNoTransferMPT({carol}, 1'000'000);
7588 AMM amm2(env, gw, usd2(1'000), eur(1'000));
7593 env(
pay(gw, carol,
STAmount{amm2.lptIssue(), 100}));
7597 amm2.withdraw({.account = carol, .asset1Out = usd2(1), .asset2Out = eur(1)});
7601 .asset1Out = eur(1),
7605 amm2.withdraw({.account = gw, .asset1Out = usd2(1), .asset2Out = eur(1)});
7608 usd2.authorize({.account = bob});
7610 usd2.authorize({.account = bob, .flags = tfMPTUnauthorize});
7612 env(
pay(carol, gw, usd2(1)));
7613 usd2.set({.flags = tfMPTSetCanTransfer});
7615 amm2.withdraw({.account = carol, .asset1Out = usd2(1), .asset2Out = eur(1)});
7620 auto const usd3 = makeDexMPT();
7621 auto const eur3 = makeDexMPT({carol}, 1'000'000);
7622 AMM amm3(env, gw, usd3(1'000), eur3(1'000));
7628 .asset1In = eur3(1'000),
7633 amm3.withdraw({.account = carol, .asset1Out = usd3(100)});