1#include <test/jtx/AMM.h>
2#include <test/jtx/CaptureLogs.h>
3#include <test/jtx/Env.h>
4#include <test/jtx/PathSet.h>
5#include <test/jtx/TestHelpers.h>
6#include <test/jtx/WSClient.h>
7#include <test/jtx/acctdelete.h>
8#include <test/jtx/amount.h>
9#include <test/jtx/balance.h>
10#include <test/jtx/envconfig.h>
11#include <test/jtx/fee.h>
12#include <test/jtx/jtx_json.h>
13#include <test/jtx/mpt.h>
14#include <test/jtx/noop.h>
15#include <test/jtx/offer.h>
16#include <test/jtx/owners.h>
17#include <test/jtx/paths.h>
18#include <test/jtx/pay.h>
19#include <test/jtx/rate.h>
20#include <test/jtx/require.h>
21#include <test/jtx/sendmax.h>
22#include <test/jtx/tags.h>
23#include <test/jtx/ter.h>
24#include <test/jtx/ticket.h>
25#include <test/jtx/trust.h>
26#include <test/jtx/txflags.h>
28#include <xrpl/basics/Number.h>
29#include <xrpl/basics/base_uint.h>
30#include <xrpl/beast/unit_test/suite.h>
31#include <xrpl/beast/utility/Journal.h>
32#include <xrpl/core/ServiceRegistry.h>
33#include <xrpl/json/json_value.h>
34#include <xrpl/ledger/helpers/DirectoryHelpers.h>
35#include <xrpl/protocol/AccountID.h>
36#include <xrpl/protocol/Book.h>
37#include <xrpl/protocol/ErrorCodes.h>
38#include <xrpl/protocol/Feature.h>
39#include <xrpl/protocol/Indexes.h>
40#include <xrpl/protocol/Issue.h>
41#include <xrpl/protocol/LedgerFormats.h>
42#include <xrpl/protocol/MPTIssue.h>
43#include <xrpl/protocol/Protocol.h>
44#include <xrpl/protocol/SField.h>
45#include <xrpl/protocol/STAmount.h>
46#include <xrpl/protocol/Seed.h>
47#include <xrpl/protocol/SeqProxy.h>
48#include <xrpl/protocol/TER.h>
49#include <xrpl/protocol/TxFlags.h>
50#include <xrpl/protocol/UintTypes.h>
51#include <xrpl/protocol/XRPAmount.h>
52#include <xrpl/protocol/jss.h>
73 return env.
current()->fees().accountReserve(count, 1);
79 return env.
current()->header().parentCloseTime.time_since_epoch().count();
86 testcase(
"Incorrect Removal of Funded Offers");
98 auto const gw =
Account{
"gateway"};
103 auto const test = [&](
auto&& issue1,
auto&& issue2) {
104 Env env{*
this, features};
106 env.
fund(
XRP(10'000), alice, bob, carol, gw);
110 issue1({.env = env, .token =
"USD", .issuer = gw, .holders = {alice, bob, carol}});
112 issue2({.env = env, .token =
"BTC", .issuer = gw, .holders = {alice, bob, carol}});
114 env(
pay(gw, alice, btc(1'000)));
116 env(
pay(gw, carol, usd(1'000)));
117 env(
pay(gw, carol, btc(1'000)));
122 env(
offer(carol, btc(49),
XRP(49)));
123 env(
offer(carol, btc(51),
XRP(51)));
127 env(
offer(carol,
XRP(50), usd(50)));
128 env(
offer(carol,
XRP(50), usd(50)));
131 env(
offer(carol, btc(1), usd(100)));
135 env(
pay(alice, bob, usd(100)),
142 !
isOffer(env, carol, btc(1), usd(100)) &&
isOffer(env, carol, btc(49),
XRP(49)));
150 testcase(
"Removing Canceled Offers");
153 Env env{*
this, features};
155 auto const gw =
Account{
"gateway"};
156 auto const alice =
Account{
"alice"};
158 env.
fund(
XRP(10'000), alice, gw);
161 MPT const usd =
MPTTester({.env = env, .issuer = gw, .holders = {alice}});
163 env(
pay(gw, alice, usd(50)));
166 auto const offer1Seq = env.
seq(alice);
171 BEAST_EXPECT(
isOffer(env, alice,
XRP(500), usd(100)));
174 auto const offer2Seq = env.
seq(alice);
176 env(
offer(alice,
XRP(300), usd(100)),
177 Json(jss::OfferSequence, offer1Seq),
187 env(
offer(alice,
XRP(400), usd(200)),
188 Json(jss::OfferSequence, offer1Seq),
196 auto const offer4Seq = env.
seq(alice);
200 BEAST_EXPECT(
isOffer(env, alice,
XRP(222), usd(111)));
203 BEAST_EXPECT(env.
seq(alice) == offer4Seq + 2);
205 BEAST_EXPECT(!
isOffer(env, alice,
XRP(222), usd(111)));
213 Json(jss::OfferSequence, offer2Seq),
218 BEAST_EXPECT(
isOffer(env, alice,
XRP(300), usd(100)));
219 BEAST_EXPECT(!
isOffer(env, alice,
XRP(5), usd(2)));
229 using namespace std::chrono_literals;
230 auto const alice =
Account{
"alice"};
231 auto const bob =
Account{
"bob"};
232 auto const carol =
Account{
"carol"};
235 auto const test = [&](
auto&& issue1,
auto&& issue2) {
236 Env env{*
this, features};
238 env.
fund(
XRP(10'000), alice, bob, carol, gw);
241 auto const usd = issue1({
245 .holders = {alice, bob, carol},
246 .
limit = 400'000'000,
248 auto const eur = issue2({
252 .holders = {alice, bob, carol},
253 .
limit = 400'000'000,
256 env(
pay(gw, alice, usd(100'000'000)));
257 env(
pay(gw, carol, eur(100'000'000)));
263 for (
int i = 0; i < 101; ++i)
264 env(
offer(carol, usd(1'000'000), eur(2'000'000)));
295 using namespace std::chrono_literals;
296 auto const alice =
Account{
"alice"};
297 auto const bob =
Account{
"bob"};
298 auto const carol =
Account{
"carol"};
299 auto const dan =
Account{
"dan"};
300 auto const erin =
Account{
"erin"};
303 Env env{*
this, features};
305 env.
fund(
XRP(10'000), alice, bob, carol, dan, erin, gw);
311 .holders = {alice, bob, carol, dan, erin},
314 env(
pay(gw, carol, usd(99'999)));
315 env(
pay(gw, dan, usd(100'000)));
316 env(
pay(gw, erin, usd(100'000)));
338 env(
pay(alice, bob, usd(100'000)),
341 Txflags(tfNoRippleDirect | tfPartialPayment));
353 testcase(
"Rm small increased q offers XRP");
361 using namespace std::chrono_literals;
362 auto const alice =
Account{
"alice"};
363 auto const bob =
Account{
"bob"};
364 auto const carol =
Account{
"carol"};
368 for (
auto const crossBothOffers : {
false,
true})
370 Env env{*
this, features};
372 env.
fund(
XRP(10'000), alice, bob, carol, gw);
374 MPT const usd =
MPTTester({.env = env, .issuer = gw, .holders = {alice, bob, carol}});
376 auto const initialCarolUSD = usd(499);
377 env(
pay(gw, carol, initialCarolUSD));
378 env(
pay(gw, bob, usd(100'000)));
384 env(
offer(bob,
drops(2), usd(1'000), tfPassive));
390 auto const aliceTakerGets = crossBothOffers ?
drops(2) :
drops(1);
391 env(
offer(alice, usd(1'000), aliceTakerGets));
412 for (
auto const partialPayment : {
false,
true})
414 Env env{*
this, features};
416 env.
fund(
XRP(10'000), alice, bob, carol, gw);
419 MPT const usd =
MPTTester({.env = env, .issuer = gw, .holders = {alice, bob, carol}});
420 auto const initialCarolUSD = usd(999);
421 env(
pay(gw, carol, initialCarolUSD));
423 env(
pay(gw, bob, usd(100'000)));
427 env(
offer(bob,
drops(2), usd(2'000), tfPassive));
432 partialPayment ? (tfNoRippleDirect | tfPartialPayment) : tfNoRippleDirect;
436 env(
pay(alice, bob, usd(5'000)),
462 testcase(
"Rm small increased q offers MPT");
470 using namespace std::chrono_literals;
471 auto const alice =
Account{
"alice"};
472 auto const bob =
Account{
"bob"};
473 auto const carol =
Account{
"carol"};
476 auto const test = [&](
auto&& issue1,
auto&& issue2) {
497 for (
auto const crossBothOffers : {
false,
true})
499 Env env{*
this, features};
501 env.
fund(
XRP(10'000), alice, bob, carol, gw);
504 auto const usd = issue1({
508 .holders = {alice, bob, carol},
509 .
limit = 100'000'000,
511 auto const eur = issue2({
515 .holders = {alice, bob, carol},
516 .
limit = 100'000'000,
519 auto const initialCarolUSD = tinyAmount(usd);
520 env(
pay(gw, carol, initialCarolUSD));
521 env(
pay(gw, bob, usd(100'000)));
522 env(
pay(gw, alice, eur(100'000)));
525 env(
offer(carol, eur(10), usd(10'000)));
528 env(
offer(bob, eur(10), usd(5'000), tfPassive));
535 auto const aliceTakerGets = crossBothOffers ? eur(2) : eur(1);
536 env(
offer(alice, usd(1'000), aliceTakerGets));
544 auto const balanceCarolUSD = kIsEuriou ? usd(0) : initialCarolUSD;
555 auto const balanceAliceUSD = kIsEuriou ? usd(1) : usd(0);
561 for (
auto const partialPayment : {
false,
true})
563 Env env{*
this, features};
565 env.
fund(
XRP(10'000), alice, bob, carol, gw);
568 auto const usd = issue1({
572 .holders = {alice, bob, carol},
573 .
limit = 100'000'000,
575 auto const eur = issue2({
579 .holders = {alice, bob, carol},
580 .
limit = 100'000'000,
583 auto const initialCarolUSD = tinyAmount(usd);
584 env(
pay(gw, carol, initialCarolUSD));
585 env(
pay(gw, bob, usd(100'000)));
586 env(
pay(gw, alice, eur(100'000)));
589 env(
offer(carol, eur(10), usd(2'000)));
591 env(
offer(bob, eur(20), usd(4'000), tfPassive));
596 partialPayment ? (tfNoRippleDirect | tfPartialPayment) : tfNoRippleDirect;
600 env(
pay(alice, bob, usd(5'000)),
614 auto const balanceCarolUSD = kIsEuriou ? usd(0) : initialCarolUSD;
633 testcase(
"MPT issuer offer dust removal uses remaining issuance capacity");
637 Account const issuer{
"issuer"};
641 Env env{*
this, features};
642 env.
fund(
XRP(10'000), issuer, carol, bob);
646 {.env = env, .issuer = issuer, .holders = {carol, bob}, .maxAmt = 101});
651 auto const issuerOfferSeq = env.
seq(issuer);
655 env(
pay(issuer, carol, musd(100)));
657 BEAST_EXPECT(env.
balance(issuer, musd) == musd(-100));
658 BEAST_EXPECT(env.
balance(carol, musd) == musd(100));
664 auto const carolOfferSeq = env.
seq(carol);
670 BEAST_EXPECT(env.
le(issuerOffer) !=
nullptr);
671 BEAST_EXPECT(env.
le(carolOffer) !=
nullptr);
673 env(
offer(bob, musd(101),
drops(2), tfImmediateOrCancel));
676 BEAST_EXPECT(env.
le(issuerOffer) ==
nullptr);
677 BEAST_EXPECT(env.
le(carolOffer) ==
nullptr);
679 BEAST_EXPECT(env.
balance(issuer, musd) == musd(-100));
680 BEAST_EXPECT(env.
balance(carol, musd) == musd(0));
681 BEAST_EXPECT(env.
balance(bob, musd) == musd(100));
696 testcase(
"MPT offer whose funded output rounds to zero is removed");
700 Account const issuer{
"issuer"};
703 Env env{*
this, features};
704 env.
fund(
XRP(10'000), issuer, bob);
714 .transferFee = kTenPercentFee,
717 BEAST_EXPECT(usd.checkTransferFee(kTenPercentFee));
723 auto const issuerOfferSeq = env.
seq(issuer);
724 env(
offer(issuer,
XRP(100), usd(100)));
728 BEAST_EXPECT(env.
le(issuerOffer) !=
nullptr);
729 BEAST_EXPECT(env.
balance(issuer, usd) == usd(0));
731 auto const bobXRPBefore = env.
balance(bob);
732 auto const bobMPTBefore = env.
balance(bob, usd);
733 auto const fee = env.
current()->fees().base;
742 BEAST_EXPECT(env.
le(issuerOffer) ==
nullptr);
743 BEAST_EXPECT(env.
balance(issuer, usd) == usd(0));
744 BEAST_EXPECT(env.
balance(bob, usd) == bobMPTBefore);
745 BEAST_EXPECT(env.
balance(bob) == bobXRPBefore - fee);
758 testcase(
"MPT zero-output offer does not block the book");
762 Account const issuer{
"issuer"};
766 Env env{*
this, features};
767 env.
fund(
XRP(10'000), issuer, carol, bob);
774 .holders = {carol, bob},
775 .transferFee = kTenPercentFee,
781 env(
pay(issuer, carol, usd(100)));
785 auto const issuerOfferSeq = env.
seq(issuer);
786 env(
offer(issuer,
XRP(100), usd(100)));
789 auto const carolOfferSeq = env.
seq(carol);
790 env(
offer(carol,
XRP(200), usd(100)));
795 BEAST_EXPECT(env.
le(issuerOffer) !=
nullptr);
796 BEAST_EXPECT(env.
le(carolOffer) !=
nullptr);
803 BEAST_EXPECT(env.
le(issuerOffer) ==
nullptr);
804 BEAST_EXPECT(env.
balance(bob, usd) == usd(50));
805 BEAST_EXPECT(env.
balance(carol, usd) == usd(45));
806 BEAST_EXPECT(env.
balance(issuer, usd) == usd(-95));
808 auto const sle = env.
le(carolOffer);
809 BEAST_EXPECT(sle !=
nullptr);
812 BEAST_EXPECT((*sle)[sfTakerPays] ==
XRP(100));
813 BEAST_EXPECT((*sle)[sfTakerGets] == usd(50));
824 testcase(
"MPT holder zero-output offer does not block the book");
828 Account const issuer{
"issuer"};
833 Env env{*
this, features};
834 env.
fund(
XRP(10'000), issuer, alice, carol, bob);
841 .holders = {alice, carol, bob},
842 .transferFee = kTenPercentFee,
845 env(
pay(issuer, alice, usd(1)));
846 env(
pay(issuer, carol, usd(100)));
849 auto const aliceOfferSeq = env.
seq(alice);
850 env(
offer(alice,
XRP(100), usd(100)));
853 auto const carolOfferSeq = env.
seq(carol);
854 env(
offer(carol,
XRP(200), usd(100)));
859 BEAST_EXPECT(env.
le(aliceOffer) !=
nullptr);
860 BEAST_EXPECT(env.
le(carolOffer) !=
nullptr);
865 BEAST_EXPECT(env.
le(aliceOffer) ==
nullptr);
866 BEAST_EXPECT(env.
balance(alice, usd) == usd(1));
867 BEAST_EXPECT(env.
balance(bob, usd) == usd(50));
868 BEAST_EXPECT(env.
balance(carol, usd) == usd(45));
870 auto const sle = env.
le(carolOffer);
871 BEAST_EXPECT(sle !=
nullptr);
874 BEAST_EXPECT((*sle)[sfTakerPays] ==
XRP(100));
875 BEAST_EXPECT((*sle)[sfTakerGets] == usd(50));
889 testcase(
"MPT issuer offer clipped to zero output by the issuance cap");
893 Account const issuerA{
"issuerA"};
894 Account const issuerB{
"issuerB"};
898 Env env{*
this, features};
899 env.
fund(
XRP(10'000), issuerA, issuerB, alice, bob);
906 MPTTester({.env = env, .issuer = issuerA, .holders = {alice, issuerB}, .maxAmt = 10});
907 MPT const b =
MPTTester({.env = env, .issuer = issuerB, .holders = {bob}});
909 env(
pay(issuerA, alice, a(10)));
912 auto const offerSeq = env.
seq(issuerB);
913 env(
offer(issuerB, a(1'000), b(1)));
917 BEAST_EXPECT(env.
le(bookOffer) !=
nullptr);
919 env(
pay(alice, bob, b(1)),
928 BEAST_EXPECT(env.
le(bookOffer) !=
nullptr);
929 BEAST_EXPECT(env.
balance(alice, a) == a(10));
930 BEAST_EXPECT(env.
balance(issuerB, a) == a(0));
931 BEAST_EXPECT(env.
balance(bob, b) == b(0));
950 testcase(
"IOU offer whose funded output rounds to zero");
962 auto const usd = gw[
"USD"];
963 auto const eur = gw2[
"EUR"];
966 env.
fund(
XRP(10'000), gw, gw2, alice, carol, dan);
970 env.
trust(usd(10'000), alice, carol, dan);
971 env.
trust(eur(10'000), alice, carol, dan);
975 env(
pay(gw, carol, usd(100)));
976 env(
pay(gw2, dan, eur(1'000)));
981 auto const aliceOfferSeq = env.
seq(alice);
982 env(
offer(alice, eur(100), usd(100)));
985 auto const carolOfferSeq = env.
seq(carol);
986 env(
offer(carol, eur(200), usd(100)));
991 BEAST_EXPECT(env.
le(aliceOffer) !=
nullptr);
992 BEAST_EXPECT(env.
le(carolOffer) !=
nullptr);
994 env(
offer(dan, usd(50), eur(100)));
997 if (fs[featureMPTokensV2])
1000 BEAST_EXPECT(env.
le(aliceOffer) ==
nullptr);
1001 BEAST_EXPECT(env.
balance(dan, usd) == usd(50));
1002 BEAST_EXPECT(env.
balance(dan, eur) == eur(900));
1003 BEAST_EXPECT(env.
balance(carol, usd) == usd(45));
1004 BEAST_EXPECT(env.
balance(carol, eur) == eur(100));
1006 auto const sle = env.
le(carolOffer);
1007 BEAST_EXPECT(sle !=
nullptr);
1010 BEAST_EXPECT((*sle)[sfTakerPays] == eur(100));
1011 BEAST_EXPECT((*sle)[sfTakerGets] == usd(50));
1019 auto const sle = env.
le(aliceOffer);
1020 BEAST_EXPECT(sle !=
nullptr);
1023 BEAST_EXPECT((*sle)[sfTakerPays] == eur(100));
1024 BEAST_EXPECT((*sle)[sfTakerGets] == usd(100));
1026 BEAST_EXPECT(env.
balance(dan, usd) == usd(0));
1027 BEAST_EXPECT(env.
balance(dan, eur) == eur(1'000));
1028 BEAST_EXPECT(env.
balance(carol, usd) == usd(100));
1029 BEAST_EXPECT(env.
le(carolOffer) !=
nullptr);
1037 test(features - featureMPTokensV2);
1052 "MPT offer whose fee-clipped input truncates to zero is "
1055 using namespace jtx;
1062 auto const run = [&](
auto&& makeOut) {
1063 Account const bondIssuer{
"bondIssuer"};
1064 Account const outIssuer{
"outIssuer"};
1067 Env env{*
this, features};
1068 env.
fund(
XRP(10'000), bondIssuer, outIssuer, alice);
1071 MPT const bond =
MPTTester({.env = env, .issuer = bondIssuer, .holders = {alice}});
1072 auto const out = makeOut(env, outIssuer, bondIssuer, alice, kTenPercentFee);
1074 env(
pay(outIssuer, alice, out(1'001)));
1077 auto const aliceOfferSeq = env.
seq(alice);
1078 env(
offer(alice, bond(1), out(1'000)));
1082 BEAST_EXPECT(env.
le(aliceOffer) !=
nullptr);
1083 BEAST_EXPECT(env.
balance(alice, out) == out(1'001));
1085 auto const issuerOutBefore = env.
balance(bondIssuer, out);
1089 env(
offer(bondIssuer, out(1'000), bond(1), tfImmediateOrCancel),
Ter(
tecKILLED));
1092 BEAST_EXPECT(env.
le(aliceOffer) ==
nullptr);
1093 BEAST_EXPECT(env.
balance(alice, out) == out(1'001));
1094 BEAST_EXPECT(env.
balance(alice, bond) == bond(0));
1095 BEAST_EXPECT(env.
balance(bondIssuer, out) == issuerOutBefore);
1104 auto const usd = gw[
"USD"];
1106 env.
trust(usd(10'000), alice, taker);
1117 {.env = env, .issuer = gw, .holders = {alice, taker}, .transferFee = fee}));
1127 testcase(
"MPT zero-input offer does not block the book");
1129 using namespace jtx;
1131 Account const bondIssuer{
"bondIssuer"};
1135 auto const usd = gw[
"USD"];
1137 Env env{*
this, features};
1138 env.
fund(
XRP(10'000), bondIssuer, gw, alice, carol);
1141 MPT const bond =
MPTTester({.env = env, .issuer = bondIssuer, .holders = {alice, carol}});
1144 env.
trust(usd(10'000), alice, carol, bondIssuer);
1147 env(
pay(gw, alice, usd(1'001)));
1148 env(
pay(gw, carol, usd(2'000)));
1153 auto const aliceOfferSeq = env.
seq(alice);
1154 env(
offer(alice, bond(1), usd(1'000)));
1157 auto const carolOfferSeq = env.
seq(carol);
1158 env(
offer(carol, bond(2), usd(1'000)));
1163 BEAST_EXPECT(env.
le(aliceOffer) !=
nullptr);
1164 BEAST_EXPECT(env.
le(carolOffer) !=
nullptr);
1166 env(
offer(bondIssuer, usd(500), bond(1)));
1171 BEAST_EXPECT(env.
le(aliceOffer) ==
nullptr);
1172 BEAST_EXPECT(env.
balance(alice, usd) == usd(1'001));
1173 BEAST_EXPECT(env.
balance(alice, bond) == bond(0));
1174 BEAST_EXPECT(env.
balance(bondIssuer, usd) == usd(500));
1175 BEAST_EXPECT(env.
balance(carol, usd) == usd(1'450));
1176 BEAST_EXPECT(env.
balance(carol, bond) == bond(1));
1178 auto const sle = env.
le(carolOffer);
1179 BEAST_EXPECT(sle !=
nullptr);
1182 BEAST_EXPECT((*sle)[sfTakerPays] == bond(1));
1183 BEAST_EXPECT((*sle)[sfTakerGets] == usd(500));
1194 testcase(
"MPT offer with TakerPays 2 still fills after the fee clip");
1196 using namespace jtx;
1198 Account const bondIssuer{
"bondIssuer"};
1201 auto const usd = gw[
"USD"];
1203 Env env{*
this, features};
1204 env.
fund(
XRP(10'000), bondIssuer, gw, alice);
1207 MPT const bond =
MPTTester({.env = env, .issuer = bondIssuer, .holders = {alice}});
1210 env.
trust(usd(10'000), alice, bondIssuer);
1213 env(
pay(gw, alice, usd(1'001)));
1216 auto const aliceOfferSeq = env.
seq(alice);
1217 env(
offer(alice, bond(2), usd(1'000)));
1221 BEAST_EXPECT(env.
le(aliceOffer) !=
nullptr);
1223 env(
offer(bondIssuer, usd(1'000), bond(2), tfImmediateOrCancel));
1229 BEAST_EXPECT(env.
le(aliceOffer) ==
nullptr);
1230 BEAST_EXPECT(env.
balance(alice, usd) == usd(0));
1231 BEAST_EXPECT(env.
balance(alice, bond) == bond(1));
1232 BEAST_EXPECT(env.
balance(bondIssuer, usd) == usd(910));
1242 testcase(
"Funds-limited MPT offer owner pays ceil(out * rate)");
1244 using namespace jtx;
1246 Account const issuer{
"issuer"};
1247 Account const seller{
"seller"};
1256 for (
auto const& tc : {
1257 TestCase{.funds = 10, .out = 6, .paid = 9},
1258 TestCase{.funds = 11, .out = 7, .paid = 11},
1261 Env env{*
this, features};
1262 env.
fund(
XRP(10'000), issuer, seller, buyer);
1267 {.env = env, .issuer = issuer, .holders = {seller, buyer}, .transferFee = 50'000});
1269 env(
pay(issuer, seller, usd(tc.funds)));
1272 env(
offer(seller,
XRP(100), usd(100)));
1275 auto const sellerXRPBefore = env.
balance(seller);
1277 env(
offer(buyer, usd(100),
XRP(100)));
1281 BEAST_EXPECT(env.
balance(buyer, usd) == usd(tc.out));
1282 BEAST_EXPECT(env.
balance(seller, usd) == usd(tc.funds - tc.paid));
1283 BEAST_EXPECT(env.
balance(seller) == sellerXRPBefore +
XRP(tc.out));
1284 BEAST_EXPECT(env.
balance(issuer, usd) == usd(-(tc.funds - tc.paid + tc.out)));
1294 testcase(
"Funds-limited MPT offer leftover does not block the book");
1296 using namespace jtx;
1298 Account const issuer{
"issuer"};
1299 Account const seller{
"seller"};
1303 Env env{*
this, features};
1304 env.
fund(
XRP(10'000), issuer, seller, carol, buyer);
1310 .holders = {seller, carol, buyer},
1311 .transferFee = 50'000,
1314 env(
pay(issuer, seller, usd(10)));
1315 env(
pay(issuer, carol, usd(100)));
1319 auto const sellerOfferSeq = env.
seq(seller);
1320 env(
offer(seller,
XRP(100), usd(100)));
1321 auto const carolOfferSeq = env.
seq(carol);
1322 env(
offer(carol,
XRP(200), usd(100)));
1325 env(
offer(buyer, usd(10),
XRP(20)));
1333 BEAST_EXPECT(env.
balance(seller, usd) == usd(1));
1334 BEAST_EXPECT(env.
balance(carol, usd) == usd(94));
1335 BEAST_EXPECT(env.
balance(buyer, usd) == usd(10));
1336 BEAST_EXPECT(env.
balance(issuer, usd) == usd(-105));
1339 BEAST_EXPECT(sle !=
nullptr);
1342 BEAST_EXPECT((*sle)[sfTakerPays] ==
XRP(192));
1343 BEAST_EXPECT((*sle)[sfTakerGets] == usd(96));
1356 testcase(
"XRP offer whose fee-clipped input truncates to zero");
1358 using namespace jtx;
1365 auto const usd = gw[
"USD"];
1368 env.
fund(
XRP(10'000), gw, alice, carol, dan);
1372 env.
trust(usd(10'000), alice, carol, dan);
1375 env(
pay(gw, alice, usd(1'001)));
1376 env(
pay(gw, carol, usd(2'000)));
1380 auto const aliceOfferSeq = env.
seq(alice);
1384 auto const carolOfferSeq = env.
seq(carol);
1390 BEAST_EXPECT(env.
le(aliceOffer) !=
nullptr);
1391 BEAST_EXPECT(env.
le(carolOffer) !=
nullptr);
1396 if (fs[featureMPTokensV2])
1399 BEAST_EXPECT(env.
le(aliceOffer) ==
nullptr);
1400 BEAST_EXPECT(env.
balance(dan, usd) == usd(500));
1401 BEAST_EXPECT(env.
balance(carol, usd) == usd(1'450));
1403 auto const sle = env.
le(carolOffer);
1404 BEAST_EXPECT(sle !=
nullptr);
1407 BEAST_EXPECT((*sle)[sfTakerPays] ==
drops(1));
1408 BEAST_EXPECT((*sle)[sfTakerGets] == usd(500));
1416 auto const sle = env.
le(aliceOffer);
1417 BEAST_EXPECT(sle !=
nullptr);
1420 BEAST_EXPECT((*sle)[sfTakerPays] ==
drops(1));
1421 BEAST_EXPECT((*sle)[sfTakerGets] == usd(1'000));
1423 BEAST_EXPECT(env.
balance(dan, usd) == usd(0));
1424 BEAST_EXPECT(env.
balance(carol, usd) == usd(2'000));
1429 BEAST_EXPECT(env.
balance(alice, usd) == usd(1'001));
1432 test(features - featureMPTokensV2);
1443 testcase(
"MPT offer with a large TakerPays rests at its true quality");
1445 using namespace jtx;
1450 auto const usd = gw[
"USD"];
1452 Env env{*
this, features};
1453 env.
fund(
XRP(10'000), gw, alice, carol);
1456 MPT const mpt =
MPTTester({.env = env, .issuer = gw, .holders = {alice, carol}});
1458 env.
trust(usd(10'000), alice, carol);
1461 STAmount const dust{usd.issue(), 1, -7};
1462 env(
pay(gw, alice, dust));
1463 env(
pay(gw, carol, usd(100)));
1466 auto const carolOfferSeq = env.
seq(carol);
1467 env(
offer(carol, mpt(100), usd(100)));
1470 STAmount const largeMpt = mpt(184'467'440'737'095'516);
1471 auto const aliceOfferSeq = env.
seq(alice);
1472 env(
offer(alice, largeMpt, dust));
1477 BEAST_EXPECT(sle !=
nullptr);
1483 auto const aliceRate = dirQuality(alice, aliceOfferSeq);
1484 auto const carolRate = dirQuality(carol, carolOfferSeq);
1488 BEAST_EXPECT(carolRate < aliceRate);
1494 using namespace jtx;
1495 auto const alice =
Account{
"alice"};
1496 auto const bob =
Account{
"bob"};
1499 testcase(
"Partially funded MPT/XRP input offer cannot be consumed for free");
1501 Env env{*
this, features};
1502 auto const gw =
Account{
"gw"};
1504 env.
fund(
XRP(10'000), gw, alice, bob);
1507 MPTTester const usd({.env = env, .issuer = gw, .holders = {alice}});
1509 auto const aliceOfferSeq = env.
seq(alice);
1513 auto const targetBalance =
reserve(env, 2) +
drops(999'999);
1519 auto const aliceXRPBefore = env.
balance(alice);
1520 auto const bobXRPBefore = env.
balance(bob);
1522 env(
pay(gw, bob,
drops(1'000'000)),
1525 Txflags(tfNoRippleDirect | tfPartialPayment),
1540 BEAST_EXPECT(env.
balance(alice) == aliceXRPBefore);
1541 BEAST_EXPECT(env.
balance(bob) == bobXRPBefore);
1545 testcase(
"Partially funded MPT/IOU input offer cannot be consumed for free");
1547 Env env{*
this, features};
1548 auto const mptIssuer =
Account{
"mptIssuer"};
1549 auto const iouIssuer =
Account{
"iouIssuer"};
1551 env.
fund(
XRP(10'000), mptIssuer, iouIssuer, alice, bob);
1554 auto const eur = iouIssuer[
"EUR"];
1555 env.
trust(eur(100), alice, bob);
1556 env(
pay(iouIssuer, alice, eur(0.5)));
1559 MPTTester const usd({.env = env, .issuer = mptIssuer, .holders = {alice}});
1561 auto const aliceOfferSeq = env.
seq(alice);
1562 env(
offer(alice, usd(1), eur(1)));
1565 auto const aliceEURBefore = env.
balance(alice, eur);
1566 auto const bobEURBefore = env.
balance(bob, eur);
1568 env(
pay(mptIssuer, bob, eur(1)),
1571 Txflags(tfNoRippleDirect | tfPartialPayment),
1581 BEAST_EXPECT(env.
balance(alice, eur) == aliceEURBefore);
1582 BEAST_EXPECT(env.
balance(bob, eur) == bobEURBefore);
1586 testcase(
"Partially funded MPT/MPT input offer cannot be consumed for free");
1588 Env env{*
this, features};
1589 auto const issuerA =
Account{
"issuerA"};
1590 auto const issuerB =
Account{
"issuerB"};
1592 env.
fund(
XRP(10'000), issuerA, issuerB, alice, bob);
1595 MPTTester const usd({.env = env, .issuer = issuerA, .holders = {alice}});
1596 MPTTester const eur({.env = env, .issuer = issuerB, .holders = {alice, bob}});
1598 env(
pay(issuerB, alice, eur(999'999)));
1601 auto const aliceOfferSeq = env.
seq(alice);
1602 env(
offer(alice, usd(1), eur(1'000'000)));
1605 auto const aliceEURBefore = eur.getBalance(alice);
1606 auto const bobEURBefore = eur.getBalance(bob);
1608 env(
pay(issuerA, bob, eur(1'000'000)),
1611 Txflags(tfNoRippleDirect | tfPartialPayment),
1621 BEAST_EXPECT(env.
balance(alice, eur) == eur(aliceEURBefore));
1622 BEAST_EXPECT(env.
balance(bob, eur) == eur(bobEURBefore));
1632 "Partially funded MPT input offer is removed, not consumed, "
1633 "when a funded offer crosses");
1635 Env env{*
this, features};
1636 auto const gw =
Account{
"gw"};
1637 auto const carol =
Account{
"carol"};
1639 env.
fund(
XRP(10'000), gw, alice, carol, bob);
1642 MPTTester const usd({.env = env, .issuer = gw, .holders = {alice, carol, bob}});
1648 auto const aliceOfferSeq = env.
seq(alice);
1652 auto const targetBalance =
reserve(env, 2) +
drops(999'999);
1660 auto const carolOfferSeq = env.
seq(carol);
1665 env(
pay(gw, bob, usd(2)));
1670 BEAST_EXPECT(env.
le(aliceOffer) !=
nullptr);
1671 BEAST_EXPECT(env.
le(carolOffer) !=
nullptr);
1673 auto const aliceXRPBefore = env.
balance(alice);
1674 auto const bobXRPBefore = env.
balance(bob);
1680 env(
offer(bob,
drops(2'000'000), usd(2), tfImmediateOrCancel));
1683 BEAST_EXPECT(env.
le(aliceOffer) ==
nullptr);
1684 BEAST_EXPECT(env.
le(carolOffer) ==
nullptr);
1689 BEAST_EXPECT(env.
balance(alice) == aliceXRPBefore);
1690 BEAST_EXPECT(env.
balance(alice, usd) == usd(0));
1691 BEAST_EXPECT(env.
balance(carol, usd) == usd(1));
1692 BEAST_EXPECT(env.
balance(bob, usd) == usd(1));
1701 testcase(
"Book with destroyed MPT issuance as input");
1703 using namespace jtx;
1705 Account const issuer{
"issuer"};
1710 Env env{*
this, features};
1711 env.
fund(
XRP(10'000), issuer, gw, alice, carol);
1714 auto const usd = gw[
"USD"];
1715 env.
trust(usd(1'000), alice, carol);
1716 env(
pay(gw, carol, usd(100)));
1719 MPTTester bond({.env = env, .issuer = issuer, .holders = {carol}});
1723 auto const carolOfferSeq = env.
seq(carol);
1724 env(
offer(carol, bond(10), usd(10)));
1732 BEAST_EXPECT(env.
le(carolOffer) !=
nullptr);
1737 env(
pay(issuer, alice, usd(10)),
1744 BEAST_EXPECT(env.
le(carolOffer) !=
nullptr);
1745 BEAST_EXPECT(env.
balance(alice, usd) == usd(0));
1746 BEAST_EXPECT(env.
balance(carol, usd) == usd(100));
1760 using namespace jtx;
1762 auto const gw =
Account{
"gateway"};
1763 auto const alice =
Account{
"alice"};
1764 auto const bob =
Account{
"bob"};
1765 auto const carol =
Account{
"carol"};
1767 auto const xrpOffer =
XRP(1'000);
1771 Env env{*
this, features};
1775 auto const f = env.
current()->fees().base;
1776 auto const r =
reserve(env, 0);
1778 env.
fund(r + f, alice);
1780 MPT const usd =
MPTTester({.env = env, .issuer = gw, .holders = {alice}});
1782 auto const usdOffer = usd(1'000);
1792 Env env{*
this, features};
1796 auto const f = env.
current()->fees().base;
1797 auto const r =
reserve(env, 0);
1799 env.
fund(r + f, alice);
1800 env.
fund(r + 2 * f + xrpOffer, bob);
1802 MPT const usd =
MPTTester({.env = env, .issuer = gw, .holders = {alice, bob}});
1804 auto const usdOffer = usd(1'000);
1805 auto const usdOffer2 = usd(500);
1806 auto const xrpOffer2 =
XRP(500);
1814 Balance(alice, r - f + xrpOffer2),
1826 Env env{*
this, features};
1830 auto const f = env.
current()->fees().base;
1831 auto const r =
reserve(env, 0);
1833 env.
fund(r + f, alice);
1835 MPT const usd =
MPTTester({.env = env, .issuer = gw, .holders = {alice}});
1837 auto const usdOffer = usd(1'000);
1838 auto const usdOffer2 = usd(500);
1839 auto const xrpOffer2 =
XRP(500);
1841 env.
fund(r + f + xrpOffer, bob, carol);
1849 Balance(alice, r - f + xrpOffer),
1855 Balance(carol, r + xrpOffer2),
1867 if (sle->getType() == ltOFFER)
1868 result.push_back(sle);
1878 using namespace jtx;
1880 auto const startBalance =
XRP(1'000'000);
1881 auto const gw =
Account{
"gateway"};
1882 auto const alice =
Account{
"alice"};
1883 auto const bob =
Account{
"bob"};
1890 Env env{*
this, features};
1892 auto const f = env.
current()->fees().base;
1894 env.
fund(startBalance, gw, alice, bob);
1896 MPTTester musd({.env = env, .issuer = gw});
1897 MPT const usd = musd[
"USD"];
1900 env(
offer(bob, usd(500),
XRP(500)),
1913 musd.authorize({.account = alice});
1920 Balance(alice, startBalance - (f * 2)),
1924 Balance(bob, startBalance - (f * 2)),
1933 Balance(alice, startBalance - (f * 3) +
XRP(500)),
1937 Balance(bob, startBalance - (f * 2) -
XRP(500)),
1946 Env env{*
this, features};
1948 auto const f = env.
current()->fees().base;
1950 env.
fund(startBalance, gw, alice, bob);
1952 MPT const usd =
MPTTester({.env = env, .issuer = gw, .holders = {alice}});
1958 env(
offer(alice,
XRP(1'000), usd(1000)),
1964 Balance(alice, startBalance - f - f),
1974 Balance(alice, startBalance - f - f - f +
XRP(50)),
1988 Balance(alice, startBalance - f - f - f - f +
XRP(100)),
1992 Balance(bob, startBalance - f - f -
XRP(100)),
2000 Env env(*
this, features);
2002 env.
fund(startBalance, gw, alice, bob);
2005 MPT const usd =
MPTTester({.env = env, .issuer = gw, .holders = {bob}});
2007 env(
pay(gw, bob, usd(1'000)));
2010 env(
offer(alice, usd(1'000),
XRP(2'000)));
2014 BEAST_EXPECT(aliceOffers.size() == 1);
2015 for (
auto const& offerPtr : aliceOffers)
2017 auto const&
offer = *offerPtr;
2018 BEAST_EXPECT(
offer[sfTakerGets] ==
XRP(2'000));
2019 BEAST_EXPECT(
offer[sfTakerPays] == usd(1'000));
2024 env(
offer(bob,
XRP(2'000), usd(1'000), tfPassive));
2029 BEAST_EXPECT(bobOffers.size() == 1);
2030 for (
auto const& offerPtr : bobOffers)
2032 auto const&
offer = *offerPtr;
2033 BEAST_EXPECT(
offer[sfTakerGets] == usd(1'000));
2034 BEAST_EXPECT(
offer[sfTakerPays] ==
XRP(2'000));
2038 env(
offer(gw,
XRP(2'000), usd(1'000)));
2044 env(
offer(gw, usd(1'000),
XRP(2'000)));
2052 Env env(*
this, features);
2054 env.
fund(startBalance, gw,
"alice",
"bob");
2057 MPT const usd =
MPTTester({.env = env, .issuer = gw, .holders = {bob}});
2059 env(
pay(gw,
"bob", usd(10'000)));
2060 env(
offer(
"alice", usd(5'000),
XRP(1'001)));
2063 env(
offer(
"alice", usd(5'000),
XRP(1'000)));
2067 BEAST_EXPECT(aliceOffers.size() == 2);
2072 env(
offer(
"bob",
XRP(2'000), usd(10'000), tfPassive));
2077 BEAST_EXPECT(bobOffers.size() == 1);
2078 for (
auto const& offerPtr : bobOffers)
2080 auto const&
offer = *offerPtr;
2081 BEAST_EXPECT(
offer[sfTakerGets] == usd(4'995));
2082 BEAST_EXPECT(
offer[sfTakerPays] ==
XRP(999));
2090 testcase(
"MPT AMM limitQuality checks rounded integral output");
2092 using namespace jtx;
2103 Env env{*
this, features};
2105 env.
fund(
XRP(10'000), gw, alice, bob);
2111 .holders = {alice, bob},
2115 AMM const amm(env, alice,
XRP(100), btc(1'000));
2117 auto const bobBTCBefore = btc.getBalance(bob);
2118 auto const [xrpBefore, btcBefore, lpBefore] =
amm.balances();
2123 auto const [xrpAfter, btcAfter, lpAfter] =
amm.balances();
2124 BEAST_EXPECT(btc.getBalance(bob) == bobBTCBefore + 32);
2125 BEAST_EXPECT(xrpAfter > xrpBefore);
2126 BEAST_EXPECT(btcAfter < btcBefore);
2127 BEAST_EXPECT(lpAfter == lpBefore);
2136 Env env{*
this, features};
2138 env.
fund(
XRP(10'000), gw, alice, bob);
2144 .holders = {alice, bob},
2148 AMM const amm(env, alice,
XRP(100), btc(1'000));
2150 auto const bobBTCBefore = btc.getBalance(bob);
2151 auto const [xrpBefore, btcBefore, lpBefore] =
amm.balances();
2153 env(
offer(bob, btc(100),
drops(10'340'000)));
2156 auto const [xrpAfter, btcAfter, lpAfter] =
amm.balances();
2157 BEAST_EXPECT(btc.getBalance(bob) == bobBTCBefore + 32);
2158 BEAST_EXPECT(xrpAfter > xrpBefore);
2159 BEAST_EXPECT(btcAfter < btcBefore);
2160 BEAST_EXPECT(lpAfter == lpBefore);
2164 if (BEAST_EXPECT(bobOffers.size() == 1))
2166 BEAST_EXPECT((*bobOffers[0])[sfTakerPays] != btc(100));
2167 BEAST_EXPECT((*bobOffers[0])[sfTakerGets] !=
drops(10'340'000));
2176 Env env{*
this, features};
2178 env.
fund(
XRP(10'000), gw, alice, bob);
2184 .holders = {alice, bob},
2188 AMM const amm(env, alice,
drops(1'000), btc(100'000'000));
2190 auto const bobXRPBefore = env.
balance(bob,
XRP);
2191 auto const baseFee = env.
current()->fees().base;
2192 auto const [xrpBefore, btcBefore, lpBefore] =
amm.balances();
2197 auto const [xrpAfter, btcAfter, lpAfter] =
amm.balances();
2199 BEAST_EXPECT(xrpAfter < xrpBefore);
2200 BEAST_EXPECT(btcAfter > btcBefore);
2201 BEAST_EXPECT(lpAfter == lpBefore);
2209 Env env{*
this, features};
2211 env.
fund(
XRP(10'000), gw, alice, bob);
2217 .holders = {alice, bob},
2221 AMM const amm(env, alice,
drops(1'000), btc(100'000'000));
2223 auto const bobXRPBefore = env.
balance(bob,
XRP);
2224 auto const baseFee = env.
current()->fees().base;
2225 auto const [xrpBefore, btcBefore, lpBefore] =
amm.balances();
2227 env(
offer(bob,
drops(100), btc(10'340'000)));
2230 auto const [xrpAfter, btcAfter, lpAfter] =
amm.balances();
2232 BEAST_EXPECT(xrpAfter < xrpBefore);
2233 BEAST_EXPECT(btcAfter > btcBefore);
2234 BEAST_EXPECT(lpAfter == lpBefore);
2238 if (BEAST_EXPECT(bobOffers.size() == 1))
2240 BEAST_EXPECT((*bobOffers[0])[sfTakerPays] !=
drops(100));
2241 BEAST_EXPECT((*bobOffers[0])[sfTakerGets] != btc(10'340'000));
2251 using namespace jtx;
2253 auto const startBalance =
XRP(1'000'000);
2254 auto const gw =
Account{
"gateway"};
2255 auto const alice =
Account{
"alice"};
2257 Env env{*
this, features};
2259 env.
fund(startBalance, gw, alice);
2261 MPT const usd =
MPTTester({.env = env, .issuer = gw, .holders = {alice}});
2291 using namespace jtx;
2293 auto const gw =
Account{
"gateway"};
2294 auto const alice =
Account{
"alice"};
2295 auto const bob =
Account{
"bob"};
2297 auto const startBalance =
XRP(1'000'000);
2298 auto const xrpOffer =
XRP(1'000);
2300 Env env{*
this, features};
2302 env.
fund(startBalance, gw, alice, bob);
2305 auto const f = env.
current()->fees().base;
2307 MPT const usd =
MPTTester({.env = env, .issuer = gw, .holders = {alice}});
2308 auto const usdOffer = usd(1'000);
2313 Balance(alice, startBalance - f),
2319 env(
offer(alice, xrpOffer, usdOffer),
2324 Balance(alice, startBalance - f - f),
2331 env(
offer(alice, xrpOffer, usdOffer),
2335 Balance(alice, startBalance - f - f - f),
2343 Balance(alice, startBalance - f - f - f),
2352 Balance(alice, startBalance - f - f - f),
2356 Balance(bob, startBalance - f),
2367 using namespace jtx;
2369 auto const gw =
Account{
"gateway"};
2371 auto const xrpOffer =
XRP(1'000);
2373 Env env{*
this, features};
2378 auto const f = env.
current()->fees().base;
2384 auto const usdOffer = usd(1'000);
2419 using namespace jtx;
2420 auto const gw =
Account{
"gateway"};
2421 auto const partner =
Account{
"partner"};
2423 auto const test = [&](
auto&& issue1,
auto&& issue2) {
2424 Env env{*
this, features};
2428 auto const usd = issue1({.env = env, .token =
"USD", .issuer = gw});
2429 auto const btc = issue2({.env = env, .token =
"BTC", .issuer = gw});
2434 env.
fund(
XRP(10'000), partner);
2437 env(
trust(partner, usd(100)));
2446 env(
trust(partner, btc(500)));
2453 env(
pay(gw, partner, usd(100)));
2454 env(
pay(gw, partner, btc(500)));
2456 auto const& accountToTest = usePartner ? partner : gw;
2464 env(
offer(accountToTest, btc(250),
XRP(1'000)));
2468 BEAST_EXPECT(
isOffer(env, accountToTest, btc(250),
XRP(1'000)));
2470 auto const secondLegSeq = env.
seq(accountToTest);
2471 env(
offer(accountToTest,
XRP(1'000), usd(50)));
2475 BEAST_EXPECT(
isOffer(env, accountToTest,
XRP(1'000), usd(50)));
2479 env(
offer(accountToTest, usd(50), btc(250)));
2482 BEAST_EXPECT(jrr[jss::offers].isArray());
2483 BEAST_EXPECT(jrr[jss::offers].size() == 0);
2486 BEAST_EXPECT(jrr[jss::offers].isArray());
2487 BEAST_EXPECT(jrr[jss::offers].size() == 0);
2494 BEAST_EXPECT(acctOffers.empty());
2495 for (
auto const& offerPtr : acctOffers)
2497 auto const&
offer = *offerPtr;
2498 BEAST_EXPECT(
offer[sfLedgerEntryType] == ltOFFER);
2499 BEAST_EXPECT(
offer[sfTakerGets] == usd(0));
2500 BEAST_EXPECT(
offer[sfTakerPays] ==
XRP(0));
2513 env(
offer(accountToTest, btc(250), usd(50)));
2518 BEAST_EXPECT(
isOffer(env, accountToTest, btc(250), usd(50)));
2521 BEAST_EXPECT(jrr[jss::offers].isArray());
2522 BEAST_EXPECT(jrr[jss::offers].size() == 0);
2526 env(
offer(accountToTest, usd(50), btc(250)));
2532 BEAST_EXPECT(jrr[jss::offers].isArray());
2533 BEAST_EXPECT(jrr[jss::offers].size() == 0);
2535 BEAST_EXPECT(
isOffer(env, accountToTest, usd(50), btc(250)));
2547 using namespace jtx;
2548 FeatureBitset const localFeatures = features | fixReducedOffersV2;
2550 Env env{*
this, localFeatures};
2552 auto const gw =
Account{
"gateway"};
2553 auto const alice =
Account{
"alice"};
2554 auto const bob =
Account{
"bob"};
2558 auto const gwInitialBalance =
drops(1'149'999'730);
2559 auto const aliceInitialBalance =
drops(499'946'999'680);
2560 auto const bobInitialBalance =
drops(10'199'999'920);
2562 env.
fund(gwInitialBalance, gw);
2563 env.
fund(aliceInitialBalance, alice);
2564 env.
fund(bobInitialBalance, bob);
2567 {.env = env, .issuer = gw, .holders = {alice, bob}, .transferFee = 5'000});
2568 MPT const usd = musd;
2569 auto const smallAmount =
STAmount{usd, 1};
2571 env(
pay(gw, alice, usd(50)));
2572 env(
pay(gw, bob, smallAmount));
2574 env(
offer(alice, usd(50),
XRP(150'000)));
2577 env(
pay(alice, gw, usd(50)));
2582 BEAST_EXPECT(!jrr[jss::node].isMember(sfMPTAmount.fieldName));
2585 BEAST_EXPECT(jrr[jss::node][sfMPTAmount.fieldName] ==
"1");
2589 env(
offer(bob,
XRP(2000), usd(1)));
2595 BEAST_EXPECT(jrr[jss::node][sfMPTAmount.fieldName] ==
"1");
2598 BEAST_EXPECT(bobOffer[sfTakerGets.jsonName][jss::value] ==
"1");
2599 BEAST_EXPECT(bobOffer[sfTakerPays.jsonName] ==
"2000000000");
2606 std::string(
"Offer Crossing with XRP, ") + (reverseOrder ?
"Reverse" :
"Normal") +
2609 using namespace jtx;
2611 Env env{*
this, features};
2613 auto const gw =
Account{
"gateway"};
2614 auto const alice =
Account{
"alice"};
2615 auto const bob =
Account{
"bob"};
2617 env.
fund(
XRP(10'000), gw, alice, bob);
2619 MPT const usd =
MPTTester({.env = env, .issuer = gw, .holders = {alice, bob}});
2621 env(
pay(gw, alice, usd(500)));
2624 env(
offer(bob, usd(1),
XRP(4'000)));
2626 env(
offer(alice,
XRP(150'000), usd(50)));
2629 env(
offer(bob, usd(1),
XRP(4000)));
2636 BEAST_EXPECT(jrr[jss::node][sfMPTAmount.fieldName] ==
"1");
2639 jrr[jss::node][sfBalance.fieldName] ==
2641 (
XRP(10000) -
XRP(reverseOrder ? 4000 : 3000) - env.
current()->fees().base * 2)
2645 BEAST_EXPECT(jrr[jss::node][sfMPTAmount.fieldName] ==
"499");
2648 jrr[jss::node][sfBalance.fieldName] ==
2650 (
XRP(10000) +
XRP(reverseOrder ? 4000 : 3000) - env.
current()->fees().base * 2)
2657 testcase(
"Offer Crossing with Limit Override");
2659 using namespace jtx;
2661 Env env{*
this, features};
2663 auto const gw =
Account{
"gateway"};
2664 auto const alice =
Account{
"alice"};
2665 auto const bob =
Account{
"bob"};
2667 env.
fund(
XRP(100000), gw, alice, bob);
2669 MPT const usd =
MPTTester({.env = env, .issuer = gw, .holders = {alice}});
2671 env(
pay(gw, alice, usd(500)));
2673 env(
offer(alice,
XRP(150'000), usd(50)));
2674 env(
offer(bob, usd(1),
XRP(3'000)));
2677 BEAST_EXPECT(jrr[jss::node][sfMPTAmount.fieldName] ==
"1");
2680 jrr[jss::node][sfBalance.fieldName] ==
2684 BEAST_EXPECT(jrr[jss::node][sfMPTAmount.fieldName] ==
"499");
2687 jrr[jss::node][sfBalance.fieldName] ==
2694 testcase(
"Offer Accept then Cancel.");
2696 using namespace jtx;
2698 Env env{*
this, features};
2702 auto const nextOfferSeq = env.
seq(env.
master);
2707 BEAST_EXPECT(env.
seq(env.
master) == nextOfferSeq + 2);
2712 BEAST_EXPECT(env.
seq(env.
master) == nextOfferSeq + 2);
2718 testcase(
"Currency Conversion: Entire Offer");
2720 using namespace jtx;
2722 Env env{*
this, features};
2724 auto const gw =
Account{
"gateway"};
2725 auto const alice =
Account{
"alice"};
2726 auto const bob =
Account{
"bob"};
2728 env.
fund(
XRP(10'000), gw, alice, bob);
2731 MPT const usd =
MPTTester({.env = env, .issuer = gw, .holders = {alice, bob}});
2735 env(
pay(gw, alice, usd(100)));
2736 auto const bobOfferSeq = env.
seq(bob);
2737 env(
offer(bob, usd(100),
XRP(500)));
2741 BEAST_EXPECT(jro[jss::node][jss::TakerGets] ==
XRP(500).value().getText());
2748 BEAST_EXPECT(!jrr[jss::node].isMember(sfMPTAmount.fieldName));
2751 jrr[jss::node][sfBalance.fieldName] ==
2755 BEAST_EXPECT(jrr[jss::node][sfMPTAmount.fieldName] ==
"100");
2758 BEAST_EXPECT(jro[jss::error] ==
"entryNotFound");
2760 BEAST_EXPECT(jro[jss::error_message] ==
"Entry not found.");
2768 testcase(
"Currency Conversion: Offerer Into Debt");
2770 using namespace jtx;
2771 auto const alice =
Account{
"alice"};
2772 auto const bob =
Account{
"bob"};
2773 auto const carol =
Account{
"carol"};
2775 auto const test = [&](
auto&& issue1,
auto&& issue2,
auto&& issue3) {
2776 Env env{*
this, features};
2778 env.
fund(
XRP(10'000), alice, bob, carol);
2781 issue1({.env = env, .token =
"USD", .issuer = alice, .holders = {bob}});
2783 issue2({.env = env, .token =
"EUC", .issuer = carol, .holders = {alice}});
2785 issue3({.env = env, .token =
"EUB", .issuer = bob, .holders = {carol}});
2787 auto const bobOfferSeq = env.
seq(bob);
2790 env(
offer(alice, eurc(200), usd(50)));
2793 BEAST_EXPECT(jro[jss::error] ==
"entryNotFound");
2795 BEAST_EXPECT(jro[jss::error_message] ==
"Entry not found.");
2803 testcase(
"Currency Conversion: In Parts");
2805 using namespace jtx;
2807 Env env{*
this, features};
2809 auto const gw =
Account{
"gateway"};
2810 auto const alice =
Account{
"alice"};
2811 auto const bob =
Account{
"bob"};
2813 env.
fund(
XRP(10'000), gw, alice, bob);
2815 MPT const usd =
MPTTester({.env = env, .issuer = gw, .holders = {alice, bob}});
2817 env(
pay(gw, alice, usd(200)));
2819 auto const bobOfferSeq = env.
seq(bob);
2820 env(
offer(bob, usd(100),
XRP(500)));
2826 BEAST_EXPECT(jro[jss::node][jss::TakerGets] ==
XRP(300).value().getText());
2833 BEAST_EXPECT(jrr[jss::node][sfMPTAmount.fieldName] ==
"160");
2837 jrr[jss::node][sfBalance.fieldName] ==
2842 BEAST_EXPECT(jrr[jss::node][sfMPTAmount.fieldName] ==
"40");
2854 BEAST_EXPECT(jro[jss::error] ==
"entryNotFound");
2856 BEAST_EXPECT(jro[jss::error_message] ==
"Entry not found.");
2864 BEAST_EXPECT(jrr[jss::node][sfMPTAmount.fieldName] ==
"100");
2867 jrr[jss::node][sfBalance.fieldName] ==
2873 BEAST_EXPECT(jrr[jss::node][sfMPTAmount.fieldName] ==
"100");
2879 testcase(
"Cross Currency Payment: Start with XRP");
2881 using namespace jtx;
2883 Env env{*
this, features};
2885 auto const gw =
Account{
"gateway"};
2886 auto const alice =
Account{
"alice"};
2887 auto const bob =
Account{
"bob"};
2888 auto const carol =
Account{
"carol"};
2890 env.
fund(
XRP(10'000), gw, alice, bob, carol);
2892 MPT const usd =
MPTTester({.env = env, .issuer = gw, .holders = {carol, bob}});
2894 env(
pay(gw, carol, usd(500)));
2896 auto const carolOfferSeq = env.
seq(carol);
2897 env(
offer(carol,
XRP(500), usd(50)));
2902 BEAST_EXPECT(jrr[jss::node][sfMPTAmount.fieldName] ==
"25");
2905 BEAST_EXPECT(jrr[jss::node][sfMPTAmount.fieldName] ==
"475");
2910 BEAST_EXPECT(jro[jss::node][jss::TakerPays] ==
XRP(250).value().getText());
2916 testcase(
"Cross Currency Payment: End with XRP");
2918 using namespace jtx;
2920 Env env{*
this, features};
2922 auto const gw =
Account{
"gateway"};
2923 auto const alice =
Account{
"alice"};
2924 auto const bob =
Account{
"bob"};
2925 auto const carol =
Account{
"carol"};
2927 env.
fund(
XRP(10'000), gw, alice, bob, carol);
2929 MPT const usd =
MPTTester({.env = env, .issuer = gw, .holders = {alice, carol}});
2931 env(
pay(gw, alice, usd(500)));
2933 auto const carolOfferSeq = env.
seq(carol);
2934 env(
offer(carol, usd(50),
XRP(500)));
2939 BEAST_EXPECT(jrr[jss::node][sfMPTAmount.fieldName] ==
"475");
2942 BEAST_EXPECT(jrr[jss::node][sfMPTAmount.fieldName] ==
"25");
2946 jrr[jss::node][sfBalance.fieldName] ==
2950 BEAST_EXPECT(jro[jss::node][jss::TakerGets] ==
XRP(250).value().getText());
2958 testcase(
"Cross Currency Payment: Bridged");
2960 using namespace jtx;
2961 auto const gw1 =
Account{
"gateway_1"};
2962 auto const gw2 =
Account{
"gateway_2"};
2963 auto const alice =
Account{
"alice"};
2964 auto const bob =
Account{
"bob"};
2965 auto const carol =
Account{
"carol"};
2966 auto const dan =
Account{
"dan"};
2968 auto const test = [&](
auto&& issue1,
auto&& issue2) {
2969 Env env{*
this, features};
2971 env.
fund(
XRP(10'000), gw1, gw2, alice, bob, carol, dan);
2974 issue1({.env = env, .token =
"USD", .issuer = gw1, .holders = {alice, carol}});
2976 issue1({.env = env, .token =
"EUR", .issuer = gw2, .holders = {bob, dan}});
2978 env(
pay(gw1, alice, usd(500)));
2979 env(
pay(gw2, dan, eur(400)));
2981 auto const carolOfferSeq = env.
seq(carol);
2982 env(
offer(carol, usd(50),
XRP(500)));
2984 auto const danOfferSeq = env.
seq(dan);
2985 env(
offer(dan,
XRP(500), eur(50)));
2988 jtp[0u][0u][jss::currency] =
"XRP";
2989 env(
pay(alice, bob, eur(30)),
Json(jss::Paths, jtp),
Sendmax(usd(333)));
2991 BEAST_EXPECT(env.
balance(alice, usd) == usd(470));
2992 BEAST_EXPECT(env.
balance(bob, eur) == eur(30));
2993 BEAST_EXPECT(env.
balance(carol, usd) == usd(30));
2994 BEAST_EXPECT(env.
balance(dan, eur) == eur(370));
2997 BEAST_EXPECT(jro[jss::node][jss::TakerGets] ==
XRP(200).value().getText());
2999 jro[jss::node][jss::TakerPays] ==
3004 jro[jss::node][jss::TakerGets] ==
3006 BEAST_EXPECT(jro[jss::node][jss::TakerPays] ==
XRP(200).value().getText());
3017 testcase(
"Auto Bridged Second Leg Dry");
3019 using namespace jtx;
3025 auto const test = [&](
auto&& issue1,
auto&& issue2) {
3026 Env env(*
this, features);
3028 env.
fund(
XRP(100'000'000), alice, bob, carol, gw);
3032 issue1({.env = env, .token =
"USD", .issuer = gw, .holders = {alice, carol}});
3033 auto const eur = issue1({.env = env, .token =
"EUR", .issuer = gw, .holders = {bob}});
3035 env(
pay(gw, alice, usd(10)));
3036 env(
pay(gw, carol, usd(3)));
3054 env(
pay(gw, bob, eur(10)));
3056 env(
offer(bob, usd(10), eur(10)));
3081 testcase(
"Offer Fees Consume Funds");
3083 using namespace jtx;
3084 auto const gw1 =
Account{
"gateway_1"};
3085 auto const gw2 =
Account{
"gateway_2"};
3086 auto const gw3 =
Account{
"gateway_3"};
3087 auto const alice =
Account{
"alice"};
3088 auto const bob =
Account{
"bob"};
3090 auto const test = [&](
auto&& issue1,
auto&& issue2,
auto&& issue3) {
3091 Env env{*
this, features};
3098 auto const base = env.
current()->fees().base;
3099 auto const startingXrp =
3100 XRP(100) + env.
current()->fees().accountReserve(3, 1) + base * 4;
3102 env.
fund(startingXrp, gw1, gw2, gw3, alice, bob);
3106 issue1({.env = env, .token =
"US1", .issuer = gw1, .holders = {alice, bob}});
3108 issue2({.env = env, .token =
"US2", .issuer = gw2, .holders = {alice, bob}});
3110 issue3({.env = env, .token =
"US3", .issuer = gw3, .holders = {alice}});
3112 env(
pay(gw1, bob, usD1(500)));
3114 env(
offer(bob,
XRP(200), usD1(200)));
3117 env(
offer(alice, usD1(200),
XRP(200)));
3119 BEAST_EXPECT(env.
balance(alice, usD1) == usD1(100));
3123 BEAST_EXPECT(env.
balance(bob, usD1) == usD1(400));
3131 testcase(
"Offer Create, then Cross");
3133 using namespace jtx;
3135 Env env{*
this, features};
3137 auto const gw =
Account{
"gateway"};
3138 auto const alice =
Account{
"alice"};
3139 auto const bob =
Account{
"bob"};
3141 env.
fund(
XRP(10'000), gw, alice, bob);
3144 MPTTester({.env = env, .issuer = gw, .holders = {alice, bob}, .transferFee = 5'000});
3146 env(
pay(gw, bob, cur(100)));
3148 env(
offer(alice, cur(50'000),
XRP(150'000)));
3149 env(
offer(bob,
XRP(100), cur(100)));
3152 BEAST_EXPECT(jrr[jss::node][sfMPTAmount.fieldName] ==
"34");
3155 BEAST_EXPECT(jrr[jss::node][sfMPTAmount.fieldName] ==
"64");
3161 testcase(
"Offer tfSell: Basic Sell");
3163 using namespace jtx;
3165 Env env{*
this, features};
3167 auto const gw =
Account{
"gateway"};
3168 auto const alice =
Account{
"alice"};
3169 auto const bob =
Account{
"bob"};
3171 auto const startingXrp =
3172 XRP(100) + env.
current()->fees().accountReserve(1, 1) + env.
current()->fees().base * 2;
3174 env.
fund(startingXrp, gw, alice, bob);
3176 MPT const usd =
MPTTester({.env = env, .issuer = gw, .holders = {alice, bob}});
3178 env(
pay(gw, bob, usd(500)));
3180 env(
offer(bob,
XRP(200), usd(200)),
Json(jss::Flags, tfSell));
3184 env(
offer(alice, usd(200),
XRP(200)),
Json(jss::Flags, tfSell));
3187 BEAST_EXPECT(jrr[jss::node][sfMPTAmount.fieldName] ==
"100");
3190 jrr[jss::node][sfBalance.fieldName] ==
3194 BEAST_EXPECT(jrr[jss::node][sfMPTAmount.fieldName] ==
"400");
3200 testcase(
"Offer tfSell: 2x Sell Exceed Limit");
3202 using namespace jtx;
3204 Env env{*
this, features};
3206 auto const gw =
Account{
"gateway"};
3207 auto const alice =
Account{
"alice"};
3208 auto const bob =
Account{
"bob"};
3210 auto const startingXrp =
3211 XRP(100) + env.
current()->fees().accountReserve(1, 1) + env.
current()->fees().base * 2;
3213 env.
fund(startingXrp, gw, alice, bob);
3215 MPT const usd =
MPTTester({.env = env, .issuer = gw, .holders = {alice, bob}});
3217 env(
pay(gw, bob, usd(500)));
3219 env(
offer(bob,
XRP(100), usd(200)));
3225 env(
offer(alice, usd(100),
XRP(100)),
Json(jss::Flags, tfSell));
3228 BEAST_EXPECT(jrr[jss::node][sfMPTAmount.fieldName] ==
"200");
3231 jrr[jss::node][sfBalance.fieldName] ==
3235 BEAST_EXPECT(jrr[jss::node][sfMPTAmount.fieldName] ==
"300");
3241 testcase(
"Client Issue #535: Gateway Cross Currency");
3243 using namespace jtx;
3244 auto const gw =
Account{
"gateway"};
3245 auto const alice =
Account{
"alice"};
3246 auto const bob =
Account{
"bob"};
3248 auto const test = [&](
auto&& issue1,
auto&& issue2) {
3249 Env env{*
this, features};
3251 auto const base = env.
current()->fees().base;
3252 auto const startingXrp =
3253 XRP(100.1) + env.
current()->fees().accountReserve(1, 1) + base * 2;
3255 env.
fund(startingXrp, gw, alice, bob);
3259 issue1({.env = env, .token =
"XTS", .issuer = gw, .holders = {alice, bob}});
3261 issue2({.env = env, .token =
"XXX", .issuer = gw, .holders = {alice, bob}});
3264 env(
pay(gw, alice, xts(1'000)));
3265 env(
pay(gw, alice, xxx(100)));
3266 env(
pay(gw, bob, xts(1'000)));
3267 env(
pay(gw, bob, xxx(100)));
3269 env(
offer(alice, xts(1'000), xxx(100)));
3276 payment[jss::id] = env.
seq(bob);
3277 payment[jss::build_path] =
true;
3278 payment[jss::tx_json] =
pay(bob, bob, xxx(1));
3279 payment[jss::tx_json][jss::Sequence] =
3282 payment[jss::tx_json][jss::SendMax] =
3284 auto jrr = wsc->invoke(
"submit", payment);
3285 BEAST_EXPECT(jrr[jss::status] ==
"success");
3286 BEAST_EXPECT(jrr[jss::result][jss::engine_result] ==
"tesSUCCESS");
3287 if (wsc->version() == 2)
3290 BEAST_EXPECT(jrr.isMember(jss::id) && jrr[jss::id] == 5);
3293 BEAST_EXPECT(env.
balance(alice, xts) == xts(1010));
3294 BEAST_EXPECT(env.
balance(alice, xxx) == xxx(99));
3296 BEAST_EXPECT(env.
balance(bob, xts) == xts(990));
3297 BEAST_EXPECT(env.
balance(bob, xxx) == xxx(101));
3310 using namespace jtx;
3312 auto const gw =
Account(
"gateway");
3314 Env env{*
this, features};
3316 env.
fund(
XRP(10'000'000), gw);
3319 auto musd =
MPTTester({.env = env, .issuer = gw});
3320 MPT const usd = musd;
3323 auto const f = env.
current()->fees().base;
3326 enum class PreAuthType { NoPreAuth, AcctPreAuth };
3332 PreAuthType preAuth;
3343 TestData
const tests[]{
3345 {.account=
"ann", .fundXrp=
reserve(env, 0) + 0 * f, .bookAmount=1, .preAuth=PreAuthType::NoPreAuth, .offerAmount=1000, .tec=
tecUNFUNDED_OFFER, .spentXrp=f, .balanceUsd=usd( 0), .offers=0, .owners=0},
3346 {.account=
"bev", .fundXrp=
reserve(env, 0) + 1 * f, .bookAmount=1, .preAuth=PreAuthType::NoPreAuth, .offerAmount=1000, .tec=
tecUNFUNDED_OFFER, .spentXrp=f, .balanceUsd=usd( 0), .offers=0, .owners=0},
3347 {.account=
"cam", .fundXrp=
reserve(env, 0) + 2 * f, .bookAmount=0, .preAuth=PreAuthType::NoPreAuth, .offerAmount=1000, .tec=
tecINSUF_RESERVE_OFFER, .spentXrp=f, .balanceUsd=usd( 0), .offers=0, .owners=0},
3348 {.account=
"deb", .fundXrp=
reserve(env, 0) + 2 * f, .bookAmount=1, .preAuth=PreAuthType::NoPreAuth, .offerAmount=1000, .tec=
tesSUCCESS, .spentXrp=2 * f, .balanceUsd=usd( 1), .offers=0, .owners=1, .scale=100000},
3349 {.account=
"eve", .fundXrp=
reserve(env, 1) + 0 * f, .bookAmount=0, .preAuth=PreAuthType::NoPreAuth, .offerAmount=1000, .tec=
tesSUCCESS, .spentXrp=f, .balanceUsd=usd( 0), .offers=1, .owners=1},
3350 {.account=
"flo", .fundXrp=
reserve(env, 1) + 0 * f, .bookAmount=1, .preAuth=PreAuthType::NoPreAuth, .offerAmount=1000, .tec=
tesSUCCESS, .spentXrp=
XRP( 1) + f, .balanceUsd=usd( 1), .offers=0, .owners=1},
3351 {.account=
"gay", .fundXrp=
reserve(env, 1) + 1 * f, .bookAmount=1000, .preAuth=PreAuthType::NoPreAuth, .offerAmount=1000, .tec=
tesSUCCESS, .spentXrp=
XRP( 50) + f, .balanceUsd=usd( 50), .offers=0, .owners=1},
3352 {.account=
"hye", .fundXrp=
XRP(1000) + 1 * f, .bookAmount=1000, .preAuth=PreAuthType::NoPreAuth, .offerAmount=1000, .tec=
tesSUCCESS, .spentXrp=
XRP( 800) + f, .balanceUsd=usd( 800), .offers=0, .owners=1},
3353 {.account=
"ivy", .fundXrp=
XRP( 1) +
reserve(env, 1) + 1 * f, .bookAmount=1, .preAuth=PreAuthType::NoPreAuth, .offerAmount=1000, .tec=
tesSUCCESS, .spentXrp=
XRP( 1) + f, .balanceUsd=usd( 1), .offers=0, .owners=1},
3354 {.account=
"joy", .fundXrp=
XRP( 1) +
reserve(env, 2) + 1 * f, .bookAmount=1, .preAuth=PreAuthType::NoPreAuth, .offerAmount=1000, .tec=
tesSUCCESS, .spentXrp=
XRP( 1) + f, .balanceUsd=usd( 1), .offers=1, .owners=2},
3355 {.account=
"kim", .fundXrp=
XRP( 900) +
reserve(env, 2) + 1 * f, .bookAmount=999, .preAuth=PreAuthType::NoPreAuth, .offerAmount=1000, .tec=
tesSUCCESS, .spentXrp=
XRP( 999) + f, .balanceUsd=usd( 999), .offers=0, .owners=1},
3356 {.account=
"liz", .fundXrp=
XRP( 998) +
reserve(env, 0) + 1 * f, .bookAmount=999, .preAuth=PreAuthType::NoPreAuth, .offerAmount=1000, .tec=
tesSUCCESS, .spentXrp=
XRP( 998) + f, .balanceUsd=usd( 998), .offers=0, .owners=1},
3357 {.account=
"meg", .fundXrp=
XRP( 998) +
reserve(env, 1) + 1 * f, .bookAmount=999, .preAuth=PreAuthType::NoPreAuth, .offerAmount=1000, .tec=
tesSUCCESS, .spentXrp=
XRP( 999) + f, .balanceUsd=usd( 999), .offers=0, .owners=1},
3358 {.account=
"nia", .fundXrp=
XRP( 998) +
reserve(env, 2) + 1 * f, .bookAmount=999, .preAuth=PreAuthType::NoPreAuth, .offerAmount=1000, .tec=
tesSUCCESS, .spentXrp=
XRP( 999) + f, .balanceUsd=usd( 999), .offers=1, .owners=2},
3359 {.account=
"ova", .fundXrp=
XRP( 999) +
reserve(env, 0) + 1 * f, .bookAmount=1000, .preAuth=PreAuthType::NoPreAuth, .offerAmount=1000, .tec=
tesSUCCESS, .spentXrp=
XRP( 999) + f, .balanceUsd=usd( 999), .offers=0, .owners=1},
3360 {.account=
"pam", .fundXrp=
XRP( 999) +
reserve(env, 1) + 1 * f, .bookAmount=1000, .preAuth=PreAuthType::NoPreAuth, .offerAmount=1000, .tec=
tesSUCCESS, .spentXrp=
XRP(1000) + f, .balanceUsd=usd( 1000), .offers=0, .owners=1},
3361 {.account=
"rae", .fundXrp=
XRP( 999) +
reserve(env, 2) + 1 * f, .bookAmount=1000, .preAuth=PreAuthType::NoPreAuth, .offerAmount=1000, .tec=
tesSUCCESS, .spentXrp=
XRP(1000) + f, .balanceUsd=usd( 1000), .offers=0, .owners=1},
3362 {.account=
"sue", .fundXrp=
XRP(1000) +
reserve(env, 2) + 1 * f, .bookAmount=0, .preAuth=PreAuthType::NoPreAuth, .offerAmount=1000, .tec=
tesSUCCESS, .spentXrp=f, .balanceUsd=usd( 0), .offers=1, .owners=1},
3365 {.account=
"ned", .fundXrp=
reserve(env, 1) + 0 * f, .bookAmount=1, .preAuth=PreAuthType::AcctPreAuth, .offerAmount=1000, .tec=
tecUNFUNDED_OFFER, .spentXrp=2 * f, .balanceUsd=usd( 0), .offers=0, .owners=1},
3366 {.account=
"ole", .fundXrp=
reserve(env, 1) + 1 * f, .bookAmount=1, .preAuth=PreAuthType::AcctPreAuth, .offerAmount=1000, .tec=
tecUNFUNDED_OFFER, .spentXrp=2 * f, .balanceUsd=usd( 0), .offers=0, .owners=1},
3367 {.account=
"pat", .fundXrp=
reserve(env, 1) + 2 * f, .bookAmount=0, .preAuth=PreAuthType::AcctPreAuth, .offerAmount=1000, .tec=
tecUNFUNDED_OFFER, .spentXrp=2 * f, .balanceUsd=usd( 0), .offers=0, .owners=1},
3368 {.account=
"quy", .fundXrp=
reserve(env, 1) + 2 * f, .bookAmount=1, .preAuth=PreAuthType::AcctPreAuth, .offerAmount=1000, .tec=
tecUNFUNDED_OFFER, .spentXrp=2 * f, .balanceUsd=usd( 0), .offers=0, .owners=1},
3369 {.account=
"ron", .fundXrp=
reserve(env, 1) + 3 * f, .bookAmount=0, .preAuth=PreAuthType::AcctPreAuth, .offerAmount=1000, .tec=
tecINSUF_RESERVE_OFFER, .spentXrp=2 * f, .balanceUsd=usd( 0), .offers=0, .owners=1},
3370 {.account=
"syd", .fundXrp=
reserve(env, 1) + 3 * f, .bookAmount=1, .preAuth=PreAuthType::AcctPreAuth, .offerAmount=1000, .tec=
tesSUCCESS, .spentXrp=3 * f, .balanceUsd=usd( 1), .offers=0, .owners=1, .scale=100000},
3371 {.account=
"ted", .fundXrp=
XRP( 20) +
reserve(env, 1) + 2 * f, .bookAmount=1000, .preAuth=PreAuthType::AcctPreAuth, .offerAmount=1000, .tec=
tesSUCCESS, .spentXrp=
XRP(20) + 2 * f, .balanceUsd=usd( 20), .offers=0, .owners=1},
3372 {.account=
"uli", .fundXrp=
reserve(env, 2) + 0 * f, .bookAmount=0, .preAuth=PreAuthType::AcctPreAuth, .offerAmount=1000, .tec=
tecINSUF_RESERVE_OFFER, .spentXrp=2 * f, .balanceUsd=usd( 0), .offers=0, .owners=1},
3373 {.account=
"vic", .fundXrp=
reserve(env, 2) + 0 * f, .bookAmount=1, .preAuth=PreAuthType::AcctPreAuth, .offerAmount=1000, .tec=
tesSUCCESS, .spentXrp=
XRP( 1) + 2 * f, .balanceUsd=usd( 1), .offers=0, .owners=1},
3374 {.account=
"wes", .fundXrp=
reserve(env, 2) + 1 * f, .bookAmount=0, .preAuth=PreAuthType::AcctPreAuth, .offerAmount=1000, .tec=
tesSUCCESS, .spentXrp=2 * f, .balanceUsd=usd( 0), .offers=1, .owners=2},
3375 {.account=
"xan", .fundXrp=
reserve(env, 2) + 1 * f, .bookAmount=1, .preAuth=PreAuthType::AcctPreAuth, .offerAmount=1000, .tec=
tesSUCCESS, .spentXrp=
XRP( 1) + 2 * f, .balanceUsd=usd( 1), .offers=1, .owners=2},
3379 for (
auto const& t :
tests)
3381 auto const acct =
Account(t.account);
3382 env.
fund(t.fundXrp, acct);
3389 auto const book = t.bookAmount;
3391 env(
offer(gw,
XRP(book), usd(book * t.scale)));
3398 if (t.preAuth == PreAuthType::AcctPreAuth)
3399 musd.authorize({.account = acct});
3404 auto const acctOffer = t.offerAmount;
3405 env(
offer(acct, usd(acctOffer * t.scale),
XRP(acctOffer)),
Ter(t.tec));
3410 auto const expBalanceUsd = [&] {
3412 return t.balanceUsd;
3415 return usd(f.value() / 10);
3417 BEAST_EXPECT(env.
balance(acct, usd) == expBalanceUsd);
3418 BEAST_EXPECT(env.
balance(acct,
xrpIssue()) == t.fundXrp - t.spentXrp);
3423 BEAST_EXPECT(acctOffers.size() == t.offers);
3424 if (!acctOffers.empty() && t.offers != 0)
3426 auto const& acctOffer = *acctOffers.front();
3428 auto const leftover = t.offerAmount - t.bookAmount;
3429 BEAST_EXPECT(acctOffer[sfTakerGets] ==
XRP(leftover));
3430 BEAST_EXPECT(acctOffer[sfTakerPays] == usd(leftover));
3433 if (t.preAuth == PreAuthType::NoPreAuth)
3435 if (t.balanceUsd.value().signum() != 0)
3438 BEAST_EXPECT(env.
balance(acct, usd) == expBalanceUsd);
3461 using namespace jtx;
3463 auto const gw =
Account(
"gateway");
3464 auto const alice =
Account(
"alice");
3465 auto const bob =
Account(
"bob");
3467 Env env{*
this, features};
3469 env.
fund(
XRP(1'000'000), gw, bob);
3473 auto const fee = env.
current()->fees().base;
3480 MPT const usd =
MPTTester({.env = env, .issuer = gw, .holders = {alice}});
3482 auto const usdOffer = usd(1'000);
3483 auto const xrpOffer =
XRP(1'000);
3485 env(
pay(gw, alice, usdOffer));
3492 auto const aliceXRP = env.
balance(alice);
3493 auto const bobsXRP = env.
balance(bob);
3495 env(
offer(alice, xrpOffer, usdOffer));
3497 env(
offer(bob, usdOffer, xrpOffer));
3503 Balance(alice, aliceXRP + xrpOffer - fee),
3504 Balance(bob, bobsXRP - xrpOffer - fee),
3508 BEAST_EXPECT(env.
balance(bob, usd) == usdOffer);
3511 env(
offer(alice, usd(999),
XRP(999)));
3512 env(
offer(bob, xrpOffer, usdOffer));
3518 BEAST_EXPECT(env.
balance(bob, usd) == usd(1));
3521 BEAST_EXPECT(bobsOffers.size() == 1);
3522 auto const& bobsOffer = *bobsOffers.front();
3524 BEAST_EXPECT(bobsOffer[sfLedgerEntryType] == ltOFFER);
3525 BEAST_EXPECT(bobsOffer[sfTakerGets] == usd(1));
3526 BEAST_EXPECT(bobsOffer[sfTakerPays] ==
XRP(1));
3535 using namespace jtx;
3536 auto const gw =
Account(
"gateway");
3537 auto const alice =
Account(
"alice");
3538 auto const bob =
Account(
"bob");
3540 auto const test = [&](
auto&& issue1,
auto&& issue2) {
3541 Env env{*
this, features};
3547 auto const fee = env.
current()->fees().base;
3555 auto const usd = issue1({.env = env, .token =
"USD", .issuer = gw, .holders = {alice}});
3556 auto const eur = issue2({.env = env, .token =
"EUR", .issuer = gw, .holders = {bob}});
3558 auto const usdOffer = usd(1'000);
3559 auto const eurOffer = eur(1'000);
3561 env(
pay(gw, alice, usdOffer));
3562 env(
pay(gw, bob, eurOffer));
3570 env(
offer(alice, eurOffer, usdOffer));
3571 env(
offer(bob, usdOffer, eurOffer));
3579 BEAST_EXPECT(env.
balance(alice, eur) == eurOffer);
3580 BEAST_EXPECT(env.
balance(bob, usd) == usdOffer);
3585 env(
offer(bob, eurOffer, usdOffer));
3588 env(
offer(alice, usd(999), eurOffer));
3601 if (BEAST_EXPECT(bobsOffers.size() == 1))
3603 auto const& bobsOffer = *bobsOffers.front();
3605 BEAST_EXPECT(bobsOffer[sfTakerGets] == usd(1));
3606 BEAST_EXPECT(bobsOffer[sfTakerPays] == eur(1));
3611 env(
offer(alice, usd(1), eur(1)));
3626 auto meur =
MPTTester(env, gw, eur, {bob});
3628 meur.
authorize({.account = alice, .flags = tfMPTUnauthorize});
3633 auto musd =
MPTTester(env, gw, usd, {alice});
3635 musd.
authorize({.account = bob, .flags = tfMPTUnauthorize});
3640 env(
offer(alice, eur(999), usdOffer));
3643 env(
offer(bob, usdOffer, eurOffer));
3662 using namespace jtx;
3663 auto const gw =
Account(
"gateway");
3664 auto const alice =
Account(
"alice");
3665 auto const bob =
Account(
"bob");
3666 auto const carol =
Account(
"carol");
3668 auto const test = [&](
auto&& issue1,
auto&& issue2) {
3669 Env env{*
this, features};
3671 env.
fund(
XRP(1'000'000), gw, alice, bob, carol);
3674 auto const usd = issue1({.env = env, .token =
"USD", .issuer = gw, .holders = {alice}});
3675 auto const eur = issue2({.env = env, .token =
"EUR", .issuer = gw, .holders = {carol}});
3677 auto const usdOffer = usd(1'000);
3678 auto const eurOffer = eur(1'000);
3680 env(
pay(gw, alice, usdOffer));
3681 env(
pay(gw, carol, eurOffer));
3690 env(
offer(alice,
XRP(1'000), usdOffer));
3691 env(
offer(bob, eurOffer,
XRP(1'000)));
3692 auto const bobXrpBalance = env.
balance(bob);
3697 env(
offer(carol, usd(400), eur(400)));
3706 BEAST_EXPECT(env.
balance(bob, eur) == eur(400));
3707 BEAST_EXPECT(env.
balance(carol, usd) == usd(400));
3710 BEAST_EXPECT(aliceOffers.size() == 1);
3711 auto const& aliceOffer = *aliceOffers.front();
3713 BEAST_EXPECT(aliceOffer[sfLedgerEntryType] == ltOFFER);
3714 BEAST_EXPECT(aliceOffer[sfTakerGets] == usd(600));
3715 BEAST_EXPECT(aliceOffer[sfTakerPays] ==
XRP(600));
3719 BEAST_EXPECT(bobsOffers.size() == 1);
3720 auto const& bobsOffer = *bobsOffers.front();
3722 BEAST_EXPECT(bobsOffer[sfLedgerEntryType] == ltOFFER);
3723 BEAST_EXPECT(bobsOffer[sfTakerGets] ==
XRP(600));
3724 BEAST_EXPECT(bobsOffer[sfTakerPays] == eur(600));
3729 env(
offer(carol, usd(600), eur(600)));
3739 BEAST_EXPECT(env.
balance(bob, eur) == eur(1'000));
3740 BEAST_EXPECT(env.
balance(carol, usd) == usd(1'000));
3744 if (!aliceOffers.empty())
3746 BEAST_EXPECT(aliceOffers.size() == 1);
3747 auto const& aliceOffer = *aliceOffers.front();
3749 BEAST_EXPECT(aliceOffer[sfLedgerEntryType] == ltOFFER);
3750 BEAST_EXPECT(aliceOffer[sfTakerGets] == usd(0));
3751 BEAST_EXPECT(aliceOffer[sfTakerPays] ==
XRP(0));
3765 using namespace jtx;
3767 auto const gw =
Account(
"gateway");
3769 Env env{*
this, features};
3771 env.
fund(
XRP(10'000'000), gw);
3773 auto musd =
MPTTester({.env = env, .issuer = gw});
3774 MPT const usd = musd;
3777 auto const f = env.
current()->fees().base;
3813 : account(std::move(account))
3814 , fundXrp(std::move(fundXrp))
3815 , fundUSD(std::move(fundUsd))
3816 , gwGets(std::move(gwGets))
3817 , gwPays(std::move(gwPays))
3818 , acctGets(std::move(acctGets))
3819 , acctPays(std::move(acctPays))
3821 , spentXrp(std::move(spentXrp))
3822 , finalUsd(std::move(finalUsd))
3825 , takerGets(std::move(takerGets))
3826 , takerPays(std::move(takerPays))
3864 TestData
const tests[]{
3867 {
"ann",
XRP(10) +
reserve(env, 0) + 1 * f, usd( 0),
XRP(10), usd( 5), usd(10),
XRP(10),
tecINSUF_RESERVE_OFFER,
XRP( 0) + (1 * f), usd( 0), 0, 0},
3868 {
"bev",
XRP(10) +
reserve(env, 1) + 1 * f, usd( 0),
XRP(10), usd( 5), usd(10),
XRP(10),
tesSUCCESS,
XRP( 0) + (1 * f), usd( 0), 1, 1,
XRP(10), usd(10)},
3869 {
"cam",
XRP(10) +
reserve(env, 0) + 1 * f, usd( 0),
XRP(10), usd(10), usd(10),
XRP(10),
tesSUCCESS,
XRP( 10) + (1 * f), usd(10), 0, 1},
3870 {
"deb",
XRP(10) +
reserve(env, 0) + 1 * f, usd( 0),
XRP(10), usd(20), usd(10),
XRP(10),
tesSUCCESS,
XRP( 10) + (1 * f), usd(20), 0, 1},
3871 {
"eve",
XRP(10) +
reserve(env, 0) + 1 * f, usd( 0),
XRP(10), usd(20), usd( 5),
XRP( 5),
tesSUCCESS,
XRP( 5) + (1 * f), usd(10), 0, 1},
3872 {
"flo",
XRP(10) +
reserve(env, 0) + 1 * f, usd( 0),
XRP(10), usd(20), usd(20),
XRP(20),
tesSUCCESS,
XRP( 10) + (1 * f), usd(20), 0, 1},
3873 {
"gay",
XRP(20) +
reserve(env, 1) + 1 * f, usd( 0),
XRP(10), usd(20), usd(20),
XRP(20),
tesSUCCESS,
XRP( 10) + (1 * f), usd(20), 0, 1},
3874 {
"hye",
XRP(20) +
reserve(env, 2) + 1 * f, usd( 0),
XRP(10), usd(20), usd(20),
XRP(20),
tesSUCCESS,
XRP( 10) + (1 * f), usd(20), 1, 2,
XRP(10), usd(10)},
3876 {
"meg",
reserve(env, 1) + 2 * f, usd(10), usd(10),
XRP( 5),
XRP(10), usd(10),
tecINSUF_RESERVE_OFFER,
XRP( 0) + (2 * f), usd(10), 0, 1},
3877 {
"nia",
reserve(env, 2) + 2 * f, usd(10), usd(10),
XRP( 5),
XRP(10), usd(10),
tesSUCCESS,
XRP( 0) + (2 * f), usd(10), 1, 2, usd(10),
XRP(10)},
3878 {
"ova",
reserve(env, 1) + 2 * f, usd(10), usd(10),
XRP(10),
XRP(10), usd(10),
tesSUCCESS,
XRP(-10) + (2 * f), usd( 0), 0, 1},
3879 {
"pam",
reserve(env, 1) + 2 * f, usd(10), usd(10),
XRP(20),
XRP(10), usd(10),
tesSUCCESS,
XRP(-20) + (2 * f), usd( 0), 0, 1},
3880 {
"qui",
reserve(env, 1) + 2 * f, usd(10), usd(20),
XRP(40),
XRP(10), usd(10),
tesSUCCESS,
XRP(-20) + (2 * f), usd( 0), 0, 1},
3881 {
"rae",
reserve(env, 2) + 2 * f, usd(10), usd( 5),
XRP( 5),
XRP(10), usd(10),
tesSUCCESS,
XRP( -5) + (2 * f), usd( 5), 1, 2, usd( 5),
XRP( 5)},
3882 {
"sue",
reserve(env, 2) + 2 * f, usd(10), usd( 5),
XRP(10),
XRP(10), usd(10),
tesSUCCESS,
XRP(-10) + (2 * f), usd( 5), 1, 2, usd( 5),
XRP( 5)},
3886 auto const zeroUsd = usd(0);
3887 for (
auto const& t :
tests)
3892 auto const acct =
Account(t.account);
3894 env.
fund(t.fundXrp, acct);
3900 if (t.fundUSD != zeroUsd)
3902 musd.authorize({.account = acct});
3904 env(
pay(gw, acct, t.fundUSD));
3908 env(
offer(gw, t.gwGets, t.gwPays));
3913 env(
offer(acct, t.acctGets, t.acctPays, tfSell),
Ter(t.tec));
3918 BEAST_EXPECT(env.
balance(acct, usd) == t.finalUsd);
3919 BEAST_EXPECT(env.
balance(acct,
xrpIssue()) == t.fundXrp - t.spentXrp);
3926 if (!acctOffers.empty())
3928 BEAST_EXPECT(acctOffers.size() == 1);
3929 auto const& acctOffer = *acctOffers.front();
3931 BEAST_EXPECT(acctOffer[sfLedgerEntryType] == ltOFFER);
3932 BEAST_EXPECT(acctOffer[sfTakerGets] == t.takerGets);
3933 BEAST_EXPECT(acctOffer[sfTakerPays] == t.takerPays);
3950 testcase(
"Combine tfSell with tfFillOrKill");
3952 using namespace jtx;
3954 auto const gw =
Account(
"gateway");
3955 auto const alice =
Account(
"alice");
3956 auto const bob =
Account(
"bob");
3958 Env env{*
this, features};
3960 env.
fund(
XRP(10'000'000), gw, alice, bob);
3962 MPT const usd =
MPTTester({.env = env, .issuer = gw, .holders = {bob}});
3965 env(
pay(gw, bob, usd(100)));
3967 env(
offer(bob,
XRP(2'000), usd(20)));
3980 env(
offer(alice, usd(20),
XRP(2'000), tfSell | tfFillOrKill));
3989 env(
offer(bob,
XRP(2'000), usd(20)));
3991 env(
offer(alice, usd(10),
XRP(1'500), tfSell | tfFillOrKill));
4015 env(
offer(alice, usd(1),
XRP(500), tfSell | tfFillOrKill));
4028 using namespace jtx;
4029 auto const gw1 =
Account(
"gateway1");
4032 auto const issuer =
Account(
"issuer");
4033 auto const sender =
Account(
"sender");
4034 auto const receiver =
Account(
"receiver");
4035 auto const seller =
Account(
"seller");
4036 auto const buyer =
Account(
"buyer");
4038 Env env{*
this, features};
4039 env.
fund(
XRP(10'000), issuer, sender, receiver, seller, buyer);
4045 .holders = {sender, receiver, seller, buyer},
4050 mpt.
pay(issuer, sender, 2'000);
4051 mpt.
pay(issuer, seller, 2'000);
4060 BEAST_EXPECT(mpt.
getBalance(sender) == 1'000);
4061 BEAST_EXPECT(mpt.
getBalance(receiver) == 999);
4062 BEAST_EXPECT(mpt.
getBalance(issuer) == 3'999);
4071 BEAST_EXPECT(mpt.
getBalance(seller) == 1'000);
4073 BEAST_EXPECT(mpt.
getBalance(issuer) == 3'998);
4076 auto const test = [&](
auto&& issue1,
auto&& issue2) {
4077 Env env{*
this, features};
4080 auto const fee = env.
current()->fees().base;
4086 issue1({.env = env, .token =
"USD", .issuer = gw1, .transferFee = 25'000});
4089 auto const ann =
Account(
"ann");
4090 auto const bob =
Account(
"bob");
4097 musd.authorize({.account = ann});
4098 musd.authorize({.account = bob});
4102 env(
trust(ann, usd(20'000)));
4103 env(
trust(bob, usd(20'000)));
4107 env(
pay(gw1, bob, usd(12'500)));
4116 env(
offer(bob,
XRP(1), usd(10'000)));
4119 env(
offer(ann, usd(10'000),
XRP(1)));
4134 auto const che =
Account(
"che");
4135 auto const deb =
Account(
"deb");
4142 musd.authorize({.account = che});
4143 musd.authorize({.account = deb});
4147 env(
trust(che, usd(20'000)));
4148 env(
trust(deb, usd(20'000)));
4152 env(
pay(gw1, deb, usd(12'500)));
4155 env(
offer(che, usd(10'000),
XRP(1)));
4158 env(
offer(deb,
XRP(1), usd(10'000)));
4170 auto const eve =
Account(
"eve");
4171 auto const fyn =
Account(
"fyn");
4173 env.
fund(
XRP(20'000) + (fee * 2), eve, fyn);
4179 musd.authorize({.account = eve});
4180 musd.authorize({.account = fyn});
4184 env(
trust(eve, usd(20'000)));
4185 env(
trust(fyn, usd(20'000)));
4189 env(
pay(gw1, eve, usd(10'000)));
4190 env(
pay(gw1, fyn, usd(10'000)));
4196 env(
offer(eve, usd(1'000),
XRP(4'000)));
4200 env(
offer(fyn,
XRP(2'000), usd(500)));
4206 BEAST_EXPECT(evesOffers.size() == 1);
4207 if (!evesOffers.empty())
4209 auto const& evesOffer = *evesOffers.front();
4210 BEAST_EXPECT(evesOffer[sfLedgerEntryType] == ltOFFER);
4211 BEAST_EXPECT(evesOffer[sfTakerGets] ==
XRP(2'000));
4212 BEAST_EXPECT(evesOffer[sfTakerPays] == usd(500));
4221 auto const gw2 =
Account(
"gateway2");
4227 issue2({.env = env, .token =
"EUR", .issuer = gw2, .transferFee = 50'000});
4233 auto const gay =
Account(
"gay");
4234 auto const hal =
Account(
"hal");
4241 musd.authorize({.account = gay});
4242 musd.authorize({.account = hal});
4246 env(
trust(gay, usd(20'000)));
4247 env(
trust(hal, usd(20'000)));
4253 meur.authorize({.account = gay});
4254 meur.authorize({.account = hal});
4258 env(
trust(gay, eur(20'000)));
4259 env(
trust(hal, eur(20'000)));
4263 env(
pay(gw1, gay, usd(12'500)));
4264 env(
pay(gw2, hal, eur(150)));
4267 env(
offer(gay, eur(100), usd(10'000)));
4270 env(
offer(hal, usd(10'000), eur(100)));
4286 auto const ova =
Account(
"ova");
4287 auto const pat =
Account(
"pat");
4288 auto const qae =
Account(
"qae");
4298 musd.authorize({.account = ova});
4299 musd.authorize({.account = pat});
4300 musd.authorize({.account = qae});
4304 env(
trust(ova, usd(20'000)));
4305 env(
trust(pat, usd(20'000)));
4306 env(
trust(qae, usd(20'000)));
4312 meur.authorize({.account = ova});
4313 meur.authorize({.account = pat});
4314 meur.authorize({.account = qae});
4318 env(
trust(ova, eur(20'000)));
4319 env(
trust(pat, eur(20'000)));
4320 env(
trust(qae, eur(20'000)));
4324 env(
pay(gw1, ova, usd(12'500)));
4325 env(
pay(gw2, qae, eur(150)));
4328 env(
offer(ova,
XRP(2), usd(10'000)));
4332 env(
offer(qae, usd(10'000), eur(100)));
4341 if (!ovasOffers.empty())
4343 BEAST_EXPECT(ovasOffers.size() == 1);
4344 auto const& ovasOffer = *ovasOffers.front();
4346 BEAST_EXPECT(ovasOffer[sfLedgerEntryType] == ltOFFER);
4347 BEAST_EXPECT(ovasOffer[sfTakerGets] == usd(0));
4348 BEAST_EXPECT(ovasOffer[sfTakerPays] ==
XRP(0));
4369 auto const gw =
Account(
"gw_tr1");
4370 auto const alice =
Account(
"alice_tr1");
4371 auto const bob =
Account(
"bob_tr1");
4373 Env env{*
this, features};
4374 env.
fund(
XRP(10'000), gw, alice, bob);
4378 {.env = env, .issuer = gw, .holders = {alice, bob}, .transferFee = 25'000});
4381 env(
pay(gw, alice, usd(1'250)));
4383 env(
offer(bob, usd(1'000),
XRP(1'000)));
4394 BEAST_EXPECT(env.
balance(alice, usd) == usd(0));
4396 BEAST_EXPECT(env.
balance(bob, usd) == usd(1'000));
4406 auto const gw =
Account(
"gw_tr2");
4407 auto const gw2 =
Account(
"gw2_tr2");
4408 auto const alice =
Account(
"alice_tr2");
4409 auto const bob =
Account(
"bob_tr2");
4410 auto const carol =
Account(
"carol_tr2");
4412 Env env{*
this, features};
4413 env.
fund(
XRP(10'000), gw, gw2, alice, bob, carol);
4417 {.env = env, .issuer = gw, .holders = {bob, carol}, .transferFee = 25'000});
4418 auto const gusd = gw2[
"USD"];
4420 env(
trust(alice, gusd(10'000)));
4421 env(
trust(bob, gusd(10'000)));
4424 env(
pay(gw2, alice, gusd(1'000)));
4425 env(
pay(gw, bob, musd(1'000)));
4429 env(
offer(bob, gusd(1'000), musd(1'000)));
4431 env(
offer(carol, musd(800),
XRP(800)));
4443 BEAST_EXPECT(env.
balance(alice, gusd) == gusd(0));
4445 BEAST_EXPECT(env.
balance(bob, musd) == musd(0));
4447 BEAST_EXPECT(env.
balance(carol, musd) == musd(800));
4454 testcase(
"Transfer Rate Overflow Offer");
4456 using namespace jtx;
4458 auto const issuer =
Account(
"issuer");
4459 auto const taker =
Account(
"taker");
4462 Env env{*
this, features};
4463 env.
fund(
XRP(10'000), issuer, taker);
4466 auto constexpr takerFunds = 2'000'000'000'000'000'000LL;
4471 .transferFee = 50'000,
4479 auto constexpr offerAmount = 1'230'000'000'000'000'000LL;
4480 auto const takerSeq = env.
seq(taker);
4494 Env env{*
this, features};
4495 env.
fund(
XRP(10'000), issuer, taker);
4499 {.env = env, .issuer = issuer, .holders = {taker}, .transferFee = 10'000}};
4507 std::int64_t const askAmount = 8'500'000'000'000'000'000LL;
4508 auto const askSeq = env.
seq(issuer);
4513 BEAST_EXPECT(env.
le(askKeylet) !=
nullptr);
4515 auto const takerSeq = env.
seq(taker);
4522 auto const sle = env.
le(askKeylet);
4523 if (BEAST_EXPECT(sle))
4524 BEAST_EXPECT((*sle)[sfTakerGets] ==
token(askAmount - 100));
4528 auto const gwA =
Account(
"gatewayA");
4529 auto const gwB =
Account(
"gatewayB");
4530 auto const alice =
Account(
"alice");
4531 auto const mallory =
Account(
"mallory");
4533 Env env{*
this, features};
4534 env.
fund(
XRP(10'000), gwA, gwB, alice, mallory);
4538 {.env = env, .issuer = gwA, .holders = {alice, mallory}, .transferFee = 50'000}};
4540 MPTTester const tokenB{{.env = env, .issuer = gwB, .holders = {alice, mallory}}};
4542 env(
pay(gwA, alice, tokenA(1'000)));
4550 std::int64_t const poisonPays = 6'148'914'691'236'517'205LL;
4551 std::int64_t const poisonGets = 34'000'000'000'000'000LL;
4552 env(
pay(gwB, mallory, tokenB(poisonGets)));
4554 auto const poisonSeq = env.
seq(mallory);
4559 BEAST_EXPECT(env.
le(poisonKeylet) ==
nullptr);
4561 auto const aliceSeq = env.
seq(alice);
4562 env(
offer(alice, tokenB(1), tokenA(100)));
4565 BEAST_EXPECT(env.
le(poisonKeylet) ==
nullptr);
4580 Env env{*
this, features};
4581 env.
fund(
XRP(10'000), issuer, taker);
4585 {.env = env, .issuer = issuer, .holders = {taker}, .maxAmt =
kMaxMpTokenAmount});
4590 auto const funded = 1'844'674'407'370'955'162LL;
4591 auto const offerOut = funded + 1;
4593 auto const askSeq = env.
seq(issuer);
4598 BEAST_EXPECT(env.
le(askKeylet) !=
nullptr);
4600 auto const issuerXRPBefore = env.
balance(issuer,
XRP);
4601 auto const takerXRPBefore = env.
balance(taker,
XRP);
4602 auto const takerSeq = env.
seq(taker);
4603 auto const fee = env.
current()->fees().base;
4610 BEAST_EXPECT(env.
le(askKeylet) ==
nullptr);
4613 BEAST_EXPECT(env.
balance(issuer,
XRP) == issuerXRPBefore +
XRP(1));
4614 BEAST_EXPECT(env.
balance(taker,
XRP) == takerXRPBefore -
XRP(1) - fee);
4616 BEAST_EXPECT(env.
seq(taker) == takerSeq + 1);
4620 auto const maker =
Account(
"maker");
4622 Env env{*
this, features};
4623 env.
fund(
XRP(10'000), issuer, maker, taker);
4629 .holders = {maker, taker},
4638 auto const funded = 1'844'674'407'370'955'162LL;
4639 auto const offerOut = funded + 1;
4640 env(
pay(issuer, maker,
token(funded)));
4642 auto const askSeq = env.
seq(maker);
4647 BEAST_EXPECT(env.
le(askKeylet) !=
nullptr);
4649 auto const takerSeq = env.
seq(taker);
4650 auto const takerXRPBefore = env.
balance(taker,
XRP);
4651 auto const fee = env.
current()->fees().base;
4660 auto const ask = env.
le(askKeylet);
4661 if (BEAST_EXPECT(ask))
4663 BEAST_EXPECT((*ask)[sfTakerPays] ==
XRP(1) -
drops(1));
4664 BEAST_EXPECT((*ask)[sfTakerGets] ==
token(offerOut - 1));
4668 BEAST_EXPECT(env.
balance(taker,
XRP) == takerXRPBefore -
drops(1) - fee);
4679 auto const gwA =
Account(
"gatewayA");
4680 auto const gwB =
Account(
"gatewayB");
4681 auto const alice =
Account(
"alice");
4682 auto const mallory =
Account(
"mallory");
4692 env.
fund(
XRP(10'000), gwA, gwB, alice, mallory);
4695 MPTTester tokenA{{.env = env, .issuer = gwA, .holders = {alice, mallory}}};
4696 MPTTester const tokenB{{.env = env, .issuer = gwB, .holders = {alice, mallory}}};
4698 std::int64_t const bidPays = 6'148'914'691'236'517'205LL;
4700 env(
pay(gwA, alice, tokenA(10'000)));
4701 env(
pay(gwB, mallory, tokenB(bidGets)));
4704 auto const bidSeq = env.
seq(mallory);
4705 env(
offer(mallory, tokenA(bidPays), tokenB(bidGets)));
4708 BEAST_EXPECT(env.
le(bidKeylet) !=
nullptr);
4710 tokenA.
set({.account = gwA, .transferFee = 50'000});
4713 auto const aliceSeq = env.
seq(alice);
4714 env(
offer(alice, tokenB(1), tokenA(1'000)));
4717 BEAST_EXPECT(env.
le(bidKeylet) ==
nullptr);
4721 BEAST_EXPECT(logs.contains(
"Removing offer with overflowing amount calculation"));
4726 std::int64_t const maxGross = 8'384'883'669'867'978'006LL;
4746 auto const gw =
Account(
"gw");
4747 auto const usd = gw[
"USD"];
4748 auto const alice =
Account(
"alice");
4749 auto const bob =
Account(
"bob");
4751 Env env{*
this, features};
4752 env.
fund(
XRP(100'000), issuer, alice, bob, gw);
4758 .holders = {alice, bob},
4759 .transferFee = 10'000,
4762 env(
pay(issuer, alice,
token(maxAmt)));
4772 auto const seq1 = env.
seq(alice);
4774 auto const seq2 = env.
seq(alice);
4776 auto const seq3 = env.
seq(alice);
4779 for (
auto const seq : {seq1, seq2, seq3})
4794 auto const alice =
Account(
"alice");
4795 auto const bob =
Account(
"bob");
4796 auto const carol =
Account(
"carol");
4798 Env env{*
this, features};
4799 env.
fund(
XRP(100'000), issuer, alice, bob, carol);
4805 .holders = {alice, bob, carol},
4806 .transferFee = 10'000,
4810 env(
pay(issuer, alice,
token(maxAmt)));
4814 auto const askSeq = env.
seq(alice);
4818 BEAST_EXPECT(env.
le(askKeylet) !=
nullptr);
4824 Txflags(tfNoRippleDirect | tfPartialPayment));
4827 BEAST_EXPECT(env.
balance(alice,
token) ==
token(maxAmt - small - (small / 10)));
4829 auto const sle = env.
le(askKeylet);
4830 if (BEAST_EXPECT(sle))
4831 BEAST_EXPECT((*sle)[sfTakerGets] ==
token(maxAmt - small - (small / 10)));
4834 auto const bidSeq = env.
seq(bob);
4838 BEAST_EXPECT(env.
balance(alice,
token) ==
token(maxAmt - (2 * (small + (small / 10)))));
4841 auto const sle = env.
le(askKeylet);
4842 if (BEAST_EXPECT(sle))
4844 BEAST_EXPECT((*sle)[sfTakerGets] ==
token(maxAmt - (2 * small) - (small / 10)));
4854 auto const alice =
Account(
"alice");
4855 auto const bob =
Account(
"bob");
4857 Env env{*
this, features};
4858 env.
fund(
XRP(100'000), issuer, alice, bob);
4864 .holders = {alice, bob},
4865 .transferFee = 10'000,
4869 env(
pay(issuer, alice,
token(aliceFunds)));
4873 std::int64_t const askAmount = 9'000'000'000'000'000'000LL;
4874 auto const askSeq = env.
seq(alice);
4878 BEAST_EXPECT(env.
le(askKeylet) !=
nullptr);
4881 auto const bidSeq = env.
seq(bob);
4885 BEAST_EXPECT(env.
balance(alice,
token) ==
token(aliceFunds - small - (small / 10)));
4887 auto const sle = env.
le(askKeylet);
4888 if (BEAST_EXPECT(sle))
4889 BEAST_EXPECT((*sle)[sfTakerGets] ==
token(askAmount - small));
4896 auto const alice =
Account(
"alice");
4897 auto const bob =
Account(
"bob");
4899 Env env{*
this, features};
4900 env.
fund(
XRP(100'000), issuer, alice, bob);
4906 .holders = {alice, bob},
4907 .transferFee = 10'000,
4910 env(
pay(issuer, alice,
token(maxAmt)));
4913 auto const okSeq = env.
seq(alice);
4917 BEAST_EXPECT(env.
le(okKeylet) !=
nullptr);
4923 BEAST_EXPECT(env.
balance(alice,
token) ==
token(maxAmt - small - (small / 10)));
4924 auto const sle = env.
le(okKeylet);
4925 if (BEAST_EXPECT(sle))
4926 BEAST_EXPECT((*sle)[sfTakerGets] ==
token(maxGross - small));
4933 auto const gwA =
Account(
"gatewayA");
4934 auto const gwB =
Account(
"gatewayB");
4935 auto const alice =
Account(
"alice");
4936 auto const bob =
Account(
"bob");
4938 Env env{*
this, features};
4939 env.
fund(
XRP(10'000), gwA, gwB, alice, bob);
4945 .holders = {alice, bob},
4946 .transferFee = 10'000,
4949 MPTTester const tokenB{{.env = env, .issuer = gwB, .holders = {alice, bob}}};
4953 std::int64_t const alicePays = 110'000'000'000'000'000LL;
4954 env(
pay(gwA, alice, tokenA(maxAmt)));
4955 env(
pay(gwB, bob, tokenB(bobPays)));
4958 env(
offer(bob, tokenA(small), tokenB(bobPays)));
4961 auto const aliceSeq = env.
seq(alice);
4962 env(
offer(alice, tokenB(alicePays), tokenA(maxAmt)));
4964 BEAST_EXPECT(env.
balance(bob, tokenA) == tokenA(small));
4965 BEAST_EXPECT(env.
balance(alice, tokenA) == tokenA(maxAmt - small - (small / 10)));
4966 BEAST_EXPECT(env.
balance(alice, tokenB) == tokenB(bobPays));
4968 if (BEAST_EXPECT(sle))
4970 BEAST_EXPECT((*sle)[sfTakerPays] == tokenB(alicePays - bobPays));
4973 auto const gets = (*sle)[sfTakerGets].mpt().value();
4974 BEAST_EXPECT(gets > maxAmt - (2 * small) && gets <= maxAmt - small);
4981 Env env{*
this, features};
4982 env.
fund(
XRP(10'000), issuer, taker);
4989 .transferFee = 10'000,
4993 auto const issuerSeq = env.
seq(issuer);
5004 Env env{*
this, features};
5005 env.
fund(
XRP(10'000), issuer, taker);
5009 {.env = env, .issuer = issuer, .holders = {taker}, .maxAmt = 1'000}};
5011 auto const issuerSeq = env.
seq(issuer);
5015 BEAST_EXPECT(env.
le(issuerKeylet) !=
nullptr);
5017 auto const takerXRPBefore = env.
balance(taker,
XRP);
5018 auto const fee = env.
current()->fees().base;
5019 auto const takerSeq = env.
seq(taker);
5026 BEAST_EXPECT(env.
balance(taker,
XRP) == takerXRPBefore - fee -
XRP(1));
5027 BEAST_EXPECT(env.
le(issuerKeylet) ==
nullptr);
5029 if (BEAST_EXPECT(sle))
5030 BEAST_EXPECT((*sle)[sfTakerPays] ==
token(1'000));
5035 Env env{*
this, features};
5036 env.
fund(
XRP(10'000), issuer, taker);
5047 auto const takerSeq = env.
seq(taker);
5058 auto const gwA =
Account(
"gatewayA");
5059 auto const gwB =
Account(
"gatewayB");
5060 auto const alice =
Account(
"alice");
5061 auto const bob =
Account(
"bob");
5063 Env env{*
this, features};
5064 env.
fund(
XRP(10'000), gwA, gwB, alice, bob);
5070 .holders = {alice, bob},
5071 .transferFee = 10'000,
5074 MPTTester const tokenB{{.env = env, .issuer = gwB, .holders = {alice, bob}}};
5076 std::int64_t const bobGets = 100'000'000'000'000'000LL;
5077 env(
pay(gwB, bob, tokenB(bobGets)));
5082 auto const bobSeq = env.
seq(bob);
5083 env(
offer(bob, tokenA(maxGross), tokenB(bobGets)));
5092 env(
pay(gwA, alice, tokenA(1'100)));
5094 env(
offer(alice, tokenB(1), tokenA(1'000)));
5096 auto const crossSeq = env.
seq(bob);
5097 env(
offer(bob, tokenA(maxAmt), tokenB(bobGets)));
5099 BEAST_EXPECT(env.
balance(bob, tokenA) == tokenA(1'000));
5100 BEAST_EXPECT(env.
balance(bob, tokenB) == tokenB(bobGets - 1));
5101 BEAST_EXPECT(env.
balance(alice, tokenA) == tokenA(0));
5102 BEAST_EXPECT(env.
balance(alice, tokenB) == tokenB(1));
5110 auto const gwA =
Account(
"gatewayA");
5111 auto const gwB =
Account(
"gatewayB");
5112 auto const alice =
Account(
"alice");
5113 auto const bob =
Account(
"bob");
5115 Env env{*
this, features};
5116 env.
fund(
XRP(10'000), gwA, gwB, alice, bob);
5122 .holders = {alice, bob},
5123 .transferFee = 10'000,
5126 MPTTester const tokenB{{.env = env, .issuer = gwB, .holders = {alice, bob}}};
5130 std::int64_t const bobGets = 110'000'000'000'000'000LL;
5131 std::int64_t const aliceGets = 1'500'000'000'000'000'000LL;
5132 std::int64_t const alicePays = 15'000'000'000'000'000LL;
5133 env(
pay(gwA, alice, tokenA(maxAmt)));
5134 env(
pay(gwB, bob, tokenB(bobGets)));
5137 env(
offer(alice, tokenB(alicePays), tokenA(aliceGets)));
5140 auto const bobSeq = env.
seq(bob);
5141 env(
offer(bob, tokenA(maxAmt), tokenB(bobGets)));
5143 BEAST_EXPECT(env.
balance(bob, tokenA) == tokenA(aliceGets));
5145 env.
balance(alice, tokenA) == tokenA(maxAmt - aliceGets - (aliceGets / 10)));
5146 BEAST_EXPECT(env.
balance(alice, tokenB) == tokenB(alicePays));
5151 if (BEAST_EXPECT(sle))
5153 BEAST_EXPECT((*sle)[sfTakerPays] == tokenA(maxAmt - aliceGets));
5154 auto const gets = (*sle)[sfTakerGets].mpt().value();
5155 BEAST_EXPECT(gets > 92'000'000'000'000'000LL && gets < 92'200'000'000'000'000LL);
5177 using namespace jtx;
5179 auto const gw =
Account(
"gateway");
5181 Env env{*
this, features};
5184 auto const fee = env.
current()->fees().base;
5185 auto const startBalance =
XRP(1'000'000);
5187 env.
fund(startBalance + (fee * 5), gw);
5204 BEAST_EXPECT(gwOffers.size() == 3);
5205 for (
auto const& offerPtr : gwOffers)
5207 auto const&
offer = *offerPtr;
5208 BEAST_EXPECT(
offer[sfLedgerEntryType] == ltOFFER);
5209 BEAST_EXPECT(
offer[sfTakerGets] ==
XRP(600));
5210 BEAST_EXPECT(
offer[sfTakerPays] == usd(60));
5215 env(
offer(gw,
XRP(1'000), usd(100)));
5222 BEAST_EXPECT(gwOffers.size() == 1);
5223 for (
auto const& offerPtr : gwOffers)
5225 auto const&
offer = *offerPtr;
5226 BEAST_EXPECT(
offer[sfLedgerEntryType] == ltOFFER);
5227 BEAST_EXPECT(
offer[sfTakerGets] == usd(100));
5228 BEAST_EXPECT(
offer[sfTakerPays] ==
XRP(1'000));
5235 using namespace jtx;
5237 auto const gw1 =
Account(
"gateway1");
5238 auto const gw2 =
Account(
"gateway2");
5239 auto const alice =
Account(
"alice");
5241 auto const test = [&](
auto&& issue1,
auto&& issue2) {
5242 Env env{*
this, features};
5244 env.
fund(
XRP(1'000'000), gw1, gw2);
5247 auto const usd = issue1({.env = env, .token =
"USD", .issuer = gw1});
5249 auto const eur = issue2({.env = env, .token =
"EUR", .issuer = gw2});
5253 auto const f = env.
current()->fees().base;
5267 TestData
const tests[]{
5278 for (
auto const& t :
tests)
5280 auto const acct =
Account{t.acct};
5281 env.
fund(t.fundXRP, acct);
5287 musd.authorize({.account = acct});
5291 env(
trust(acct, usd(1'000)));
5297 meur.authorize({.account = acct});
5301 env(
trust(acct, eur(1'000)));
5305 if (t.fundUSD > usd(0))
5306 env(
pay(gw1, acct, t.fundUSD));
5307 if (t.fundEUR > eur(0))
5308 env(
pay(gw2, acct, t.fundEUR));
5311 env(
offer(acct, usd(500), eur(600)),
Ter(t.firstOfferTec));
5315 int offerCount = t.firstOfferTec ==
tesSUCCESS ? 1 : 0;
5321 BEAST_EXPECT(acctOffers.size() == offerCount);
5322 for (
auto const& offerPtr : acctOffers)
5324 auto const&
offer = *offerPtr;
5325 BEAST_EXPECT(
offer[sfLedgerEntryType] == ltOFFER);
5326 BEAST_EXPECT(
offer[sfTakerGets] == eur(600));
5327 BEAST_EXPECT(
offer[sfTakerPays] == usd(500));
5330 env(
offer(acct, eur(600), usd(500)),
Ter(t.secondOfferTec));
5334 offerCount = t.secondOfferTec ==
tesSUCCESS ? 1 : offerCount;
5340 BEAST_EXPECT(acctOffers.size() == offerCount);
5341 for (
auto const& offerPtr : acctOffers)
5343 auto const&
offer = *offerPtr;
5344 BEAST_EXPECT(
offer[sfLedgerEntryType] == ltOFFER);
5345 if (
offer[sfSequence] == firstOfferSeq)
5347 BEAST_EXPECT(
offer[sfTakerGets] == eur(600));
5348 BEAST_EXPECT(
offer[sfTakerPays] == usd(500));
5352 BEAST_EXPECT(
offer[sfTakerGets] == usd(500));
5353 BEAST_EXPECT(
offer[sfTakerPays] == eur(600));
5382 using namespace jtx;
5384 Env env{*
this, features};
5386 auto const alice =
Account(
"alice");
5387 auto const bob =
Account(
"bob");
5388 auto const f = env.
current()->fees().base;
5390 env.
fund(
XRP(50'000) + f, alice, bob);
5393 MPT const usd =
MPTTester({.env = env, .issuer = bob});
5395 env(
offer(alice, usd(5'000),
XRP(50'000)));
5399 env(
offer(bob,
XRP(50'000), usd(5'000)));
5411 BEAST_EXPECT(bobOffers.size() == 1);
5412 for (
auto const& offerPtr : bobOffers)
5414 auto const&
offer = *offerPtr;
5415 BEAST_EXPECT(
offer[sfLedgerEntryType] == ltOFFER);
5416 BEAST_EXPECT(
offer[sfTakerGets] == usd(25));
5417 BEAST_EXPECT(
offer[sfTakerPays] ==
XRP(250));
5430 using namespace jtx;
5431 auto const ann =
Account(
"ann");
5432 auto const bob =
Account(
"bob");
5433 auto const cam =
Account(
"cam");
5435 auto const test = [&](
auto&& issue1,
auto&& issue2) {
5436 Env env{*
this, features};
5438 auto const fee = env.
current()->fees().base;
5439 env.
fund(
reserve(env, 4) + (fee * 5), ann, bob, cam);
5442 auto const aBux = issue1(
5443 {.env = env, .token =
"AUX", .issuer = ann, .holders = {cam}});
5444 auto const bBux = issue2(
5448 .holders = {ann, cam},});
5450 env(
pay(ann, cam, aBux(35)));
5451 env(
pay(bob, cam, bBux(35)));
5453 env(
offer(bob, aBux(30), bBux(30)));
5459 env(
offer(cam, aBux(29), bBux(30), tfPassive));
5466 env(
offer(cam, bBux(30), aBux(30)));
5483 testcase(
"Self crossing low quality offer");
5485 using namespace jtx;
5487 Env env{*
this, features};
5489 auto const ann =
Account(
"ann");
5490 auto const gw =
Account(
"gateway");
5492 auto const fee = env.
current()->fees().base;
5498 {.env = env, .issuer = gw, .holders = {ann}, .transferFee = 2'000});
5500 env(
pay(gw, ann, btc(2'856)));
5503 env(
offer(ann,
drops(365'611'702'030), btc(5'713)));
5507 env(
offer(ann, btc(687),
drops(20'000'000'000)),
5520 using namespace jtx;
5522 Env env{*
this, features};
5524 auto const gw =
Account(
"gateway");
5525 auto const alice =
Account(
"alice");
5526 auto const bob =
Account(
"bob");
5528 auto const fee = env.
current()->fees().base;
5533 MPT const cny =
MPTTester({.env = env, .issuer = gw, .holders = {bob}});
5535 env(
pay(gw, bob, cny(3'000'000)));
5538 env(
offer(bob,
drops(5'400'000'000), cny(2'160'540)));
5542 env(
offer(alice, cny(135'620'001),
drops(339'000'000'000)));
5546 BEAST_EXPECT(aliceOffers.size() == 1);
5547 for (
auto const& offerPtr : aliceOffers)
5549 auto const&
offer = *offerPtr;
5550 BEAST_EXPECT(
offer[sfLedgerEntryType] == ltOFFER);
5551 BEAST_EXPECT(
offer[sfTakerGets] ==
drops(333'599'446'582));
5552 BEAST_EXPECT(
offer[sfTakerPays] == cny(13'3459'461));
5562 testcase(
"Offer In Scaling With Xfer Rate");
5564 using namespace jtx;
5565 auto const gw =
Account(
"gateway");
5566 auto const alice =
Account(
"alice");
5567 auto const bob =
Account(
"bob");
5569 auto const test = [&](
auto&& issue1,
auto&& issue2) {
5570 Env env{*
this, features};
5572 auto const fee = env.
current()->fees().base;
5580 auto const jpy = issue1(
5586 .transferFee = 2'000,});
5587 auto const btc = issue2(
5593 .transferFee = 2'000,});
5595 env(
pay(gw, alice, jpy(3'699'034'802'280'317)));
5596 env(
pay(gw, bob, btc(115'672'255'914'031'100)));
5600 bob, jpy(1'241'913'390'770'747), btc(1'969'825'690'469'254)));
5605 alice, btc(5'507'568'706'427'876), jpy(3'472'696'773'391'072)));
5609 BEAST_EXPECT(aliceOffers.size() == 1);
5610 for (
auto const& offerPtr : aliceOffers)
5612 auto const&
offer = *offerPtr;
5613 BEAST_EXPECT(
offer[sfLedgerEntryType] == ltOFFER);
5622 BEAST_EXPECT(
offer[sfTakerGets] == jpy(2'230'659'191'281'247));
5623 BEAST_EXPECT(
offer[sfTakerPays] == btc(3'537'743'015'958'622));
5668 using namespace jtx;
5669 auto const gw =
Account(
"gw");
5671 auto const test = [&](
auto&& issue1,
auto&& issue2) {
5672 Env env{*
this, features};
5673 auto const baseFee = env.
current()->fees().base.drops();
5675 auto const startXrpBalance =
XRP(4'000'000);
5677 env.
fund(startXrpBalance, gw);
5680 auto const btc = issue1(
5684 .transferFee = 25'000,});
5687 auto const usd = issue2(
5691 .transferFee = 25'000,});
5718 TestData
const tests[]{
5720 {0, 0, 1, btc(200), {{
"ann", 0,
drops(3900000'000000 - (4 * baseFee)), btc(200), usd(3000)}, {
"abe", 0,
drops(4100000'000000 - (3 * baseFee)), btc( 0), usd(750)}}},
5721 {0, 1, 0, btc(200), {{
"bev", 0,
drops(4100000'000000 - (4 * baseFee)), btc( 75), usd(2000)}, {
"bob", 0,
drops(3900000'000000 - (3 * baseFee)), btc(100), usd( 0)}}},
5722 {0, 0, 0, btc(200), {{
"cam", 0,
drops(4000000'000000 - (5 * baseFee)), btc(200), usd(2000)} }},
5723 {0, 1, 0, btc( 50), {{
"deb", 1,
drops(4040000'000000 - (4 * baseFee)), btc( 0), usd(2000)}, {
"dan", 1,
drops(3960000'000000 - (3 * baseFee)), btc( 40), usd( 0)}}},
5727 for (
auto const& t :
tests)
5729 Account const& self = t.actors[t.self].acct;
5730 Account const& leg0 = t.actors[t.leg0].acct;
5731 Account const& leg1 = t.actors[t.leg1].acct;
5733 for (
auto const& actor : t.actors)
5735 env.
fund(
XRP(4'000'000), actor.acct);
5741 mbtc.authorize({.account = actor.acct});
5745 env(
trust(actor.acct, btc(400)));
5751 musd.authorize({.account = actor.acct});
5755 env(
trust(actor.acct, usd(8000)));
5761 env(
pay(gw, self, t.btcStart));
5762 env(
pay(gw, self, usd(2'000)));
5763 if (self.
id() != leg1.
id())
5764 env(
pay(gw, leg1, usd(2'000)));
5769 env(
offer(leg0, btc(100),
XRP(100'000), tfPassive));
5773 env(
offer(leg1,
XRP(100'000), usd(1'000), tfPassive));
5778 env(
offer(self, usd(1'000), btc(100)));
5783 for (
auto const& actor : t.actors)
5789 actorOffers.begin(),
5791 return (*offer)[sfTakerGets].signum() == 0;
5793 BEAST_EXPECT(offerCount == actor.offers);
5815 testcase(
"Self Pay Unlimited Funds");
5847 using namespace jtx;
5848 auto const gw =
Account(
"gw");
5850 auto const test = [&](
auto&& issue1,
auto&& issue2) {
5851 Env env{*
this, features};
5852 auto const baseFee = env.
current()->fees().base.drops();
5854 auto const startXrpBalance =
XRP(4'000'000);
5856 env.
fund(startXrpBalance, gw);
5859 auto const btc = issue1(
5860 {.env = env, .token =
"BTC", .issuer = gw, .
limit = 40, .transferFee = 25'000});
5862 auto const usd = issue2(
5863 {.env = env, .token =
"USD", .issuer = gw, .
limit = 8'000, .transferFee = 25'000});
5890 TestData
const flowTests[]{
5892 {0, 0, 1, btc(5), {{
"gay", 1,
drops(3950000'000000 - (4 * baseFee)), btc(5), usd (2500)}, {
"gar", 1,
drops(4050000'000000 - (3 * baseFee)), btc(0), usd(1375)}}},
5893 {0, 0, 0, btc(5), {{
"hye", 2,
drops(4000000'000000 - (5 * baseFee)), btc(5), usd (2000)} }},
5897 for (
auto const& t : flowTests)
5899 Account const& self = t.actors[t.self].acct;
5900 Account const& leg0 = t.actors[t.leg0].acct;
5901 Account const& leg1 = t.actors[t.leg1].acct;
5903 for (
auto const& actor : t.actors)
5905 env.
fund(
XRP(4'000'000), actor.acct);
5911 mbtc.authorize({.account = actor.acct});
5915 env(
trust(actor.acct, btc(40)));
5921 musd.authorize({.account = actor.acct});
5925 env(
trust(actor.acct, usd(8'000)));
5930 env(
pay(gw, self, t.btcStart));
5931 env(
pay(gw, self, usd(2'000)));
5932 if (self.
id() != leg1.
id())
5933 env(
pay(gw, leg1, usd(2'000)));
5938 env(
offer(leg0, btc(10),
XRP(100'000), tfPassive));
5942 env(
offer(leg1,
XRP(100'000), usd(1'000), tfPassive));
5947 env(
offer(self, usd(1'000), btc(10)));
5952 for (
auto const& actor : t.actors)
5958 actorOffers.begin(),
5960 return (*offer)[sfTakerGets].signum() == 0;
5962 BEAST_EXPECT(offerCount == actor.offers);
5986 using namespace jtx;
5988 Env env{*
this, features};
5990 auto const gw =
Account(
"gw");
5991 auto const alice =
Account(
"alice");
5992 auto const bob =
Account(
"bob");
5994 env.
fund(
XRP(400'000), gw, alice, bob);
6000 MPT const gwUSD = gwMUSD;
6003 gwMUSD.authorize({.account = alice});
6004 gwMUSD.authorize({.account = gw, .holder = alice});
6005 gwMUSD.authorize({.account = bob});
6006 gwMUSD.authorize({.account = gw, .holder = bob});
6008 env(
offer(alice, gwUSD(40),
XRP(4'000)));
6014 env(
pay(gw, bob, gwUSD(50)));
6020 env(
offer(bob,
XRP(4'000), gwUSD(40)));
6046 using namespace jtx;
6048 Env env{*
this, features};
6050 auto const gw =
Account(
"gw");
6051 auto const alice =
Account(
"alice");
6052 auto const bob =
Account(
"bob");
6054 env.
fund(
XRP(400'000), gw, alice, bob);
6059 MPT const gwUSD = gwMUSD;
6069 gwMUSD.authorize({.account = bob});
6070 gwMUSD.authorize({.account = gw, .holder = bob});
6072 env(
pay(gw, bob, gwUSD(50)));
6078 env(
offer(bob,
XRP(4'000), gwUSD(40)));
6086 gwMUSD.authorize({.account = alice});
6104 gwMUSD.authorize({.account = gw, .holder = alice});
6106 env(
offer(alice, gwUSD(40),
XRP(4'000)));
6112 env(
offer(bob,
XRP(4'000), gwUSD(40)));
6127 using namespace jtx;
6129 Env env{*
this, features};
6131 auto const gw =
Account(
"gw");
6132 auto const alice =
Account(
"alice");
6134 env.
fund(
XRP(400'000), gw, alice);
6139 MPT const gwUSD = gwMUSD;
6142 env(
offer(gw, gwUSD(40),
XRP(4'000)));
6155 env(
offer(gw, gwUSD(40),
XRP(4'000)));
6163 gwMUSD.authorize({.account = alice});
6164 gwMUSD.authorize({.account = gw, .holder = alice});
6166 env(
pay(gw, alice, gwUSD(50)));
6172 env(
offer(alice,
XRP(4'000), gwUSD(40)));
6185 using namespace jtx;
6189 auto const mpTokenExists =
6199 Env env{*
this, features};
6203 auto musd =
MPTTester({.env = env, .issuer = gw});
6204 MPT const usd = musd;
6206 musd.authorize({.account = becky});
6207 BEAST_EXPECT(mpTokenExists(env, becky, usd.issuanceID));
6208 env(
pay(gw, becky, usd(5)));
6211 auto mbux =
MPTTester({.env = env, .issuer = alice});
6212 MPT const bux = mbux;
6223 env(
pay(becky, gw, usd(5)));
6224 musd.authorize({.account = becky, .flags = tfMPTUnauthorize});
6226 BEAST_EXPECT(!mpTokenExists(env, becky, usd.issuanceID));
6227 BEAST_EXPECT(
isOffer(env, becky,
XRP(2), usd(2)));
6228 BEAST_EXPECT(
isOffer(env, becky, bux(3), usd(3)));
6238 int const delta = [&env, &gw, openLedgerSeq = env.
current()->seq()] ->
int {
6240 if (gwSeq + 255 > openLedgerSeq)
6241 return gwSeq - openLedgerSeq + 255;
6245 for (
int i = 0; i < delta; ++i)
6261 BEAST_EXPECT(
isOffer(env, becky,
XRP(2), usd(2)));
6262 BEAST_EXPECT(
isOffer(env, becky, bux(3), usd(3)));
6268 BEAST_EXPECT(
isOffer(env, becky,
XRP(2), usd(2)));
6269 BEAST_EXPECT(
isOffer(env, becky, bux(3), usd(3)));
6274 BEAST_EXPECT(!
isOffer(env, becky, bux(3), usd(3)));
6278 mbux.authorize({.account = carol});
6279 env(
pay(alice, carol, bux(2)));
6288 BEAST_EXPECT(
isOffer(env, alice, bux(2),
XRP(2)));
6289 BEAST_EXPECT(
isOffer(env, becky,
XRP(2), usd(2)));
6298 return (*rhs)[sfSequence] < (*lhs)[sfSequence];
6308 using namespace jtx;
6316 Env env{*
this, features};
6317 auto const gw =
Account{
"gateway"};
6318 auto const alice =
Account{
"alice"};
6319 auto const bob =
Account{
"bob"};
6321 env.
fund(
XRP(10'000), gw, alice, bob);
6324 MPT const usd =
MPTTester({.env = env, .issuer = gw, .holders = {alice, bob}});
6326 env(
pay(gw, alice, usd(200)));
6333 env(
offer(alice,
XRP(50), usd(50)));
6343 BEAST_EXPECT(offerId1 == offerId0 + 4);
6344 env(
offer(alice,
XRP(50), usd(50)));
6360 BEAST_EXPECT(offers.size() == 4);
6361 BEAST_EXPECT(offers[0]->getFieldU32(sfSequence) == offerId0);
6362 BEAST_EXPECT(offers[1]->getFieldU32(sfSequence) == offerId3);
6363 BEAST_EXPECT(offers[2]->getFieldU32(sfSequence) == offerId2);
6364 BEAST_EXPECT(offers[3]->getFieldU32(sfSequence) == offerId1);
6376 BEAST_EXPECT(offers.size() == 3);
6377 BEAST_EXPECT(offers[0]->getFieldU32(sfSequence) == offerId3);
6378 BEAST_EXPECT(offers[1]->getFieldU32(sfSequence) == offerId2);
6379 BEAST_EXPECT(offers[2]->getFieldU32(sfSequence) == offerId1);
6389 BEAST_EXPECT(offers.size() == 2);
6390 BEAST_EXPECT(offers[0]->getFieldU32(sfSequence) == offerId3);
6391 BEAST_EXPECT(offers[1]->getFieldU32(sfSequence) == offerId2);
6401 BEAST_EXPECT(offers.size() == 1);
6402 BEAST_EXPECT(offers[0]->getFieldU32(sfSequence) == offerId3);
6412 BEAST_EXPECT(offers.empty());
6425 using namespace jtx;
6429 Env env{*
this, features};
6430 auto const gw =
Account{
"gateway"};
6431 auto const alice =
Account{
"alice"};
6433 env.
fund(
XRP(10'000), gw, alice);
6436 MPT const usd =
MPTTester({.env = env, .issuer = gw, .holders = {alice}});
6440 env(
pay(gw, alice, usd(200)));
6445 env(
offer(alice,
XRP(50), usd(50)));
6457 BEAST_EXPECT(offerSeqId1 == offerSeqId0 + 6);
6458 env(
offer(alice,
XRP(50), usd(50)));
6474 BEAST_EXPECT(offers.size() == 4);
6475 BEAST_EXPECT(offers[0]->getFieldU32(sfSequence) == offerSeqId0);
6476 BEAST_EXPECT(offers[1]->getFieldU32(sfSequence) == offerTixId1);
6477 BEAST_EXPECT(offers[2]->getFieldU32(sfSequence) == offerTixId0);
6478 BEAST_EXPECT(offers[3]->getFieldU32(sfSequence) == offerSeqId1);
6490 BEAST_EXPECT(offers.size() == 3);
6491 BEAST_EXPECT(offers[0]->getFieldU32(sfSequence) == offerTixId1);
6492 BEAST_EXPECT(offers[1]->getFieldU32(sfSequence) == offerTixId0);
6493 BEAST_EXPECT(offers[2]->getFieldU32(sfSequence) == offerSeqId1);
6503 BEAST_EXPECT(offers.size() == 2);
6504 BEAST_EXPECT(offers[0]->getFieldU32(sfSequence) == offerTixId1);
6505 BEAST_EXPECT(offers[1]->getFieldU32(sfSequence) == offerSeqId1);
6518 BEAST_EXPECT(offers.size() == 1);
6519 BEAST_EXPECT(offers[0]->getFieldU32(sfSequence) == offerSeqId1);
6535 using namespace jtx;
6536 Account const issuer(
"issuer");
6540 auto const test = [&](
auto&& issue1,
auto&& issue2) {
6541 Env env(*
this, features);
6544 env.
fund(
XRP(1'000), maker, taker);
6548 issue1({.env = env, .token =
"USD", .issuer = issuer, .holders = {maker, taker}});
6550 issue2({.env = env, .token =
"EUR", .issuer = issuer, .holders = {maker, taker}});
6552 env(
pay(issuer, maker, usd(1'000)));
6553 env(
pay(issuer, taker, usd(1'000)));
6554 env(
pay(issuer, maker, eur(1'000)));
6557 auto makerUSDBalance = env.
balance(maker, usd).
value();
6558 auto takerUSDBalance = env.
balance(taker, usd).
value();
6559 auto makerEURBalance = env.
balance(maker, eur).
value();
6560 auto takerEURBalance = env.
balance(taker, eur).
value();
6566 env(
offer(maker,
XRP(100), usd(100)));
6572 makerXRPBalance -=
txFee(env, 1);
6573 takerXRPBalance -=
txFee(env, 1);
6574 makerUSDBalance -= usd(100);
6575 takerUSDBalance += usd(100);
6576 makerXRPBalance +=
XRP(100).value();
6577 takerXRPBalance -=
XRP(100).value();
6580 env(
offer(maker, usd(100),
XRP(100)));
6586 makerXRPBalance -=
txFee(env, 1);
6587 takerXRPBalance -=
txFee(env, 1);
6588 makerUSDBalance += usd(100);
6589 takerUSDBalance -= usd(100);
6590 makerXRPBalance -=
XRP(100).value();
6591 takerXRPBalance +=
XRP(100).value();
6594 env(
offer(maker, usd(100), eur(100)));
6597 env(
offer(taker, eur(100), usd(101)),
Txflags(tfFillOrKill));
6600 makerXRPBalance -=
txFee(env, 1);
6601 takerXRPBalance -=
txFee(env, 1);
6602 makerUSDBalance += usd(100);
6603 takerUSDBalance -= usd(100);
6604 makerEURBalance -= eur(100);
6605 takerEURBalance += eur(100);
6611 env(
offer(maker,
XRP(101), usd(101)));
6614 env(
offer(taker, usd(100),
XRP(101)),
Txflags(tfFillOrKill | tfSell));
6617 makerUSDBalance -= usd(101);
6618 takerUSDBalance += usd(101);
6619 makerXRPBalance +=
XRP(101).value() -
txFee(env, 1);
6620 takerXRPBalance -=
XRP(101).value() +
txFee(env, 1);
6623 env(
offer(maker, usd(101),
XRP(101)));
6626 env(
offer(taker,
XRP(100), usd(101)),
Txflags(tfFillOrKill | tfSell));
6629 makerUSDBalance += usd(101);
6630 takerUSDBalance -= usd(101);
6631 makerXRPBalance -=
XRP(101).value() +
txFee(env, 1);
6632 takerXRPBalance +=
XRP(101).value() -
txFee(env, 1);
6635 env(
offer(maker, usd(101), eur(101)));
6638 env(
offer(taker, eur(100), usd(101)),
Txflags(tfFillOrKill | tfSell));
6641 makerUSDBalance += usd(101);
6642 takerUSDBalance -= usd(101);
6643 makerEURBalance -= eur(101);
6644 takerEURBalance += eur(101);
6645 makerXRPBalance -=
txFee(env, 1);
6646 takerXRPBalance -=
txFee(env, 1);
6651 for (
auto const flags : {tfFillOrKill, tfFillOrKill + tfSell})
6653 env(
offer(maker,
XRP(100), usd(100)));
6659 makerXRPBalance -=
txFee(env, 1);
6660 takerXRPBalance -=
txFee(env, 1);
6663 env(
offer(maker, usd(100),
XRP(100)));
6669 makerXRPBalance -=
txFee(env, 1);
6670 takerXRPBalance -=
txFee(env, 1);
6673 env(
offer(maker, usd(100), eur(100)));
6679 makerXRPBalance -=
txFee(env, 1);
6680 takerXRPBalance -=
txFee(env, 1);
6685 env.
balance(maker, usd) == makerUSDBalance &&
6686 env.
balance(taker, usd) == takerUSDBalance &&
6687 env.
balance(maker, eur) == makerEURBalance &&
6688 env.
balance(taker, eur) == takerEURBalance &&
6689 env.
balance(maker,
XRP) == makerXRPBalance &&
6700 using namespace jtx;
6702 auto const gw =
Account{
"gateway"};
6703 auto const alice =
Account{
"alice"};
6708 auto const iou = gw[name];
6709 env(
trust(alice, iou(1'000)));
6710 env(
pay(gw, alice, iou(100)));
6716 MPTTester({.env = env, .issuer = gw, .holders = {alice}, .pay = 1'000'000'000});
6733 {.toAsset1 = getIOU, .toAsset2 = getIOU, .val1 = 10, .val2 = 30},
6734 {.toAsset1 = getIOU, .toAsset2 = getXRP, .val1 = 10, .val2 = 30'000'000},
6735 {.toAsset1 = getXRP, .toAsset2 = getIOU, .val1 = 10'000'000, .val2 = 30},
6736 {.toAsset1 = getMPT, .toAsset2 = getXRP, .val1 = 10'000'000, .val2 = 30'000'000},
6737 {.toAsset1 = getXRP, .toAsset2 = getMPT, .val1 = 10'000'000, .val2 = 30'000'000},
6738 {.toAsset1 = getIOU, .toAsset2 = getMPT, .val1 = 10, .val2 = 30'000'000},
6739 {.toAsset1 = getMPT, .toAsset2 = getIOU, .val1 = 10'000'000, .val2 = 30},
6740 {.toAsset1 = getMPT, .toAsset2 = getMPT, .val1 = 10'000'000, .val2 = 30'000'000},
6742 for (TestInfo
const& t :
tests)
6744 Env env{*
this, features};
6745 env.
fund(
XRP(10'000), gw, alice);
6748 auto const xts = t.toAsset1(env);
6749 auto const xxx = t.toAsset2(env);
6752 return asset.raw().visit(
6753 [&](
Issue const& issue) {
return issue.
native() ?
"XRPIssue" :
"Issue"; },
6754 [&](
MPTIssue const&) {
return "MPTIssue"; });
6757 testcase <<
"offer: " << tokenType(xts) <<
"/" << tokenType(xxx);
6761 auto txn =
noop(gw);
6762 txn[sfTickSize.fieldName] = 5;
6764 BEAST_EXPECT((*env.
le(gw))[sfTickSize] == 5);
6767 env(
offer(alice, xts(t.val1), xxx(t.val2)));
6768 env(
offer(alice, xts(t.val2), xxx(t.val1)));
6769 env(
offer(alice, xts(t.val1), xxx(t.val2)),
Json(jss::Flags, tfSell));
6770 env(
offer(alice, xts(t.val2), xxx(t.val1)),
Json(jss::Flags, tfSell));
6774 if (sle->getType() == ltOFFER)
6778 std::make_pair((*sle)[sfTakerPays], (*sle)[sfTakerGets]));
6783 auto it = offers.begin();
6784 BEAST_EXPECT(it != offers.end());
6785 if (xxx.native() && !xts.holds<
MPTIssue>())
6788 it->second.first == xts(t.val1) && it->second.second ==
XRPAmount(29'999'400));
6790 else if (!xxx.integral())
6793 it->second.first == xts(t.val1) && it->second.second < xxx(t.val2) &&
6794 it->second.second >
STAmount(xxx, 29'9994, -4));
6798 BEAST_EXPECT(it->second.first == xts(t.val1) && it->second.second == xxx(t.val2));
6803 BEAST_EXPECT(it != offers.end());
6804 BEAST_EXPECT(it->second.first == xts(t.val2) && it->second.second == xxx(t.val1));
6808 BEAST_EXPECT(it != offers.end());
6809 if (xts.native() && !xxx.holds<
MPTIssue>())
6812 it->second.first ==
XRPAmount(10'000'200) && it->second.second == xxx(t.val2));
6814 else if (!xts.integral())
6817 it->second.first ==
STAmount(xts, 10'0002, -4) &&
6818 it->second.second == xxx(t.val2));
6822 BEAST_EXPECT(it->second.first == xts(t.val1) && it->second.second == xxx(t.val2));
6828 BEAST_EXPECT(it != offers.end());
6829 BEAST_EXPECT(it->second.first == xts(t.val2) && it->second.second == xxx(t.val1));
6831 BEAST_EXPECT(++it == offers.end());
6859 using namespace jtx;
6861 auto const kBigMpt = 5'000'000'000'000'000'000LL;
6863 auto const runScenario = [&](
bool withTickSize) {
6864 Env env{*
this, features};
6865 auto const gw =
Account{
"gateway"};
6866 auto const alice =
Account{
"alice"};
6867 env.
fund(
XRP(10'000), gw, alice);
6870 auto const usd = gw[
"USD"];
6871 env(
trust(alice, usd(1'000)));
6872 env(
pay(gw, alice, usd(100)));
6880 auto txn =
noop(gw);
6881 txn[sfTickSize.fieldName] = 5;
6884 BEAST_EXPECT((*env.
le(gw))[sfTickSize] == 5);
6895 BEAST_EXPECT(
getRate(tiny, mpt(kBigMpt)) == 0);
6944 testcase(
"Zero Rate XRP/IOU Offer");
6946 using namespace jtx;
6948 auto const gw =
Account{
"gateway"};
6949 auto const alice =
Account{
"alice"};
6950 auto const bob =
Account{
"bob"};
6951 auto const usd = gw[
"USD"];
6956 auto const tinyUsd =
STAmount{usd, UINT64_C(1'000'000'000'000'000), -96};
6958 auto const setup = [&](
Env& env) {
6959 env.fund(
XRP(100'000), gw, alice, bob);
6961 env(
trust(alice, usd(1'000)));
6962 env(
trust(bob, usd(1'000)));
6963 env(
pay(gw, bob, usd(100)));
6969 Env env{*
this, features - featureMPTokensV2};
6973 BEAST_EXPECT(
getRate(
XRP(1'000), tinyUsd) == 0);
6978 BEAST_EXPECT(aliceOffers.size() == 1);
6980 BEAST_EXPECT(
getQuality((*aliceOffers.front())[sfBookDirectory]) == 0);
6997 Env env{*
this, features - featureMPTokensV2};
7000 auto txn =
noop(gw);
7001 txn[sfTickSize.fieldName] = 5;
7004 BEAST_EXPECT((*env.
le(gw))[sfTickSize] == 5);
7006 BEAST_EXPECT(
getRate(
XRP(1'000), tinyUsd) == 0);
7015 Env env{*
this, features};
7018 BEAST_EXPECT(
getRate(
XRP(1000), tinyUsd) == 0);
7030 Env env{*
this, features};
7034 auto const bobSeq = env.
seq(bob);
7041 BEAST_EXPECT(
getRate(
XRP(1'000), tinyUsd) == 0);
7049 BEAST_EXPECT(env.
balance(alice, usd).
value() == tinyUsd);
7066 testcase(
"Auto-Create Object Without Reserve Check During Partial Crossing");
7068 using namespace jtx;
7070 auto const gw =
Account{
"gateway"};
7071 auto const alice =
Account{
"alice"};
7072 auto const carol =
Account{
"carol"};
7073 auto const bob =
Account{
"bob"};
7075 auto const test = [&](
auto&& getToken,
auto&& execTx) {
7080 Env env{*
this, features};
7082 auto const f = env.
current()->fees().base;
7083 auto const r =
reserve(env, 0);
7084 auto const inc =
reserve(env, 1) - r;
7086 env.
fund(
XRP(10'000), gw, alice, bob);
7091 auto const token = getToken(env);
7097 if (BEAST_EXPECT(inc >
XRP(30)))
7098 env.
fund(r + inc + f +
XRP(30), carol);
7117 auto const carolBalance = r + inc +
XRP(15);
7119 BEAST_EXPECT(carolBalance < r + 2 * inc);
7122 env.trust(gw[
"USD"](1'000), alice);
7123 env(
pay(gw, alice, gw[
"USD"](100)));
7127 MPT const mpT1 =
MPTTester({.env = env, .issuer = gw, .holders = {alice}, .pay = 100});
7130 for (
auto&& getToken : {getIOU, getMPT})
7142 env(
pay(alice, bob,
XRP(15)),
7145 Txflags(tfNoRippleDirect | tfPartialPayment));
7161 testcase(
"MPT Offer large remainder after partial cross");
7163 using namespace jtx;
7171 Env env{*
this, features};
7175 env.
fund(
XRP(10'000), gw, alice, bob);
7178 auto const usd = gw[
"USD"];
7179 env(
trust(alice, usd(2 * gets)));
7180 env(
trust(bob, usd(2 * gets)));
7181 env(
pay(gw, alice, usd(2 * gets)));
7184 {.env = env, .issuer = gw, .holders = {alice, bob}, .maxAmt =
kMaxMpTokenAmount});
7185 env(
pay(gw, bob, mpt(1'000)));
7186 auto const askSeq = env.
seq(bob);
7187 env(
offer(bob, usd(askGets), mpt(1'000)));
7190 auto const bidSeq = env.
seq(alice);
7191 env(
offer(alice, mpt(pays), usd(gets)));
7194 BEAST_EXPECT(env.
balance(alice, mpt) == mpt(1'000));
7195 BEAST_EXPECT(env.
balance(bob, mpt) == mpt(0));
7196 BEAST_EXPECT(env.
balance(bob, usd) == usd(askGets));
7199 if (BEAST_EXPECT(bid))
7201 BEAST_EXPECT((*bid)[sfTakerPays] == mpt(pays - 1'000));
7202 BEAST_EXPECT((*bid)[sfTakerGets] == usd(remainderGets));
7209 test(1'000'000'000'000'000'000LL, 9'000'000'000'000'000LL, 9, 8'999'999'999'999'991LL);
7213 test(5'000'000'000'000'000'000LL, 5'000'000'000'000'000LL, 1, 4'999'999'999'999'999LL);
7227 testcase(
"Partially funded large MPT ask");
7229 using namespace jtx;
7231 for (
bool const payment : {
false,
true})
7233 Env env{*
this, features};
7238 env.
fund(
XRP(10'000), gw, bob, carol, dan);
7241 auto const usd = gw[
"USD"];
7242 env(
trust(bob, usd(10'000)));
7243 env(
trust(carol, usd(10'000)));
7244 env(
pay(gw, bob, usd(5'000)));
7249 .holders = {bob, carol, dan},
7252 env(
pay(gw, carol, s(480'000'000'000'000'000LL)));
7255 auto const carolSeq = env.
seq(carol);
7256 env(
offer(carol, usd(1'000), s(500'000'000'000'000'000LL)));
7261 env(
pay(bob, dan, s(1'000'000'000'000'000LL)),
7266 BEAST_EXPECT(env.
balance(dan, s) == s(1'000'000'000'000'000LL));
7270 env(
offer(bob, s(1'000'000'000'000'000LL), usd(2)));
7272 BEAST_EXPECT(env.
balance(bob, s) == s(1'000'000'000'000'000LL));
7276 BEAST_EXPECT(env.
balance(bob, usd) == usd(4'998));
7277 BEAST_EXPECT(env.
balance(carol, usd) == usd(2));
7278 BEAST_EXPECT(env.
balance(carol, s) == s(479'000'000'000'000'000LL));
7280 if (BEAST_EXPECT(ask))
7282 BEAST_EXPECT((*ask)[sfTakerGets] == s(499'000'000'000'000'000LL));
7283 BEAST_EXPECT((*ask)[sfTakerPays] == usd(998));
7291 testcase(
"book_offers uses MPT issuer capacity, transfer fees, and locks");
7293 using namespace jtx;
7295 Account const issuer{
"issuer"};
7303 Env env{*
this, features};
7305 env.
fund(
XRP(10'000), issuer, maker, buyer);
7309 {.env = env, .issuer = issuer, .holders = {maker, buyer}, .maxAmt = 100});
7310 MPT const usd = musd;
7312 auto const issuerOfferSeq = env.
seq(issuer);
7313 env(
offer(issuer,
XRP(100), usd(100)));
7315 musd.pay(issuer, maker, 100);
7318 if (!BEAST_EXPECT(issuance))
7320 BEAST_EXPECT(issuance->getFieldU64(sfOutstandingAmount) == 100);
7321 BEAST_EXPECT(issuance->getFieldU64(sfMaximumAmount) == 100);
7323 env(
offer(maker,
XRP(200), usd(100)));
7327 BEAST_EXPECT(bookOffers.
isArray());
7328 if (!BEAST_EXPECT(bookOffers.
size() >= 2))
7332 BEAST_EXPECT(issuerOffer[sfAccount.jsonName] == issuer.
human());
7333 BEAST_EXPECT(issuerOffer[sfSequence.jsonName] == issuerOfferSeq);
7334 BEAST_EXPECT(issuerOffer[jss::owner_funds] ==
"0");
7335 BEAST_EXPECT(issuerOffer.
isMember(jss::taker_gets_funded));
7336 BEAST_EXPECT(issuerOffer[jss::taker_gets_funded][jss::value] ==
"0");
7337 BEAST_EXPECT(issuerOffer.
isMember(jss::taker_pays_funded));
7338 BEAST_EXPECT(issuerOffer[jss::taker_pays_funded] ==
"0");
7345 Env env{*
this, features};
7347 env.
fund(
XRP(10'000), issuer, buyer);
7350 MPTTester const musd({.env = env, .issuer = issuer, .holders = {buyer}, .maxAmt = 150});
7351 MPT const usd = musd;
7353 auto const firstIssuerOfferSeq = env.
seq(issuer);
7354 env(
offer(issuer,
XRP(100), usd(100)));
7355 auto const secondIssuerOfferSeq = env.
seq(issuer);
7356 env(
offer(issuer,
XRP(100), usd(100)));
7360 BEAST_EXPECT(bookOffers.
isArray());
7361 if (!BEAST_EXPECT(bookOffers.
size() >= 2))
7365 BEAST_EXPECT(firstOffer[sfAccount.jsonName] == issuer.
human());
7366 BEAST_EXPECT(firstOffer[sfSequence.jsonName] == firstIssuerOfferSeq);
7367 BEAST_EXPECT(firstOffer[jss::owner_funds] ==
"150");
7368 BEAST_EXPECT(!firstOffer.
isMember(jss::taker_gets_funded));
7369 BEAST_EXPECT(!firstOffer.
isMember(jss::taker_pays_funded));
7372 BEAST_EXPECT(secondOffer[sfAccount.jsonName] == issuer.
human());
7373 BEAST_EXPECT(secondOffer[sfSequence.jsonName] == secondIssuerOfferSeq);
7374 BEAST_EXPECT(!secondOffer.
isMember(jss::owner_funds));
7375 BEAST_EXPECT(secondOffer.
isMember(jss::taker_gets_funded));
7376 BEAST_EXPECT(secondOffer[jss::taker_gets_funded][jss::value] ==
"50");
7377 BEAST_EXPECT(secondOffer.
isMember(jss::taker_pays_funded));
7378 BEAST_EXPECT(secondOffer[jss::taker_pays_funded] ==
"50000000");
7381 auto const checkTransferFeeBookOffers = [&](
std::uint16_t transferFee,
auto&& checkOffers) {
7382 Env env{*
this, features};
7384 env.
fund(
XRP(10'000), issuer, maker, buyer);
7390 .holders = {maker, buyer},
7391 .transferFee = transferFee,
7394 MPT const usd = musd;
7395 if (transferFee != 0)
7396 BEAST_EXPECT(musd.checkTransferFee(transferFee));
7398 auto const firstOfferSeq = env.
seq(maker);
7399 env(
offer(maker,
XRP(1'500), usd(1'500)));
7400 auto const secondOfferSeq = env.
seq(maker);
7401 env(
offer(maker,
XRP(1'500), usd(1'500)));
7405 BEAST_EXPECT(bookOffers.
isArray());
7406 if (!BEAST_EXPECT(bookOffers.
size() == 2))
7409 checkOffers(bookOffers, firstOfferSeq, secondOfferSeq);
7414 checkTransferFeeBookOffers(
7419 for (
auto const i : {0u, 1u})
7422 BEAST_EXPECT(
offer[sfAccount.jsonName] == maker.
human());
7424 offer[sfSequence.jsonName] == (i == 0u ? firstOfferSeq : secondOfferSeq));
7425 BEAST_EXPECT(!
offer.isMember(jss::taker_gets_funded));
7426 BEAST_EXPECT(!
offer.isMember(jss::taker_pays_funded));
7428 BEAST_EXPECT(bookOffers[0u][jss::owner_funds] ==
"3000");
7433 checkTransferFeeBookOffers(
7439 BEAST_EXPECT(firstOffer[sfAccount.jsonName] == maker.
human());
7440 BEAST_EXPECT(firstOffer[sfSequence.jsonName] == firstOfferSeq);
7441 BEAST_EXPECT(firstOffer[jss::owner_funds] ==
"3000");
7442 BEAST_EXPECT(!firstOffer.
isMember(jss::taker_gets_funded));
7443 BEAST_EXPECT(!firstOffer.
isMember(jss::taker_pays_funded));
7446 BEAST_EXPECT(secondOffer[sfAccount.jsonName] == maker.
human());
7447 BEAST_EXPECT(secondOffer[sfSequence.jsonName] == secondOfferSeq);
7452 BEAST_EXPECT(secondOffer.
isMember(jss::taker_gets_funded));
7453 BEAST_EXPECT(secondOffer[jss::taker_gets_funded][jss::value] ==
"500");
7454 BEAST_EXPECT(secondOffer.
isMember(jss::taker_pays_funded));
7455 BEAST_EXPECT(secondOffer[jss::taker_pays_funded] ==
"500000000");
7464 Env env{*
this, features};
7465 env.
fund(
XRP(10'000), issuer, maker, buyer);
7471 .holders = {maker, buyer},
7476 auto const firstOfferSeq = env.
seq(maker);
7478 auto const secondOfferSeq = env.
seq(maker);
7484 BEAST_EXPECT(bookOffers.
isArray());
7485 if (BEAST_EXPECT(bookOffers.
size() == 2))
7488 BEAST_EXPECT(firstOffer[sfSequence.jsonName] == firstOfferSeq);
7489 BEAST_EXPECT(firstOffer[jss::owner_funds] ==
"3");
7490 BEAST_EXPECT(!firstOffer.
isMember(jss::taker_gets_funded));
7491 BEAST_EXPECT(!firstOffer.
isMember(jss::taker_pays_funded));
7494 BEAST_EXPECT(secondOffer[sfSequence.jsonName] == secondOfferSeq);
7495 BEAST_EXPECT(secondOffer.
isMember(jss::taker_gets_funded));
7496 BEAST_EXPECT(secondOffer[jss::taker_gets_funded][jss::value] ==
"0");
7497 BEAST_EXPECT(secondOffer.
isMember(jss::taker_pays_funded));
7498 BEAST_EXPECT(secondOffer[jss::taker_pays_funded] ==
"0");
7506 BEAST_EXPECT(env.
balance(buyer, usd) == usd(3 + 1));
7507 BEAST_EXPECT(env.
balance(maker, usd) == usd(3 - 2));
7520 auto const checkLargeOwnerFunds =
7522 Env env{*
this, features};
7523 env.
fund(
XRP(10'000), issuer, maker, buyer);
7529 .holders = {maker, buyer},
7530 .transferFee = transferFee,
7533 env(
pay(issuer, maker, usd(funds)));
7536 auto const offerSeq = env.
seq(maker);
7537 env(
offer(maker,
XRP(100), usd(funds)));
7541 BEAST_EXPECT(!jrr.
isMember(jss::error));
7543 BEAST_EXPECT(bookOffers.
isArray());
7544 if (!BEAST_EXPECT(bookOffers.
size() == 1))
7548 BEAST_EXPECT(
offer[sfAccount.jsonName] == maker.
human());
7549 BEAST_EXPECT(
offer[sfSequence.jsonName] == offerSeq);
7551 BEAST_EXPECT(
offer[jss::taker_gets_funded][jss::value] == expectedFunded);
7556 checkLargeOwnerFunds(
kMaxTransferFee, 300'000'000'000'000'000LL,
"200000000000000000");
7560 checkLargeOwnerFunds(
kMaxTransferFee, 6'000'000'000'000'000'000LL,
"4000000000000000000");
7565 checkLargeOwnerFunds(1, 9'000'000'000'000'000'000LL,
"8999910000899991000");
7570 Env env{*
this, features};
7572 env.
fund(
XRP(10'000), issuer, maker, buyer);
7578 .holders = {maker, buyer},
7582 MPT const usd = musd;
7584 auto const offerSeq = env.
seq(maker);
7585 env(
offer(maker,
XRP(100), usd(100)));
7591 BEAST_EXPECT(bookOffers.
isArray());
7592 if (!BEAST_EXPECT(bookOffers.
size() == 1))
7596 BEAST_EXPECT(
offer[sfAccount.jsonName] == maker.
human());
7597 BEAST_EXPECT(
offer[sfSequence.jsonName] == offerSeq);
7598 BEAST_EXPECT(
offer[jss::owner_funds] ==
"100");
7599 BEAST_EXPECT(!
offer.isMember(jss::taker_gets_funded));
7600 BEAST_EXPECT(!
offer.isMember(jss::taker_pays_funded));
7603 musd.set({.flags = tfMPTLock});
7609 BEAST_EXPECT(bookOffers.
isArray() && bookOffers.
size() == 1);
7612 BEAST_EXPECT(
offer[sfAccount] == maker.
human());
7613 BEAST_EXPECT(
offer[sfSequence] == offerSeq);
7614 BEAST_EXPECT(
offer[jss::owner_funds] ==
"0");
7615 BEAST_EXPECT(
offer.isMember(jss::taker_gets_funded));
7616 BEAST_EXPECT(
offer[jss::taker_gets_funded][jss::value] ==
"0");
7617 BEAST_EXPECT(
offer.isMember(jss::taker_pays_funded));
7618 BEAST_EXPECT(
offer[jss::taker_pays_funded] ==
"0");
7632 testcase(
"getBookBase: (Issue,MPT) vs (MPT,Issue) preimage collision");
7644 BEAST_EXPECT(issuerB.
parseHex(
"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA00000007"));
7645 BEAST_EXPECT(issuerA.
parseHex(
"BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB"));
7646 BEAST_EXPECT(currencyB.
parseHex(
"BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB"));
7647 BEAST_EXPECT(currencyA.
parseHex(
"00000005AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"));
7648 BEAST_EXPECT(sharedIOUIssuer.
parseHex(
"CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC"));
7659 BEAST_EXPECT(bookA != bookB);
7669 testcase(
"getBookBase: (MPT,MPT) distinguishes from mixed branches");
7675 BEAST_EXPECT(issuerX.
parseHex(
"1111111111111111111111111111111111111111"));
7676 BEAST_EXPECT(issuerY.
parseHex(
"2222222222222222222222222222222222222222"));
7677 BEAST_EXPECT(currency.
parseHex(
"3333333333333333333333333333333333333333"));
7678 BEAST_EXPECT(iouIssuer.
parseHex(
"4444444444444444444444444444444444444444"));
7682 Book const mptBook{mptX, mptY, std::nullopt};
7683 Book const mixedBook{mptX,
Asset{
Issue{currency, iouIssuer}}, std::nullopt};
7684 Book const reversedMptBook{mptY, mptX, std::nullopt};
7693 testcase(
"getBookBase: domain does not reopen MPT preimage collisions");
7700 BEAST_EXPECT(issuerX.
parseHex(
"1111111111111111111111111111111111111111"));
7701 BEAST_EXPECT(issuerY.
parseHex(
"2222222222222222222222222222222222222222"));
7702 BEAST_EXPECT(currency.
parseHex(
"3333333333333333333333333333333333333333"));
7703 BEAST_EXPECT(iouIssuer.
parseHex(
"4444444444444444444444444444444444444444"));
7706 "\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD"
7707 "\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD");
7713 Book const publicBook{mptX, iou, std::nullopt};
7714 Book const domainBook{mptX, iou, domainA};
7719 Book const mi{mptX, iou, domainA};
7720 Book const im{iou, mptX, domainA};
7721 BEAST_EXPECT(mi != im);
7732 testcase(
"MPT Offer large rate - crosses in full");
7734 using namespace jtx;
7738 auto const kBigMpt = 200'000'000'000'000'000LL;
7743 auto const runScenario = [&](
STAmount const& aliceQuote) {
7744 Env env{*
this, features};
7745 auto const gw =
Account{
"gateway"};
7746 auto const alice =
Account{
"alice"};
7747 auto const bob =
Account{
"bob"};
7748 env.
fund(
XRP(10'000), gw, alice, bob);
7752 {.env = env, .issuer = gw, .holders = {alice, bob}, .maxAmt =
kMaxMpTokenAmount});
7754 env(
pay(gw, bob, mpt(kBigMpt)));
7761 BEAST_EXPECT(
getRate(mpt(kBigMpt),
XRP(1)) != 0);
7762 auto const bobSeq = env.
seq(bob);
7778 BEAST_EXPECT(env.
balance(alice, mpt) == mpt(kBigMpt));
7786 runScenario(
XRP(1));
7789 runScenario(
XRP(2));
7799 testcase(
"MPT Offer large rate - partial cross");
7801 using namespace jtx;
7803 auto const kBigMpt = 200'000'000'000'000'000LL;
7805 Env env{*
this, features};
7806 auto const gw =
Account{
"gateway"};
7807 auto const alice =
Account{
"alice"};
7808 auto const bob =
Account{
"bob"};
7809 env.
fund(
XRP(10'000), gw, alice, bob);
7813 {.env = env, .issuer = gw, .holders = {alice, bob}, .maxAmt =
kMaxMpTokenAmount});
7815 env(
pay(gw, bob, mpt(kBigMpt)));
7819 auto const bobSeq = env.
seq(bob);
7826 BEAST_EXPECT(
getRate(
XRP(2), mpt(2 * kBigMpt)) != 0);
7829 auto const fee = env.
current()->fees().base;
7835 BEAST_EXPECT(env.
balance(alice, mpt) == mpt(kBigMpt));
7841 if (BEAST_EXPECT(aliceOffers.size() == 1))
7843 auto const& remainder = *aliceOffers.front();
7844 BEAST_EXPECT(remainder[sfTakerPays] == mpt(kBigMpt));
7845 BEAST_EXPECT(remainder[sfTakerGets] ==
XRP(1));
7850 BEAST_EXPECT((*env.
le(alice))[sfOwnerCount] == 2);
7860 testcase(
"MPT Offer large rate - tick size with crossing");
7862 using namespace jtx;
7864 auto const kBigMpt = 5'000'000'000'000'000'000LL;
7866 Env env{*
this, features};
7867 auto const gw =
Account{
"gateway"};
7868 auto const alice =
Account{
"alice"};
7869 auto const bob =
Account{
"bob"};
7870 env.
fund(
XRP(10'000), gw, alice, bob);
7873 auto const usd = gw[
"USD"];
7874 env(
trust(alice, usd(1'000)));
7875 env(
pay(gw, alice, usd(100)));
7878 auto txn =
noop(gw);
7879 txn[sfTickSize.fieldName] = 5;
7882 BEAST_EXPECT((*env.
le(gw))[sfTickSize] == 5);
7885 {.env = env, .issuer = gw, .holders = {alice, bob}, .maxAmt =
kMaxMpTokenAmount});
7886 env(
pay(gw, bob, mpt(kBigMpt)));
7890 BEAST_EXPECT(
getRate(mpt(kBigMpt), usd(1)) != 0);
7891 auto const bobSeq = env.
seq(bob);
7898 BEAST_EXPECT(
getRate(usd(1), mpt(kBigMpt)) != 0);
7902 BEAST_EXPECT(env.
balance(alice, mpt) == mpt(kBigMpt));
7914 testcase(
"MPT Offer large rate - IOC and FoK");
7916 using namespace jtx;
7918 auto const kBigMpt = 200'000'000'000'000'000LL;
7921 Env env{*
this, features};
7922 auto const gw =
Account{
"gateway"};
7923 auto const alice =
Account{
"alice"};
7924 auto const bob =
Account{
"bob"};
7925 env.
fund(
XRP(10'000), gw, alice, bob);
7929 {.env = env, .issuer = gw, .holders = {alice, bob}, .maxAmt =
kMaxMpTokenAmount});
7930 env(
pay(gw, bob, mpt(kBigMpt)));
7933 auto const bobSeq = env.
seq(bob);
7939 BEAST_EXPECT(
getRate(
XRP(2), mpt(2 * kBigMpt)) != 0);
7940 env(
offer(alice, mpt(2 * kBigMpt),
XRP(2), flags),
Ter(expected));
7943 auto const bobOfferLive =
7949 BEAST_EXPECT(env.
balance(alice, mpt) == mpt(kBigMpt));
7950 BEAST_EXPECT(!bobOfferLive);
7956 BEAST_EXPECT(env.
balance(alice, mpt) == mpt(0));
7957 BEAST_EXPECT(bobOfferLive);
7962 runScenario(tfImmediateOrCancel,
tesSUCCESS);
8057 using namespace jtx;
TestcaseT testcase
Memberspace for declaring test cases.
UInt size() const
Number of values in array or object.
bool isMember(char const *key) const
Return true if the object has a member named key.
virtual Config & config()=0
static BaseUInt fromVoid(void const *data)
constexpr bool parseHex(std::string_view sv)
Parse a hex string into a base_uint.
A currency issued by an account.
Number is a floating point type that can represent a wide range of values.
std::string getText() const override
static constexpr int kMinOffset
static constexpr std::uint64_t kMinValue
std::shared_ptr< STLedgerEntry const > const & ConstRef
std::shared_ptr< STLedgerEntry const > const_pointer
static constexpr SeqProxy rawSequence(std::uint32_t v)
Factory function to return a sequence-based SeqProxy.
constexpr value_type value() const
Returns the underlying value.
void testMPTOfferLargeRateCrossable(FeatureBitset features)
void testMPTOfferFeePartialInStillFills(FeatureBitset features)
void testCurrencyConversionInParts(FeatureBitset features)
void run() override
Runs the suite.
void testCurrencyConversionEntire(FeatureBitset features)
void testMPTOfferFeeZeroInRemoved(FeatureBitset features)
void testXRPDirectCross(FeatureBitset features)
void testSellFlagExceedLimit(FeatureBitset features)
void testSelfPayUnlimitedFunds(FeatureBitset features)
void testCanceledOffer(FeatureBitset features)
void testMalformed(FeatureBitset features)
static std::vector< SLE::const_pointer > offersOnAccount(jtx::Env &env, jtx::Account account)
void testOfferAcceptThenCancel(FeatureBitset features)
static std::uint32_t lastClose(jtx::Env &env)
void testMPTOfferFeeZeroOutUnblocksBook(FeatureBitset features)
void testOfferInScalingWithXferRate(FeatureBitset features)
void testRequireAuth(FeatureBitset features)
void testUnfundedCross(FeatureBitset features)
void testMPTOfferFundsLimitedDustUnblocksBook(FeatureBitset features)
void testGatewayCrossCurrency(FeatureBitset features)
void testOfferCreateThenCross(FeatureBitset features)
void testMPTOfferLargeRatePartialCross(FeatureBitset features)
void testBookBaseDomainMptDistinct(FeatureBitset)
void testMPTOfferFeeZeroInUnblocksBook(FeatureBitset features)
void testInsufficientReserve(FeatureBitset features)
void testOfferInScaling(FeatureBitset features)
void testRmSmallIncreasedQOffersXRP(FeatureBitset features)
void testSelfAuth(FeatureBitset features)
void testMPTIssuerOfferUsesRemainingCapacity(FeatureBitset features)
void testMPTOfferLargeRateFlags(FeatureBitset features)
void testTransferRateOffer(FeatureBitset features)
void testTransferRateOverflowOffer(FeatureBitset features)
void testCurrencyConversionIntoDebt(FeatureBitset features)
void testSelfCrossOffer2(FeatureBitset features)
void testBridgedSecondLegDry(FeatureBitset features)
void testPartiallyFundedLargeMPTAsk(FeatureBitset features)
void testMPTOfferLargeTakerPaysQuality(FeatureBitset features)
void testTicketOffer(FeatureBitset features)
void testDestroyedMPTIssuanceBookInput(FeatureBitset features)
static std::vector< SLE::const_pointer > sortedOffersOnAccount(jtx::Env &env, jtx::Account const &acct)
void testRmSmallIncreasedQOffersMPT(FeatureBitset features)
void testPartiallyFundedMPTInputOfferZeroInput(FeatureBitset features)
void testTinyPayment(FeatureBitset features)
void testSelfCross(bool usePartner, FeatureBitset features)
void testCrossCurrencyBridged(FeatureBitset features)
void testNegativeBalance(FeatureBitset features)
void testSelfCrossOffer1(FeatureBitset features)
void testIOUOfferFeeZeroOutSlice(FeatureBitset features)
void testSellFlagBasic(FeatureBitset features)
void testMPTOfferFundsLimitedOwnerPays(FeatureBitset features)
void testBookBaseMixedAssetCollision(FeatureBitset)
void testSelfCrossOffer(FeatureBitset features)
void testDirectCross(FeatureBitset features)
void testSelfCrossLowQualityOffer(FeatureBitset features)
void testRmFundedOffer(FeatureBitset features)
void testMissingAuth(FeatureBitset features)
void testPartialCross(FeatureBitset features)
void testDeletedOfferIssuer(FeatureBitset features)
void testOfferCrossWithXRP(bool reverseOrder, FeatureBitset features)
void testSellWithFillOrKill(FeatureBitset features)
void testMPTOfferLargeRateTickSizeCross(FeatureBitset features)
void testSellOffer(FeatureBitset features)
void testMPTIssuerOfferZeroSelfDebit(FeatureBitset features)
void testMPTHolderOfferFeeZeroOutUnblocksBook(FeatureBitset features)
void testMPTAMMLimitQualityRounding(FeatureBitset features)
void testTicketCancelOffer(FeatureBitset features)
void testBookOffersMPTFunding(FeatureBitset features)
void testDirectToDirectPath(FeatureBitset features)
void testMPTOfferLargeRemainderCross(FeatureBitset features)
void testFillOrKill(FeatureBitset features)
void testCrossCurrencyStartXRP(FeatureBitset features)
void testZeroRateXrpIouOffer(FeatureBitset features)
void testMPTOfferZeroRate(FeatureBitset features)
void testExpiration(FeatureBitset features)
void testFillModes(FeatureBitset features)
void testCrossCurrencyEndXRP(FeatureBitset features)
void testOfferCrossWithLimitOverride(FeatureBitset features)
void testXRPOfferFeeZeroInSlice(FeatureBitset features)
void testXRPTinyPayment(FeatureBitset features)
void testTickSize(FeatureBitset features)
void testAutoCreateReserve(FeatureBitset features)
void testOfferFeesConsumeFunds(FeatureBitset features)
void testAll(FeatureBitset features)
void testMPTOfferFeeZeroOutRemoved(FeatureBitset features)
void testBridgedCross(FeatureBitset features)
static XRPAmount reserve(jtx::Env &env, std::uint32_t count)
void testSelfIssueOffer(FeatureBitset features)
void testBookBaseMptMptDistinct(FeatureBitset)
void testSelfPayXferFeeOffer(FeatureBitset features)
Convenience class to test AMM functionality.
Immutable cryptographic account descriptor.
std::string const & human() const
Returns the human readable public key.
AccountID id() const
Returns the Account ID.
A transaction testing environment.
bool close(NetClock::time_point closeTime, std::optional< std::chrono::milliseconds > consensusDelay=std::nullopt)
Close and advance the ledger.
SLE::const_pointer le(Account const &account) const
Return an account root.
std::uint32_t ownerCount(Account const &account) const
Return the number of objects owned by an account.
std::shared_ptr< ReadView const > closed()
Returns the last closed ledger.
void fund(bool setDefaultRipple, STAmount const &amount, Account const &account)
PrettyAmount limit(Account const &account, Issue const &issue) const
Returns the IOU limit on an account.
std::uint32_t seq(Account const &account) const
Returns the next sequence number on account.
PrettyAmount balance(Account const &account) const
Returns the XRP balance on an account.
void trust(STAmount const &amount, Account const &account)
Establish trust lines.
void require(Args const &... args)
Check a set of requirements.
std::shared_ptr< OpenView const > current() const
Returns the current ledger.
Test helper for creating, mutating, and asserting MPT and confidential MPT ledger state.
std::int64_t getBalance(Account const &account) const
void pay(Account const &src, Account const &dest, std::int64_t amount, std::optional< TER > err=std::nullopt, std::optional< std::vector< std::string > > credentials=std::nullopt, std::source_location const &loc=std::source_location::current())
void set(MPTSet const &set={}, std::source_location const &loc=std::source_location::current())
void authorize(MPTAuthorize const &arg=MPTAuthorize{}, std::source_location const &loc=std::source_location::current())
Converts to MPT Issue or STAmount.
Match the number of items in the account's owner directory.
Check a set of conditions.
Sets the SendMax on a JTx.
Set the expected result code for a JTx The test will fail if the code doesn't match.
Set a ticket sequence on a JTx.
@ Array
array value (ordered list)
Keylet offer(AccountID const &id, SeqProxy const &seq) noexcept
An offer from an account.
Keylet mptoken(MPTID const &issuanceID, AccountID const &holder) noexcept
Keylet account(AccountID const &id) noexcept
AccountID root.
Keylet mptokenIssuance(MPTID const &issuanceID) noexcept
json::Value create(Account const &account, std::uint32_t count)
Create one of more tickets.
json::Value ledgerEntryMPT(jtx::Env &env, jtx::Account const &acct, MPTID const &mptID)
json::Value pay(AccountID const &account, AccountID const &to, AnyAmount amount)
Create a payment.
static EpsilonT const kEpsilon
json::Value offerCancel(Account const &account, std::uint32_t offerSeq)
Cancel an offer.
void testHelper2TokensMix(TTester &&tester)
XrpT const XRP
Converts to XRP Issue or STAmount.
bool hasEnvelope2(json::Value const &reply)
Reports whether reply carries the version 2 envelope: jsonrpc equal to rpc::kJsonRpcVersion and rippl...
json::Value noop(Account const &account)
The null transaction.
json::Value getBookOffers(jtx::Env &env, Asset const &takerPays, Asset const &takerGets)
bool expectOffers(Env const &env, AccountID const &account, std::uint16_t size, std::vector< Amounts > const &toMatch)
XRPAmount txFee(Env const &env, std::uint16_t n)
FeatureBitset testableAmendments()
void testHelper3TokensMix(TTester &&tester)
OwnerCount< ltOFFER > Offers
Match the number of offers in the account's owner directory.
json::Value acctdelete(Account const &account, Account const &dest)
Delete account.
std::array< Account, 1+sizeof...(Args)> noripple(Account const &account, Args const &... args)
Designate accounts as no-ripple in Env::fund.
json::Value offer(Account const &account, STAmount const &takerPays, STAmount const &takerGets, std::uint32_t flags)
Create an offer.
json::Value ledgerEntryRoot(Env &env, Account const &acct)
std::unique_ptr< Config > envconfig()
creates and initializes a default configuration for jtx::Env
json::Value trust(Account const &account, STAmount const &amount, std::uint32_t flags)
Modify a trust line.
OwnerCount< ltMPTOKEN > MPTokens
Match the number of MPToken in the account's owner directory.
PrettyAmount drops(Integer i)
Returns an XRP PrettyAmount, which is trivially convertible to STAmount.
json::Value rate(Account const &account, double multiplier)
Set a transfer rate.
OwnerCount< ltTICKET > Tickets
Match the number of tickets on the account.
json::Value ledgerEntryOffer(jtx::Env &env, jtx::Account const &acct, std::uint32_t offerSeq)
bool isOffer(jtx::Env const &env, jtx::Account const &account, STAmount const &takerPays, STAmount const &takerGets)
An offer exists.
constexpr XRPAmount
Convert XRP to drops (integral types).
static XRPAmount reserve(jtx::Env const &env, std::uint32_t count)
BEAST_DEFINE_TESTSUITE_PRIO(AccountDelete, app, xrpl, 2)
std::unique_ptr< WSClient > makeWSClient(Config const &cfg, bool v2, unsigned rpcVersion, std::unordered_map< std::string, std::string > const &headers)
Returns a client operating through WebSockets/S.
Use hash_* containers for keys that do not need a cryptographically secure hashing algorithm.
void forEachItem(ReadView const &view, Keylet const &root, std::function< void(SLE::ConstRef)> const &f)
Iterate all items in the given directory.
Issue const & xrpIssue()
Returns an asset specifier that represents XRP.
UInt256 getBookBase(Book const &book)
std::uint64_t getQuality(UInt256 const &uBase)
int scale(Number const &number, Asset const &asset)
Get the scale of a Number for a given asset.
std::string toBase58(AccountID const &v)
Convert AccountID to base58 checked string.
BaseUInt< 160, detail::CurrencyTag > Currency
Currency is a hash representing a specific currency.
Seed generateSeed(std::string const &passPhrase)
Generate a seed deterministically.
std::string to_string(BaseUInt< Bits, Tag > const &a)
@ Actor
Another account signed and submitted transactions on behalf of this account (this account is the owne...
STAmount amountFromQuality(std::uint64_t rate)
BaseUInt< 192 > MPTID
MPTID is a 192-bit value representing MPT Issuance ID, which is a concatenation of a 32-bit sequence ...
json::Value getJson(LedgerFill const &fill)
Return a new json::Value representing the ledger with given options.
std::uint64_t getRate(STAmount const &offerOut, STAmount const &offerIn)
BaseUInt< 160, detail::AccountIDTag > AccountID
A 160-bit unsigned that uniquely identifies an account.
constexpr std::uint16_t kMaxTransferFee
The maximum token transfer fee allowed.
bool isTesSuccess(TER x) noexcept
TERSubset< CanCvtToTER > TER
Issue const & noIssue()
Returns an asset specifier that represents no account and currency.
constexpr std::uint64_t kMaxMpTokenAmount
The maximum amount of MPTokenIssuance.
Represents an XRP, IOU, or MPT quantity This customizes the string conversion and supports XRP conver...
STAmount const & value() const