ARCHIVE/rippled
1
0
Fork 0
mirror of https://github.com/XRPLF/rippled.git synced 2026-06-03 16:56:48 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
81903e7511eab37b85c674766b2645c697842420
rippled/src/test/app/AMMExtendedMPT_test.cpp
Alex Kremer 5b6e8b6f93 refactor: Rename static constants (#7120) 
Co-authored-by: Bart <bthomee@users.noreply.github.com>
2026-05-15 15:32:19 +00:00

3673 lines
133 KiB
C++
Raw Blame History

#include <test/jtx/AMM.h>
#include <test/jtx/AMMTest.h>
#include <test/jtx/Env.h>
#include <test/jtx/PathSet.h>
#include <test/jtx/TestHelpers.h>
#include <test/jtx/amount.h>
#include <test/jtx/balance.h>
#include <test/jtx/delivermin.h>
#include <test/jtx/fee.h>
#include <test/jtx/flags.h>
#include <test/jtx/jtx_json.h>
#include <test/jtx/mpt.h>
#include <test/jtx/multisign.h>
#include <test/jtx/noop.h>
#include <test/jtx/offer.h>
#include <test/jtx/owners.h>
#include <test/jtx/paths.h>
#include <test/jtx/pay.h>
#include <test/jtx/regkey.h>
#include <test/jtx/require.h>
#include <test/jtx/sendmax.h>
#include <test/jtx/sig.h>
#include <test/jtx/tags.h>
#include <test/jtx/ter.h>
#include <test/jtx/txflags.h>
#include <xrpl/beast/unit_test/suite.h>
#include <xrpl/json/json_value.h>
#include <xrpl/json/to_string.h>
#include <xrpl/ledger/ApplyView.h>
#include <xrpl/ledger/OpenView.h>
#include <xrpl/ledger/PaymentSandbox.h>
#include <xrpl/ledger/Sandbox.h>
#include <xrpl/ledger/helpers/OfferHelpers.h>
#include <xrpl/protocol/AccountID.h>
#include <xrpl/protocol/Feature.h>
#include <xrpl/protocol/Indexes.h>
#include <xrpl/protocol/Issue.h>
#include <xrpl/protocol/KeyType.h>
#include <xrpl/protocol/Quality.h>
#include <xrpl/protocol/SField.h>
#include <xrpl/protocol/STPathSet.h>
#include <xrpl/protocol/Seed.h>
#include <xrpl/protocol/TER.h>
#include <xrpl/protocol/TxFlags.h>
#include <xrpl/protocol/UintTypes.h>
#include <xrpl/protocol/XRPAmount.h>
#include <xrpl/protocol/jss.h>
#include <xrpl/tx/paths/Flow.h>
#include <xrpl/tx/paths/detail/Steps.h>
#include <cstdint>
#include <optional>
#include <tuple>
namespace xrpl::test {
/**
* Tests of AMM MPT that use offers.
*/
struct AMMExtendedMPT_test : public jtx::AMMTest
{
private:
void
testRmFundedOffer(FeatureBitset features)
{
testcase("Incorrect Removal of Funded Offers");
// We need at least two paths. One at good quality and one at bad
// quality. The bad quality path needs two offer books in a row.
// Each offer book should have two offers at the same quality, the
// offers should be completely consumed, and the payment should
// require both offers to be satisfied. The first offer must
// be "taker gets" XRP. Ensure that the payment engine does not remove
// the first "taker gets" xrp offer, because the offer is still
// funded and not used for the payment.
using namespace jtx;
Env env{*this, features};
fund(env, gw_, {alice_, bob_, carol_}, XRP(10'000));
MPTTester const eth(
{.env = env,
.issuer = gw_,
.holders = {alice_, bob_, carol_},
.pay = 200'000'000'000'000'000,
.flags = kMptDexFlags});
MPTTester const btc(
{.env = env,
.issuer = gw_,
.holders = {alice_, bob_, carol_},
.pay = 2'000'000'000'000'000,
.flags = kMptDexFlags});
// Must be two offers at the same quality
// "taker gets" must be XRP
// (Different amounts so I can distinguish the offers)
env(offer(carol_, btc(49'000'000'000'000), XRP(49)));
env(offer(carol_, btc(51'000'000'000'000), XRP(51)));
// Offers for the poor quality path
// Must be two offers at the same quality
env(offer(carol_, XRP(50), eth(50'000'000'000'000)));
env(offer(carol_, XRP(50), eth(50'000'000'000'000)));
// Good quality path
AMM const ammCarol(env, carol_, btc(1'000'000'000'000'000), eth(100'100'000'000'000'000));
PathSet const paths(TestPath(XRP, MPT(eth)), TestPath(MPT(eth)));
env(pay(alice_, bob_, eth(100'000'000'000'000)),
Json(paths.json()),
Sendmax(btc(1'000'000'000'000'000)),
Txflags(tfPartialPayment));
BEAST_EXPECT(ammCarol.expectBalances(
btc(1'001'000'000'374'816), eth(100'000'000'000'000'000), ammCarol.tokens()));
env.require(Balance(bob_, eth(200'100'000'000'000'000)));
BEAST_EXPECT(isOffer(env, carol_, btc(49'000'000'000'000), XRP(49)));
}
void
testFillModes(FeatureBitset features)
{
testcase("Fill Modes");
using namespace jtx;
auto const startBalance = XRP(1'000'000);
// Fill or Kill - unless we fully cross, just charge a fee and don't
// place the offer on the books. But also clean up expired offers
// that are discovered along the way.
testAMM(
[&](AMM& ammAlice, Env& env) {
auto const& btc = MPT(ammAlice[1]);
auto const baseFee = env.current()->fees().base;
auto carolBTC = env.balance(carol_, btc);
auto carolXRP = env.balance(carol_, XRP);
// Order that can't be filled
env(offer(carol_, btc(100), XRP(100)), Txflags(tfFillOrKill), Ter(tecKILLED));
env.close();
BEAST_EXPECT(ammAlice.expectBalances(XRP(10'100), btc(10'000), ammAlice.tokens()));
// fee = AMM
env.require(Balance(carol_, carolXRP - baseFee));
env.require(Balance(carol_, carolBTC));
BEAST_EXPECT(expectOffers(env, carol_, 0));
carolXRP = env.balance(carol_, XRP);
// Order that can be filled
env(offer(carol_, XRP(100), btc(100)), Txflags(tfFillOrKill), Ter(tesSUCCESS));
BEAST_EXPECT(ammAlice.expectBalances(XRP(10'000), btc(10'100), ammAlice.tokens()));
env.require(Balance(carol_, carolXRP + XRP(100) - baseFee));
env.require(Balance(carol_, carolBTC - btc(100)));
BEAST_EXPECT(expectOffers(env, carol_, 0));
},
{{XRP(10'100), gAmmmpt(10'000)}},
0,
std::nullopt,
{features});
// Immediate or Cancel - cross as much as possible
// and add nothing on the books.
testAMM(
[&](AMM& ammAlice, Env& env) {
auto const& btc = MPT(ammAlice[1]);
auto const baseFee = env.current()->fees().base;
auto carolBTC = env.balance(carol_, btc);
auto carolXRP = env.balance(carol_, XRP);
env(offer(carol_, XRP(200), btc(200)),
Txflags(tfImmediateOrCancel),
Ter(tesSUCCESS));
// AMM generates a synthetic offer of 100BTC/100XRP
// to match the CLOB offer quality.
BEAST_EXPECT(ammAlice.expectBalances(XRP(10'000), btc(10'100), ammAlice.tokens()));
// +AMM - offer * fee
env.require(Balance(carol_, carolXRP + XRP(100) - baseFee));
env.require(Balance(carol_, carolBTC - btc(100)));
BEAST_EXPECT(expectOffers(env, carol_, 0));
},
{{XRP(10'100), gAmmmpt(10'000)}},
0,
std::nullopt,
{features});
// tfPassive -- place the offer without crossing it.
testAMM(
[&](AMM& ammAlice, Env& env) {
// Carol creates a passive offer that could cross AMM.
// Carol's offer should stay in the ledger.
auto const& btc = MPT(ammAlice[1]);
env(offer(carol_, XRP(100), btc(100), tfPassive));
env.close();
BEAST_EXPECT(ammAlice.expectBalances(XRP(10'100), btc(10'000), ammAlice.tokens()));
BEAST_EXPECT(expectOffers(env, carol_, 1, {{{XRP(100), btc(100)}}}));
},
{{XRP(10'100), gAmmmpt(10'000)}},
0,
std::nullopt,
{features});
// tfPassive -- cross only offers of better quality.
testAMM(
[&](AMM& ammAlice, Env& env) {
auto const& btc = MPT(ammAlice[1]);
env(offer(alice_, btc(110), XRP(100)));
env.close();
// Carol creates a passive offer. That offer should cross
// AMM and leave Alice's offer untouched.
env(offer(carol_, XRP(100), btc(100), tfPassive));
env.close();
BEAST_EXPECT(ammAlice.expectBalances(XRP(10'900), btc(9083), ammAlice.tokens()));
BEAST_EXPECT(expectOffers(env, carol_, 0));
BEAST_EXPECT(expectOffers(env, alice_, 1));
},
{{XRP(11'000), gAmmmpt(9'000)}},
0,
std::nullopt,
{features});
}
void
testOfferCrossWithXRP(FeatureBitset features)
{
testcase("Offer Crossing with XRP, Normal order");
using namespace jtx;
Env env{*this, features};
fund(env, gw_, {bob_, alice_}, XRP(300'000));
MPTTester const btc(
{.env = env,
.issuer = gw_,
.holders = {alice_, bob_},
.pay = 100'000'000,
.flags = kMptDexFlags});
AMM const ammAlice(env, alice_, XRP(150'000), btc(50'000'000));
// Existing offer pays better than this wants.
// Partially consume existing offer.
// Pay 1'000'000 BTC, get 3061224490 Drops.
auto const xrpTransferred = XRPAmount{3'061'224'490};
env(offer(bob_, btc(1'000'000), XRP(4'000)));
BEAST_EXPECT(ammAlice.expectBalances(
XRP(150'000) + xrpTransferred, btc(49'000'000), IOUAmount{273'861'278752583, -5}));
env.require(Balance(bob_, btc(101'000'000)));
BEAST_EXPECT(
expectLedgerEntryRoot(env, bob_, XRP(300'000) - xrpTransferred - 2 * txFee(env, 1)));
BEAST_EXPECT(expectOffers(env, bob_, 0));
}
void
testOfferCrossWithLimitOverride(FeatureBitset features)
{
testcase("Offer Crossing with Limit Override");
using namespace jtx;
Env env{*this, features};
env.fund(XRP(200'000), gw_, alice_, bob_);
env.close();
MPTTester const btc(
{.env = env, .issuer = gw_, .holders = {alice_, bob_}, .flags = kMptDexFlags});
env(pay(gw_, alice_, btc(500'000'000)));
AMM const ammAlice(env, alice_, XRP(150'000), btc(51'000'000));
env(offer(bob_, btc(1'000'000), XRP(3'000)));
BEAST_EXPECT(ammAlice.expectBalances(XRP(153'000), btc(50'000'000), ammAlice.tokens()));
env.require(Balance(bob_, btc(1'000'000)));
env.require(Balance(bob_, XRP(200'000) - XRP(3'000) - env.current()->fees().base * 2));
}
void
testCurrencyConversionEntire(FeatureBitset features)
{
testcase("Currency Conversion: Entire Offer");
using namespace jtx;
Env env{*this, features};
fund(env, gw_, {alice_, bob_}, XRP(10'000));
env.require(Owners(bob_, 0));
MPTTester const btc(
{.env = env, .issuer = gw_, .holders = {alice_, bob_}, .flags = kMptDexFlags});
env(pay(gw_, bob_, btc(1'000'000'000)));
env.require(Owners(alice_, 1), Owners(bob_, 1));
env(pay(gw_, alice_, btc(100'000'000)));
AMM const ammBob(env, bob_, btc(200'000'000), XRP(1'500));
env(pay(alice_, alice_, XRP(500)), Sendmax(btc(100'000'000)));
BEAST_EXPECT(ammBob.expectBalances(btc(300'000'000), XRP(1'000), ammBob.tokens()));
env.require(Balance(alice_, btc(0)));
auto jrr = ledgerEntryRoot(env, alice_);
env.require(Balance(alice_, XRP(10'000) + XRP(500) - env.current()->fees().base * 2));
}
void
testCurrencyConversionInParts(FeatureBitset features)
{
testcase("Currency Conversion: In Parts");
using namespace jtx;
Env env{*this, features};
env.fund(XRP(30'000), gw_, bob_);
env.fund(XRP(40'000), alice_);
MPTTester const btc(
{.env = env,
.issuer = gw_,
.holders = {alice_, bob_},
.pay = 30'000'000'000,
.flags = kMptDexFlags});
env(pay(gw_, alice_, btc(10'000'000'000)));
AMM const ammAlice(env, alice_, XRP(10'000), btc(10'000'000'000));
env.close();
// Alice converts BTC to XRP which should fail
// due to PartialPayment.
env(pay(alice_, alice_, XRP(100)), Sendmax(btc(100'000'000)), Ter(tecPATH_PARTIAL));
// Alice converts BTC to XRP, should succeed because
// we permit partial payment
env(pay(alice_, alice_, XRP(100)), Sendmax(btc(100'000'000)), Txflags(tfPartialPayment));
env.close();
BEAST_EXPECT(ammAlice.expectBalances(
XRPAmount{9'900'990'100}, btc(10'100'000'000), ammAlice.tokens()));
// initial 40,000'000'000 - 10,000'000'000AMM - 100'000'000pay
env.require(Balance(alice_, btc(29'900'000'000)));
// initial 40,000 - 10,0000AMM + 99.009900pay - fee*3
BEAST_EXPECT(expectLedgerEntryRoot(
env,
alice_,
XRP(40'000) - XRP(10'000) + XRPAmount{99'009'900} - ammCrtFee(env) - txFee(env, 3)));
}
void
testCrossCurrencyStartXRP(FeatureBitset features)
{
testcase("Cross Currency Payment: Start with XRP");
using namespace jtx;
Env env{*this, features};
env.fund(XRP(30'000), gw_);
env.fund(XRP(40'000), alice_);
env.fund(XRP(1'000), bob_);
MPTTester const btc(
{.env = env, .issuer = gw_, .holders = {alice_, bob_}, .flags = kMptDexFlags});
env(pay(gw_, alice_, btc(10'100'000'000)));
AMM const ammAlice(env, alice_, XRP(10'000), btc(10'100'000'000));
env.close();
env(pay(alice_, bob_, btc(100'000'000)), Sendmax(XRP(100)));
BEAST_EXPECT(ammAlice.expectBalances(XRP(10'100), btc(10'000'000'000), ammAlice.tokens()));
env.require(Balance(bob_, btc(100'000'000)));
}
void
testCrossCurrencyEndXRP(FeatureBitset features)
{
testcase("Cross Currency Payment: End with XRP");
using namespace jtx;
Env env{*this, features};
env.fund(XRP(30'000), gw_);
env.fund(XRP(40'100), alice_);
env.fund(XRP(1'000), bob_);
MPTTester const btc(
{.env = env, .issuer = gw_, .holders = {alice_, bob_}, .flags = kMptDexFlags});
env(pay(gw_, alice_, btc(40'000'000'000)));
AMM const ammAlice(env, alice_, XRP(10'100), btc(10'000'000'000));
env.close();
env(pay(alice_, bob_, XRP(100)), Sendmax(btc(100'000'000)));
BEAST_EXPECT(ammAlice.expectBalances(XRP(10'000), btc(10'100'000'000), ammAlice.tokens()));
BEAST_EXPECT(expectLedgerEntryRoot(env, bob_, XRP(1'000) + XRP(100) - txFee(env, 1)));
}
void
testCrossCurrencyBridged(FeatureBitset features)
{
testcase("Cross Currency Payment: Bridged");
using namespace jtx;
auto test = [&](auto&& issue1, auto&& issue2) {
Env env(*this);
auto const dan = Account{"dan"};
env.fund(XRP(60'000), alice_, bob_, carol_, gw_, dan);
env.close();
auto const eth = issue1(
{.env = env,
.token = "ETH",
.issuer = gw_,
.holders = {alice_, bob_, carol_, dan},
.limit = 10'000'000'000'000'000});
auto const btc = issue2(
{.env = env,
.token = "BTC",
.issuer = gw_,
.holders = {alice_, bob_, carol_, dan},
.limit = 10'000'000'000'000'000});
env(pay(gw_, alice_, btc(500'000'000'000'000)));
env(pay(gw_, carol_, btc(6'000'000'000'000'000)));
env(pay(gw_, dan, eth(400'000'000'000'000)));
env.close();
env.close();
AMM const ammCarol(env, carol_, btc(5'000'000'000'000'000), XRP(50'000));
env(offer(dan, XRP(500), eth(50'000'000'000'000)));
env.close();
json::Value jtp{json::ValueType::Array};
jtp[0u][0u][jss::currency] = "XRP";
env(pay(alice_, bob_, eth(30'000'000'000'000)),
Json(jss::Paths, jtp),
Sendmax(btc(333'000'000'000'000)));
env.close();
BEAST_EXPECT(ammCarol.expectBalances(
XRP(49'700), btc(5'030'181'086'519'115), ammCarol.tokens()));
BEAST_EXPECT(expectOffers(env, dan, 1, {{Amounts{XRP(200), eth(20'000'000'000'000)}}}));
env.require(Balance(bob_, eth(30'000'000'000'000)));
};
testHelper2TokensMix(test);
}
void
testOfferFeesConsumeFunds(FeatureBitset features)
{
testcase("Offer Fees Consume Funds");
using namespace jtx;
Env env{*this, features};
// Provide micro amounts to compensate for fees to make results round
// nice.
auto const startingXrp =
XRP(100) + env.current()->fees().accountReserve(2) + env.current()->fees().base * 3;
env.fund(startingXrp, gw_, alice_);
env.fund(XRP(2'000), bob_);
env.close();
MPTTester const btc(
{.env = env, .issuer = gw_, .holders = {alice_, bob_}, .flags = kMptDexFlags});
// Created only to increase one reserve count for alice
MPTTester const eth(
{.env = env, .issuer = gw_, .holders = {alice_}, .flags = kMptDexFlags});
env(pay(gw_, bob_, btc(1'200'000'000'000'000)));
AMM const ammBob(env, bob_, XRP(1'000), btc(1'200'000'000'000'000));
// Alice has 400 - (2 reserve of 50 = 300 reserve) = 100 available.
// Ask for more than available to prove reserve works.
env(offer(alice_, btc(200'000'000'000'000), XRP(200)));
// The pool gets only 100XRP for ~109.09e12BTC, even though
// it can exchange more.
BEAST_EXPECT(
ammBob.expectBalances(XRP(1'100), btc(1'090'909'090'909'091), ammBob.tokens()));
env.require(Balance(alice_, btc(109'090'909'090'909)));
env.require(Balance(alice_, XRP(300)));
}
void
testOfferCreateThenCross(FeatureBitset features)
{
testcase("Offer Create, then Cross");
using namespace jtx;
Env env{*this, features};
fund(env, gw_, {alice_, bob_}, XRP(200'000));
MPTTester const btc(
{.env = env,
.issuer = gw_,
.holders = {alice_, bob_},
.transferFee = 500,
.flags = kMptDexFlags});
env(pay(gw_, bob_, btc(1'000'000'000'000)));
env(pay(gw_, alice_, btc(200'000'000'000'000)));
AMM const ammAlice(env, alice_, btc(150'000'000'000'000), XRP(150'100));
env(offer(bob_, XRP(100), btc(100'000'000'000)));
BEAST_EXPECT(
ammAlice.expectBalances(btc(150'100'000'000'000), XRP(150'000), ammAlice.tokens()));
// Bob pays 0.005 transfer fee.
env.require(Balance(bob_, btc(899'500'000'000)));
}
void
testSellFlagBasic(FeatureBitset features)
{
testcase("Offer tfSell: Basic Sell");
using namespace jtx;
Env env{*this, features};
env.fund(XRP(30'000), gw_, bob_, carol_);
env.fund(XRP(39'900), alice_);
MPTTester const btc(
{.env = env,
.issuer = gw_,
.holders = {alice_, bob_, carol_},
.pay = 30'000,
.flags = kMptDexFlags});
env(pay(gw_, alice_, btc(10'100)));
AMM const ammAlice(env, alice_, XRP(9'900), btc(10'100));
env(offer(carol_, btc(100), XRP(100)), Json(jss::Flags, tfSell));
env.close();
BEAST_EXPECT(ammAlice.expectBalances(XRP(10'000), btc(9'999), ammAlice.tokens()));
BEAST_EXPECT(expectOffers(env, carol_, 0));
env.require(Balance(carol_, btc(30'101)));
BEAST_EXPECT(
expectLedgerEntryRoot(env, carol_, XRP(30'000) - XRP(100) - 2 * txFee(env, 1)));
}
void
testSellFlagExceedLimit(FeatureBitset features)
{
testcase("Offer tfSell: 2x Sell Exceed Limit");
using namespace jtx;
Env env{*this, features};
auto const startingXrp = XRP(100) + reserve(env, 1) + env.current()->fees().base * 2;
env.fund(startingXrp, gw_, alice_);
env.fund(XRP(2'000), bob_);
env.close();
MPTTester const btc(
{.env = env, .issuer = gw_, .holders = {alice_, bob_}, .flags = kMptDexFlags});
env(pay(gw_, bob_, btc(2'200'000'000)));
AMM const ammBob(env, bob_, XRP(1'000), btc(2'200'000'000));
// Alice has 350 fees - a reserve of 50 = 250 reserve = 100 available.
// Ask for more than available to prove reserve works.
// Taker pays 100'000'000 BTC for 100 XRP.
// Selling XRP.
// Will sell all 100 XRP and get more BTC than asked for.
env(offer(alice_, btc(100'000'000), XRP(200)), Json(jss::Flags, tfSell));
BEAST_EXPECT(ammBob.expectBalances(XRP(1'100), btc(2'000'000'000), ammBob.tokens()));
env.require(Balance(alice_, btc(200'000'000)));
BEAST_EXPECT(expectLedgerEntryRoot(env, alice_, XRP(250)));
BEAST_EXPECT(expectOffers(env, alice_, 0));
}
void
testGatewayCrossCurrency(FeatureBitset features)
{
testcase("Client Issue: Gateway Cross Currency");
using namespace jtx;
Env env{*this, features};
auto const startingXrp = XRP(100.1) + reserve(env, 1) + env.current()->fees().base * 2;
env.fund(startingXrp, gw_, alice_, bob_);
MPTTester const xts(
{.env = env,
.issuer = gw_,
.holders = {alice_, bob_},
.pay = 1'000'000'000'000'000,
.flags = kMptDexFlags});
MPTTester const xxx(
{.env = env,
.issuer = gw_,
.holders = {alice_, bob_},
.pay = 1'000'000'000'000'000,
.flags = kMptDexFlags});
AMM const ammAlice(env, alice_, xts(1'000'000'000'000'000), xxx(1'000'000'000'000'000));
json::Value payment;
payment[jss::secret] = toBase58(generateSeed("bob"));
payment[jss::id] = env.seq(bob_);
payment[jss::build_path] = true;
payment[jss::tx_json] = pay(bob_, bob_, xxx(10'000'000'000'000));
payment[jss::tx_json][jss::Sequence] =
env.current()->read(keylet::account(bob_.id()))->getFieldU32(sfSequence);
payment[jss::tx_json][jss::Fee] = to_string(env.current()->fees().base);
payment[jss::tx_json][jss::SendMax] =
xts(15'000'000'000'000).value().getJson(JsonOptions::Values::None);
payment[jss::tx_json][jss::Flags] = tfPartialPayment;
auto const jrr = env.rpc("json", "submit", to_string(payment));
BEAST_EXPECT(jrr[jss::result][jss::status] == "success");
BEAST_EXPECT(jrr[jss::result][jss::engine_result] == "tesSUCCESS");
BEAST_EXPECT(ammAlice.expectBalances(
xts(1'010'101'010'101'011), xxx(990'000'000'000'000), ammAlice.tokens()));
env.require(Balance(bob_, xts(989'898'989'898'989)));
env.require(Balance(bob_, xxx(1'010'000'000'000'000)));
}
void
testBridgedCross(FeatureBitset features)
{
testcase("Bridged Crossing");
using namespace jtx;
{
Env env{*this, features};
env.fund(XRP(30'000), gw_, alice_, bob_, carol_);
MPTTester const btc(
{.env = env,
.issuer = gw_,
.holders = {alice_, bob_, carol_},
.pay = 15'000'000'000,
.flags = kMptDexFlags});
MPTTester const eth(
{.env = env,
.issuer = gw_,
.holders = {alice_, bob_, carol_},
.pay = 15'000'000'000,
.flags = kMptDexFlags});
// The scenario:
// o BTC/XRP AMM is created.
// o ETH/XRP AMM is created.
// o carol has ETH but wants BTC.
// Note that carol's offer must come last. If carol's offer is
// placed before AMM is created, then autobridging will not occur.
AMM const ammAlice(env, alice_, XRP(10'000), btc(10'100'000'000));
AMM const ammBob(env, bob_, eth(10'000'000'000), XRP(10'100));
// Carol makes an offer that consumes AMM liquidity and
// fully consumes Carol's offer.
env(offer(carol_, btc(100'000'000), eth(100'000'000)));
env.close();
BEAST_EXPECT(
ammAlice.expectBalances(XRP(10'100), btc(10'000'000'000), ammAlice.tokens()));
BEAST_EXPECT(ammBob.expectBalances(XRP(10'000), eth(10'100'000'000), ammBob.tokens()));
env.require(Balance(carol_, btc(15'100'000'000)));
env.require(Balance(carol_, eth(14'900'000'000)));
BEAST_EXPECT(expectOffers(env, carol_, 0));
}
{
Env env{*this, features};
env.fund(XRP(30'000), gw_, alice_, bob_, carol_);
MPTTester const btc(
{.env = env,
.issuer = gw_,
.holders = {alice_, bob_, carol_},
.pay = 15'000'000'000,
.flags = kMptDexFlags});
MPTTester const eth(
{.env = env,
.issuer = gw_,
.holders = {alice_, bob_, carol_},
.pay = 15'000'000'000,
.flags = kMptDexFlags});
// The scenario:
// o BTC/XRP AMM is created.
// o ETH/XRP offer is created.
// o carol has ETH but wants BTC.
// Note that carol's offer must come last. If carol's offer is
// placed before AMM and bob's offer are created, then autobridging
// will not occur.
AMM const ammAlice(env, alice_, XRP(10'000), btc(10'100'000'000));
env(offer(bob_, eth(100'000'000), XRP(100)));
env.close();
// Carol makes an offer that consumes AMM liquidity and
// fully consumes Carol's offer.
env(offer(carol_, btc(100'000'000), eth(100'000'000)));
env.close();
BEAST_EXPECT(
ammAlice.expectBalances(XRP(10'100), btc(10'000'000'000), ammAlice.tokens()));
env.require(Balance(carol_, btc(15'100'000'000)));
env.require(Balance(carol_, eth(14'900'000'000)));
BEAST_EXPECT(expectOffers(env, carol_, 0));
BEAST_EXPECT(expectOffers(env, bob_, 0));
}
{
Env env{*this, features};
env.fund(XRP(30'000), gw_, alice_, bob_, carol_);
MPTTester const btc(
{.env = env,
.issuer = gw_,
.holders = {alice_, bob_, carol_},
.pay = 15'000'000'000,
.flags = kMptDexFlags});
MPTTester const eth(
{.env = env,
.issuer = gw_,
.holders = {alice_, bob_, carol_},
.pay = 15'000'000'000,
.flags = kMptDexFlags});
// The scenario:
// o BTC/XRP offer is created.
// o ETH/XRP AMM is created.
// o carol has ETH but wants BTC.
// Note that carol's offer must come last. If carol's offer is
// placed before AMM and alice's offer are created, then
// autobridging will not occur.
env(offer(alice_, XRP(100), btc(100'000'000)));
env.close();
AMM const ammBob(env, bob_, eth(10'000'000'000), XRP(10'100));
// Carol makes an offer that consumes AMM liquidity and
// fully consumes Carol's offer.
env(offer(carol_, btc(100'000'000), eth(100'000'000)));
env.close();
BEAST_EXPECT(ammBob.expectBalances(XRP(10'000), eth(10'100'000'000), ammBob.tokens()));
env.require(Balance(carol_, btc(15'100'000'000)));
env.require(Balance(carol_, eth(14'900'000'000)));
BEAST_EXPECT(expectOffers(env, carol_, 0));
BEAST_EXPECT(expectOffers(env, alice_, 0));
}
}
void
testSellWithFillOrKill(FeatureBitset features)
{
// Test a number of different corner cases regarding offer crossing
// when both the tfSell flag and tfFillOrKill flags are set.
testcase("Combine tfSell with tfFillOrKill");
using namespace jtx;
{
Env env{*this, features};
env.fund(XRP(30'000), gw_, alice_, bob_);
MPTTester const btc(
{.env = env,
.issuer = gw_,
.holders = {alice_, bob_},
.pay = 20'000'000'000,
.flags = kMptDexFlags});
AMM const ammBob(env, bob_, XRP(20'000), btc(200'000'000));
// alice submits a tfSell | tfFillOrKill offer that does not cross.
env(offer(alice_, btc(2'100'000), XRP(210), tfSell | tfFillOrKill), Ter(tecKILLED));
BEAST_EXPECT(ammBob.expectBalances(XRP(20'000), btc(200'000'000), ammBob.tokens()));
BEAST_EXPECT(expectOffers(env, bob_, 0));
}
{
Env env{*this, features};
env.fund(XRP(30'000), gw_, alice_, bob_);
MPTTester const btc(
{.env = env,
.issuer = gw_,
.holders = {alice_, bob_},
.pay = 1'000'000'000'000'000,
.flags = kMptDexFlags});
AMM const ammBob(env, bob_, XRP(20'000), btc(200'000'000'000'000));
// alice submits a tfSell | tfFillOrKill offer that crosses.
// Even though tfSell is present it doesn't matter this time.
env(offer(alice_, btc(2'000'000'000'000), XRP(220), tfSell | tfFillOrKill));
env.close();
BEAST_EXPECT(
ammBob.expectBalances(XRP(20'220), btc(197'823'936'696'341), ammBob.tokens()));
env.require(Balance(alice_, btc(1'002'176'063'303'659)));
BEAST_EXPECT(expectOffers(env, alice_, 0));
}
{
// alice submits a tfSell | tfFillOrKill offer that crosses and
// returns more than was asked for (because of the tfSell flag).
Env env{*this, features};
env.fund(XRP(30'000), gw_, alice_, bob_);
MPTTester const btc(
{.env = env,
.issuer = gw_,
.holders = {alice_, bob_},
.pay = 1'000'000'000'000'000,
.flags = kMptDexFlags});
AMM const ammBob(env, bob_, XRP(20'000), btc(200'000'000'000'000));
env(offer(alice_, btc(10'000'000'000'000), XRP(1'500), tfSell | tfFillOrKill));
env.close();
BEAST_EXPECT(
ammBob.expectBalances(XRP(21'500), btc(186'046'511'627'907), ammBob.tokens()));
env.require(Balance(alice_, btc(1'013'953'488'372'093)));
BEAST_EXPECT(expectOffers(env, alice_, 0));
}
{
// alice submits a tfSell | tfFillOrKill offer that doesn't cross.
// This would have succeeded with a regular tfSell, but the
// fillOrKill prevents the transaction from crossing since not
// all of the offer is consumed because AMM generated offer,
// which matches alice's offer quality is ~ 10XRP/0.01996e3BTC.
Env env{*this, features};
env.fund(XRP(30'000), gw_, alice_, bob_);
MPTTester const btc(
{.env = env,
.issuer = gw_,
.holders = {alice_, bob_},
.pay = 10'000'000'000,
.flags = kMptDexFlags});
AMM const ammBob(env, bob_, XRP(5000), btc(10'000'000));
env(offer(alice_, btc(1'000'000), XRP(501), tfSell | tfFillOrKill), Ter(tecKILLED));
env.close();
BEAST_EXPECT(expectOffers(env, alice_, 0));
BEAST_EXPECT(expectOffers(env, bob_, 0));
}
}
void
testTransferRateOffer(FeatureBitset features)
{
testcase("Transfer Rate Offer");
using namespace jtx;
// AMM XRP/BTC. Alice places BTC/XRP offer.
{
Env env(*this, features);
env.fund(XRP(30'000), gw_, bob_, carol_);
env.fund(XRP(40'000), alice_);
MPTTester const btc(
{.env = env,
.issuer = gw_,
.holders = {alice_, bob_, carol_},
.transferFee = 25'000,
.pay = 30'000'000,
.flags = kMptDexFlags});
env(pay(gw_, alice_, btc(10'100'000)));
AMM const ammAlice(env, alice_, XRP(10'000), btc(10'100'000));
env.close();
env(offer(carol_, btc(100'000), XRP(100)));
env.close();
// AMM doesn't pay the transfer fee
BEAST_EXPECT(ammAlice.expectBalances(XRP(10'100), btc(10'000'000), ammAlice.tokens()));
env.require(Balance(carol_, btc(30'100'000)));
BEAST_EXPECT(expectOffers(env, carol_, 0));
}
{
Env env(*this, features);
env.fund(XRP(30'000), gw_, bob_, carol_);
env.fund(XRP(40'100), alice_);
MPTTester const btc(
{.env = env,
.issuer = gw_,
.holders = {alice_, bob_, carol_},
.transferFee = 25'000,
.pay = 30'000'000,
.flags = kMptDexFlags});
env(pay(gw_, alice_, btc(10'000'000)));
AMM const ammAlice(env, alice_, XRP(10'100), btc(10'000'000));
env.close();
env(offer(carol_, XRP(100), btc(100'000)));
env.close();
BEAST_EXPECT(ammAlice.expectBalances(XRP(10'000), btc(10'100'000), ammAlice.tokens()));
// Carol pays 25% transfer fee
env.require(Balance(carol_, btc(29'875'000)));
BEAST_EXPECT(expectOffers(env, carol_, 0));
}
{
// Bridged crossing.
Env env{*this, features};
env.fund(XRP(30'000), gw_, alice_, bob_, carol_);
MPTTester const btc(
{.env = env,
.issuer = gw_,
.holders = {alice_, bob_, carol_},
.transferFee = 25'000,
.pay = 15'000'000,
.flags = kMptDexFlags});
MPTTester const eth(
{.env = env,
.issuer = gw_,
.holders = {alice_, bob_, carol_},
.transferFee = 25'000,
.pay = 15'000'000,
.flags = kMptDexFlags});
// The scenario:
// o BTC/XRP AMM is created.
// o ETH/XRP Offer is created.
// o carol has ETH but wants BTC.
// Note that Carol's offer must come last. If Carol's offer is
// placed before AMM is created, then autobridging will not occur.
AMM const ammAlice(env, alice_, XRP(10'000), btc(10'100'000));
env(offer(bob_, eth(100'000), XRP(100)));
env.close();
// Carol makes an offer that consumes AMM liquidity and
// fully consumes Bob's offer.
env(offer(carol_, btc(100'000), eth(100'000)));
env.close();
// AMM doesn't pay the transfer fee
BEAST_EXPECT(ammAlice.expectBalances(XRP(10'100), btc(10'000'000), ammAlice.tokens()));
env.require(Balance(carol_, btc(15'100'000)));
// Carol pays 25% transfer fee.
env.require(Balance(carol_, eth(14'875'000)));
BEAST_EXPECT(expectOffers(env, carol_, 0));
BEAST_EXPECT(expectOffers(env, bob_, 0));
}
{
// Bridged crossing. The transfer fee is paid on the step not
// involving AMM as src/dst.
Env env{*this, features};
env.fund(XRP(30'000), gw_, alice_, bob_, carol_);
MPTTester const btc(
{.env = env,
.issuer = gw_,
.holders = {alice_, bob_, carol_},
.transferFee = 25'000,
.pay = 15'000'000,
.flags = kMptDexFlags});
MPTTester const eth(
{.env = env,
.issuer = gw_,
.holders = {alice_, bob_, carol_},
.transferFee = 25'000,
.pay = 15'000'000,
.flags = kMptDexFlags});
// The scenario:
// o BTC/XRP AMM is created.
// o ETH/XRP Offer is created.
// o carol has ETH but wants BTC.
// Note that Carol's offer must come last. If Carol's offer is
// placed before AMM is created, then autobridging will not occur.
AMM const ammAlice(env, alice_, XRP(10'000), btc(10'050'000));
env(offer(bob_, eth(100'000), XRP(100)));
env.close();
// Carol makes an offer that consumes AMM liquidity and
// partially consumes Bob's offer.
env(offer(carol_, btc(50'000), eth(50'000)));
env.close();
// This test verifies that the amount removed from an offer
// accounts for the transfer fee that is removed from the
// account but not from the remaining offer.
// AMM doesn't pay the transfer fee
BEAST_EXPECT(ammAlice.expectBalances(XRP(10'050), btc(10'000'000), ammAlice.tokens()));
env.require(Balance(carol_, btc(15'050'000)));
// Carol pays 25% transfer fee.
env.require(Balance(carol_, eth(14'937'500)));
BEAST_EXPECT(expectOffers(env, carol_, 0));
BEAST_EXPECT(expectOffers(env, bob_, 1, {{Amounts{eth(50'000), XRP(50)}}}));
}
}
void
testSelfIssueOffer(FeatureBitset features)
{
// This test is not the same as corresponding testSelfIssueOffer()
// in the Offer_test. It simply tests AMM with self issue and
// offer crossing.
using namespace jtx;
Env env{*this, features};
auto const f = env.current()->fees().base;
env.fund(XRP(30'000) + f, alice_, bob_);
env.close();
MPTTester const btc(
{.env = env, .issuer = bob_, .holders = {alice_}, .flags = kMptDexFlags});
AMM const ammBob(env, bob_, XRP(10'000), btc(10'100));
env(offer(alice_, btc(100), XRP(100)));
env.close();
BEAST_EXPECT(ammBob.expectBalances(XRP(10'100), btc(10'000), ammBob.tokens()));
BEAST_EXPECT(expectOffers(env, alice_, 0));
env.require(Balance(alice_, btc(100)));
}
void
testDirectToDirectPath(FeatureBitset features)
{
// The offer crossing code expects that a DirectStep is always
// preceded by a BookStep. In one instance the default path
// was not matching that assumption. Here we recreate that case
// so we can prove the bug stays fixed.
testcase("Direct to Direct path");
using namespace jtx;
Env env{*this, features};
auto const ann = Account("ann");
auto const bob = Account("bob");
auto const cam = Account("cam");
auto const carol = Account("carol");
auto const fee = env.current()->fees().base;
env.fund(XRP(1'000), carol);
env.fund(reserve(env, 4) + (fee * 5), ann, bob, cam);
env.close();
MPTTester const aBux(
{.env = env, .issuer = ann, .holders = {bob, cam, carol}, .flags = kMptDexFlags});
MPTTester const bBux(
{.env = env, .issuer = bob, .holders = {ann, cam, carol}, .flags = kMptDexFlags});
env(pay(ann, cam, aBux(350'000'000'000'000)));
env(pay(bob, cam, bBux(350'000'000'000'000)));
env(pay(bob, carol, bBux(4'000'000'000'000'000)));
env(pay(ann, carol, aBux(4'000'000'000'000'000)));
AMM const ammCarol(env, carol, aBux(3'000'000'000'000'000), bBux(3'300'000'000'000'000));
// cam puts an offer on the books that her upcoming offer could cross.
// But this offer should be deleted, not crossed, by her upcoming
// offer.
env(offer(cam, aBux(290'000'000'000'000), bBux(300'000'000'000'000), tfPassive));
env.close();
env.require(Balance(cam, aBux(350'000'000'000'000)));
env.require(Balance(cam, bBux(350'000'000'000'000)));
env.require(offers(cam, 1));
// This offer caused the assert.
env(offer(cam, bBux(300'000'000'000'000), aBux(300'000'000'000'000)));
// AMM is consumed up to the first cam Offer quality
BEAST_EXPECT(ammCarol.expectBalances(
aBux(3'093'541'659'651'604), bBux(3'200'215'509'984'418), ammCarol.tokens()));
BEAST_EXPECT(expectOffers(
env, cam, 1, {{Amounts{bBux(200'215'509'984'418), aBux(200'215'509'984'419)}}}));
}
void
testRequireAuth(FeatureBitset features)
{
testcase("RequireAuth");
using namespace jtx;
Env env{*this, features};
env.fund(XRP(400'000), gw_, alice_, bob_);
MPTTester btc(
{.env = env,
.issuer = gw_,
.holders = {alice_, bob_},
.flags = tfMPTRequireAuth | kMptDexFlags});
// Authorize bob and alice
btc.authorize({.holder = alice_});
btc.authorize({.holder = bob_});
env(pay(gw_, alice_, btc(1'000)));
env.close();
// Alice is able to create AMM since the GW has authorized her
AMM const ammAlice(env, alice_, btc(1'000), XRP(1'050));
env(pay(gw_, bob_, btc(50)));
env.close();
env.require(Balance(bob_, btc(50)));
// Bob's offer should cross Alice's AMM
env(offer(bob_, XRP(50), btc(50)));
env.close();
BEAST_EXPECT(ammAlice.expectBalances(btc(1'050), XRP(1'000), ammAlice.tokens()));
BEAST_EXPECT(expectOffers(env, bob_, 0));
env.require(Balance(bob_, btc(0)));
}
void
testMissingAuth(FeatureBitset features)
{
testcase("Missing Auth");
using namespace jtx;
Env env{*this, features};
env.fund(XRP(400'000), gw_, alice_, bob_);
env.close();
MPTTester btc(
{.env = env,
.issuer = gw_,
.holders = {alice_, bob_},
.flags = tfMPTRequireAuth | kMptDexFlags});
// Alice doesn't have the funds
{
AMM const ammAlice(env, alice_, btc(1'000), XRP(1'000), Ter(tecNO_AUTH));
}
btc.authorize({.holder = bob_});
env(pay(gw_, bob_, btc(50)));
env.close();
env.require(Balance(bob_, btc(50)));
// Alice should not be able to create AMM without authorization.
{
AMM const ammAlice(env, alice_, btc(1'000), XRP(1'000), Ter(tecNO_AUTH));
}
// Finally, authorize alice. Now alice's AMM create should succeed.
btc.authorize({.holder = alice_});
env(pay(gw_, alice_, btc(1'000)));
env.close();
AMM const ammAlice(env, alice_, btc(1'000), XRP(1'050));
// Authorize AMM.
// BTC.authorize({.account = ammAlice.ammAccount()});
// env.close();
// Now bob creates his offer again, which crosses with alice's AMM.
env(offer(bob_, XRP(50), btc(50)));
env.close();
BEAST_EXPECT(ammAlice.expectBalances(btc(1'050), XRP(1'000), ammAlice.tokens()));
BEAST_EXPECT(expectOffers(env, bob_, 0));
env.require(Balance(bob_, btc(0)));
}
void
testOffers()
{
using namespace jtx;
FeatureBitset const all{testableAmendments()};
testRmFundedOffer(all);
testFillModes(all);
testOfferCrossWithXRP(all);
testOfferCrossWithLimitOverride(all);
testCurrencyConversionEntire(all);
testCurrencyConversionInParts(all);
testCrossCurrencyStartXRP(all);
testCrossCurrencyEndXRP(all);
testCrossCurrencyBridged(all);
testOfferFeesConsumeFunds(all);
testOfferCreateThenCross(all);
testSellFlagExceedLimit(all);
testGatewayCrossCurrency(all);
testBridgedCross(all);
testSellWithFillOrKill(all);
testTransferRateOffer(all);
testSelfIssueOffer(all);
testSellFlagBasic(all);
testDirectToDirectPath(all);
testRequireAuth(all);
testMissingAuth(all);
}
void
pathFindConsumeAll()
{
testcase("path find consume all");
using namespace jtx;
Env env = pathTestEnv();
env.fund(XRP(100'000'260), alice_);
env.fund(XRP(30'000), gw_, bob_, carol_);
MPTTester const eth(
{.env = env,
.issuer = gw_,
.holders = {alice_, bob_, carol_},
.pay = 100'000'000'000'000,
.flags = kMptDexFlags});
AMM const ammCarol(env, carol_, XRP(100), eth(100'000'000'000'000));
STPathSet st;
STAmount sa;
STAmount da;
std::tie(st, sa, da) = findPaths(
env, alice_, bob_, bob_["AUD"](-1), std::optional<STAmount>(XRP(100'000'000)));
BEAST_EXPECT(st.empty());
std::tie(st, sa, da) =
findPaths(env, alice_, bob_, eth(-1), std::optional<STAmount>(XRP(100'000'000)));
// Alice sends all requested 100,000,000XRP
BEAST_EXPECT(sa == XRP(100'000'000));
// Bob gets ~99.99e12ETH. This is the amount Bob
// can get out of AMM for 100,000,000XRP.
BEAST_EXPECT(equal(da, eth(99'999'900'000'100)));
}
// carol holds ETH, sells ETH for XRP
// bob will hold ETH
// alice pays bob ETH using XRP
void
viaOffersViaGateway()
{
testcase("via gateway");
using namespace jtx;
Env env = pathTestEnv();
env.fund(XRP(10'000), alice_, bob_, carol_, gw_);
env.close();
MPTTester const eth(
{.env = env,
.issuer = gw_,
.holders = {alice_, bob_, carol_},
.transferFee = 10'000,
.flags = kMptDexFlags});
MPTTester const btc(
{.env = env,
.issuer = gw_,
.holders = {alice_, bob_, carol_},
.transferFee = 10'000,
.flags = kMptDexFlags});
env(pay(gw_, carol_, eth(51)));
env.close();
AMM const ammCarol(env, carol_, XRP(40), eth(51));
env(pay(alice_, bob_, eth(10)), Sendmax(XRP(100)), Paths(XRP));
env.close();
// AMM offer is 51.282052XRP/11ETH, 11ETH/1.1 = 10ETH to bob
BEAST_EXPECT(ammCarol.expectBalances(XRP(51), eth(40), ammCarol.tokens()));
env.require(Balance(bob_, eth(10)));
auto const result = findPaths(env, alice_, bob_, btc(25));
BEAST_EXPECT(std::get<0>(result).empty());
}
void
receiveMax()
{
testcase("Receive max");
using namespace jtx;
auto const charlie = Account("charlie");
{
// XRP -> MPT receive max
Env env = pathTestEnv();
env.fund(XRP(30'000), alice_, bob_, charlie, gw_);
MPTTester const eth(
{.env = env,
.issuer = gw_,
.holders = {alice_, bob_, charlie},
.pay = 11'000'000'000'000,
.flags = kMptDexFlags});
AMM const ammCharlie(env, charlie, XRP(10), eth(11'000'000'000'000));
auto [st, sa, da] = findPaths(env, alice_, bob_, eth(-1), XRP(1).value());
BEAST_EXPECT(sa == XRP(1));
BEAST_EXPECT(equal(da, eth(1'000'000'000'000)));
if (BEAST_EXPECT(st.size() == 1 && st[0].size() == 1))
{
auto const& pathElem = st[0][0];
BEAST_EXPECT(
pathElem.isOffer() && pathElem.getIssuerID() == gw_.id() &&
pathElem.getMPTID() == eth.issuanceID());
}
}
{
// MPT -> XRP receive max
Env env = pathTestEnv();
env.fund(XRP(30'000), alice_, bob_, charlie, gw_);
MPTTester const eth(
{.env = env,
.issuer = gw_,
.holders = {alice_, bob_, charlie},
.pay = 11'000'000'000'000,
.flags = kMptDexFlags});
AMM const ammCharlie(env, charlie, XRP(11), eth(10'000'000'000'000));
env.close();
auto [st, sa, da] =
findPaths(env, alice_, bob_, drops(-1), eth(1'000'000'000'000).value());
BEAST_EXPECT(sa == eth(1'000'000'000'000));
BEAST_EXPECT(equal(da, XRP(1)));
if (BEAST_EXPECT(st.size() == 1 && st[0].size() == 1))
{
auto const& pathElem = st[0][0];
BEAST_EXPECT(
pathElem.isOffer() && pathElem.getIssuerID() == xrpAccount() &&
pathElem.getCurrency() == xrpCurrency());
}
}
}
void
pathFind01()
{
testcase("Path Find: XRP -> XRP and XRP -> MPT");
using namespace jtx;
Env env = pathTestEnv();
Account a1{"A1"};
Account a2{"A2"};
Account a3{"A3"};
Account const g1{"G1"};
Account const g2{"G2"};
Account g3{"G3"};
Account m1{"M1"};
env.fund(XRP(100'000), a1);
env.fund(XRP(10'000), a2);
env.fund(XRP(1'000), a3, g1, g2, g3);
env.fund(XRP(20'000), m1);
env.close();
MPTTester const xyzG1(
{.env = env, .issuer = g1, .holders = {a1, m1, a2}, .flags = kMptDexFlags});
MPTTester const xyzG2(
{.env = env, .issuer = g2, .holders = {a2, m1, a1}, .flags = kMptDexFlags});
MPTTester const abcG3(
{.env = env, .issuer = g3, .holders = {a1, a2, m1, a3}, .flags = kMptDexFlags});
MPTTester const abcA2(
{.env = env, .issuer = a2, .holders = {g3, a1}, .flags = kMptDexFlags});
env(pay(g1, a1, xyzG1(3'500'000'000)));
env(pay(g3, a1, abcG3(1'200'000'000)));
env(pay(g1, m1, xyzG1(25'000'000'000)));
env(pay(g2, m1, xyzG2(25'000'000'000)));
env(pay(g3, m1, abcG3(25'000'000'000)));
env(pay(a2, g3, abcA2(101'000'000)));
env.close();
AMM const ammM1XyzG1XyzG2(env, m1, xyzG1(1'000'000'000), xyzG2(1'000'000'000));
AMM const ammM1XrpAbcG3(env, m1, XRP(10'000), abcG3(1'000'000'000));
AMM const ammG3AbcG3AbcA2(env, g3, abcG3(100'000'000), abcA2(101'000'000));
env.close();
STPathSet st;
STAmount sa, da;
{
auto const& sendAmt = XRP(10);
std::tie(st, sa, da) = findPaths(env, a1, a2, sendAmt, std::nullopt, xrpCurrency());
BEAST_EXPECT(equal(da, sendAmt));
BEAST_EXPECT(st.empty());
}
{
// no path should exist for this since dest account
// does not exist.
auto const& sendAmt = XRP(200);
std::tie(st, sa, da) =
findPaths(env, a1, Account{"A0"}, sendAmt, std::nullopt, xrpCurrency());
BEAST_EXPECT(equal(da, sendAmt));
BEAST_EXPECT(st.empty());
}
{
auto const& sendAmt = abcG3(10'000'000);
std::tie(st, sa, da) = findPaths(env, a2, g3, sendAmt, std::nullopt, xrpCurrency());
BEAST_EXPECT(equal(da, sendAmt));
BEAST_EXPECT(equal(sa, XRPAmount{101'010'102}));
BEAST_EXPECT(same(st, stpath(ipe(MPT(abcG3)))));
}
{
auto const& sendAmt = abcA2(1'000'000);
std::tie(st, sa, da) = findPaths(env, a1, a2, sendAmt, std::nullopt, xrpCurrency());
BEAST_EXPECT(equal(da, sendAmt));
BEAST_EXPECT(equal(sa, XRPAmount{10'010'011}));
BEAST_EXPECT(same(st, stpath(ipe(MPT(abcG3)), ipe(MPT(abcA2)))));
}
}
void
pathFind02()
{
testcase("Path Find: non-XRP -> XRP");
using namespace jtx;
Env env = pathTestEnv();
Account a1{"A1"};
Account a2{"A2"};
Account const g3{"G3"};
Account m1{"M1"};
env.fund(XRP(1'000), a1, a2, g3);
env.fund(XRP(11'000), m1);
env.close();
MPTTester const eth(
{.env = env,
.issuer = g3,
.holders = {a1, a2, m1},
.pay = 1'000'000'000,
.flags = kMptDexFlags});
AMM const ammM1(env, m1, eth(1'000'000'000), XRP(10'010));
STPathSet st;
STAmount sa, da;
auto const& sendAmt = XRP(10);
std::tie(st, sa, da) =
findPathsByElement(env, a1, a2, sendAmt, std::nullopt, ipe(MPT(eth)));
BEAST_EXPECT(equal(da, sendAmt));
BEAST_EXPECT(equal(sa, eth(1'000'000)));
BEAST_EXPECT(same(st, stpath(ipe(xrpIssue()))));
}
void
pathFind06()
{
testcase("Path Find: non-XRP -> non-XRP, same issuanceID");
using namespace jtx;
{
Env env = pathTestEnv();
Account a1{"A1"};
Account a2{"A2"};
Account const a3{"A3"};
Account const g1{"G1"};
Account const g2{"G2"};
Account m1{"M1"};
env.fund(XRP(11'000), m1);
env.fund(XRP(1'000), a1, a2, a3, g1, g2);
env.close();
MPTTester const hkdG1(
{.env = env,
.issuer = g1,
.holders = {a1, m1},
.pay = 5'000'000'000,
.flags = kMptDexFlags});
MPTTester const hkdG2(
{.env = env,
.issuer = g2,
.holders = {a2, m1},
.pay = 5'000'000'000,
.flags = kMptDexFlags});
AMM const ammM1(env, m1, hkdG1(1'000'000'000), hkdG2(1'010'000'000));
auto const& sendAmt = hkdG2(10'000'000);
STPathSet st;
STAmount sa, da;
std::tie(st, sa, da) = jtx::findPaths(
env, g1, a2, sendAmt, std::nullopt, hkdG1.issuanceID(), std::nullopt, std::nullopt);
BEAST_EXPECT(equal(da, sendAmt));
BEAST_EXPECT(equal(sa, hkdG1(10'000'000)));
BEAST_EXPECT(same(st, stpath(ipe(MPT(hkdG2)))));
}
}
void
testFalseDry(FeatureBitset features)
{
testcase("falseDryChanges");
using namespace jtx;
Env env(*this, features);
env.memoize(bob_);
env.fund(XRP(10'000), alice_, gw_);
fund(env, gw_, {carol_}, XRP(10'000), {}, Fund::Acct);
auto const ammxrpPool = env.current()->fees().increment * 2;
env.fund(reserve(env, 5) + ammCrtFee(env) + ammxrpPool, bob_);
env.close();
MPTTester const eth(
{.env = env, .issuer = gw_, .holders = {alice_, bob_, carol_}, .flags = kMptDexFlags});
MPTTester const btc(
{.env = env, .issuer = gw_, .holders = {alice_, bob_, carol_}, .flags = kMptDexFlags});
env(pay(gw_, alice_, eth(50'000)));
env(pay(gw_, bob_, btc(150'000)));
// Bob has _just_ slightly less than 50 xrp available
// If his owner count changes, he will have more liquidity.
// This is one error case to test (when Flow is used).
// Computing the incoming xrp to the XRP/BTC offer will require two
// recursive calls to the ETH/XRP offer. The second call will return
// tecPATH_DRY, but the entire path should not be marked as dry.
// This is the second error case to test (when flowV1 is used).
env(offer(bob_, eth(50'000), XRP(50)));
AMM const ammBob(env, bob_, ammxrpPool, btc(150'000));
env(pay(alice_, carol_, btc(1'000'000'000)),
Path(~XRP, ~MPT(btc)),
Sendmax(eth(500'000)),
Txflags(tfNoRippleDirect | tfPartialPayment));
auto const carolBTC = env.balance(carol_, MPT(btc));
BEAST_EXPECT(carolBTC > btc(0) && carolBTC < btc(50'000));
}
void
testBookStep(FeatureBitset features)
{
testcase("Book Step");
using namespace jtx;
// simple MPT/IOU mix offer
{
auto test = [&](auto&& issue1, auto&& issue2) {
Env env(*this);
env.fund(XRP(30'000), alice_, bob_, carol_, gw_);
env.close();
auto const eth = issue1(
{.env = env,
.token = "ETH",
.issuer = gw_,
.holders = {alice_, bob_, carol_},
.limit = 100'000'000});
auto const btc = issue2(
{.env = env,
.token = "BTC",
.issuer = gw_,
.holders = {alice_, bob_, carol_},
.limit = 100'000'000});
env(pay(gw_, alice_, btc(500000)));
env(pay(gw_, bob_, btc(500000)));
env(pay(gw_, carol_, btc(500000)));
env(pay(gw_, alice_, eth(500000)));
env(pay(gw_, bob_, eth(500000)));
env(pay(gw_, carol_, eth(500000)));
env.close();
AMM const ammBob(env, bob_, btc(100'000), eth(150'000));
env(pay(alice_, carol_, eth(50'000)), Path(~eth), Sendmax(btc(50'000)));
env.require(Balance(alice_, btc(450'000)));
env.require(Balance(bob_, btc(400'000)));
env.require(Balance(bob_, eth(350'000)));
env.require(Balance(carol_, eth(550'000)));
BEAST_EXPECT(ammBob.expectBalances(btc(150'000), eth(100'000), ammBob.tokens()));
};
testHelper2TokensMix(test);
}
{
// simple MPT/XRP XRP/MPT offer
Env env(*this, features);
env.fund(XRP(10'000), gw_, alice_, bob_, carol_);
MPTTester const btc(
{.env = env,
.issuer = gw_,
.holders = {alice_, bob_, carol_},
.pay = 100'000,
.flags = kMptDexFlags});
MPTTester const eth(
{.env = env,
.issuer = gw_,
.holders = {alice_, bob_, carol_},
.pay = 150'000,
.flags = kMptDexFlags});
AMM const ammBobBtcXrp(env, bob_, btc(100'000), XRP(150));
AMM const ammBobXrpEth(env, bob_, XRP(100), eth(150'000));
env(pay(alice_, carol_, eth(50'000)), Path(~XRP, ~MPT(eth)), Sendmax(btc(50'000)));
env.require(Balance(alice_, btc(50'000)));
env.require(Balance(bob_, btc(0)));
env.require(Balance(bob_, eth(0)));
env.require(Balance(carol_, eth(200'000)));
BEAST_EXPECT(
ammBobBtcXrp.expectBalances(btc(150'000), XRP(100), ammBobBtcXrp.tokens()));
BEAST_EXPECT(
ammBobXrpEth.expectBalances(XRP(150), eth(100'000), ammBobXrpEth.tokens()));
}
{
// simple XRP -> MPT through offer and sendmax
Env env(*this, features);
XRPAmount const baseFee{env.current()->fees().base};
env.fund(XRP(10'000), gw_, alice_, bob_, carol_);
MPTTester const eth(
{.env = env,
.issuer = gw_,
.holders = {alice_, bob_, carol_},
.pay = 150'000,
.flags = kMptDexFlags});
AMM const ammBob(env, bob_, XRP(100), eth(150'000));
env(pay(alice_, carol_, eth(50'000)), Path(~MPT(eth)), Sendmax(XRP(50)));
BEAST_EXPECT(expectLedgerEntryRoot(env, alice_, XRP(10'000) - XRP(50) - 2 * baseFee));
BEAST_EXPECT(expectLedgerEntryRoot(
env, bob_, XRP(10'000) - XRP(100) - ammCrtFee(env) - baseFee));
env.require(Balance(bob_, eth(0)));
env.require(Balance(carol_, eth(200'000)));
BEAST_EXPECT(ammBob.expectBalances(XRP(150), eth(100'000), ammBob.tokens()));
}
{
// simple MPT -> XRP through offer and sendmax
Env env(*this, features);
XRPAmount const baseFee{env.current()->fees().base};
env.fund(XRP(10'000), gw_, alice_, bob_, carol_);
MPTTester const eth(
{.env = env,
.issuer = gw_,
.holders = {alice_, bob_, carol_},
.pay = 100'000,
.flags = kMptDexFlags});
AMM const ammBob(env, bob_, eth(100'000), XRP(150));
env(pay(alice_, carol_, XRP(50)), Path(~XRP), Sendmax(eth(50'000)));
env.require(Balance(alice_, eth(50'000)));
BEAST_EXPECT(expectLedgerEntryRoot(
env, bob_, XRP(10'000) - XRP(150) - ammCrtFee(env) - baseFee));
env.require(Balance(bob_, eth(0)));
BEAST_EXPECT(expectLedgerEntryRoot(env, carol_, XRP(10'000 + 50) - baseFee));
BEAST_EXPECT(ammBob.expectBalances(eth(150'000), XRP(100), ammBob.tokens()));
}
// test unfunded offers are removed when payment succeeds
{
auto test = [&](auto&& issue1, auto&& issue2, auto&& issue3) {
Env env(*this, features);
env.fund(XRP(10'000), alice_, bob_, carol_, gw_);
env.close();
auto const btc = issue1(
{.env = env,
.token = "BTC",
.issuer = gw_,
.holders = {alice_, bob_, carol_},
.limit = 1000'000000});
auto const eth = issue2(
{.env = env,
.token = "ETH",
.issuer = gw_,
.holders = {alice_, bob_, carol_},
.limit = 1000'000000});
auto const gbp = issue3(
{.env = env,
.token = "GBP",
.issuer = gw_,
.holders = {alice_, bob_, carol_},
.limit = 1000'000000});
env(pay(gw_, alice_, btc(60'000)));
env(pay(gw_, bob_, eth(200'000)));
env(pay(gw_, bob_, gbp(150'000)));
env(offer(bob_, btc(50'000), eth(50'000)));
env(offer(bob_, btc(40'000), gbp(50'000)));
env.close();
AMM const ammBob(env, bob_, gbp(100'000), eth(150'000));
// unfund offer
env(pay(bob_, gw_, gbp(50'000)));
BEAST_EXPECT(isOffer(env, bob_, btc(50'000), eth(50'000)));
BEAST_EXPECT(isOffer(env, bob_, btc(40'000), gbp(50'000)));
env(pay(alice_, carol_, eth(50'000)),
Path(~eth),
Path(~gbp, ~eth),
Sendmax(btc(60'000)));
env.require(Balance(alice_, btc(10'000)));
env.require(Balance(bob_, btc(50'000)));
env.require(Balance(bob_, eth(0)));
env.require(Balance(bob_, gbp(0)));
env.require(Balance(carol_, eth(50'000)));
// used in the payment
BEAST_EXPECT(!isOffer(env, bob_, btc(50'000), eth(50'000)));
// found unfunded
BEAST_EXPECT(!isOffer(env, bob_, btc(40'000), gbp(50'000)));
// unchanged
BEAST_EXPECT(ammBob.expectBalances(gbp(100'000), eth(150'000), ammBob.tokens()));
};
testHelper3TokensMix(test);
}
{
// test unfunded offers are removed when the payment fails.
// bob makes two offers: a funded 50'000'000 ETH for 50'000'000 BTC
// and an unfunded 50'000'000 GBP for 60'000'000 BTC. alice pays
// carol 61'000'000 ETH with 61'000'000 BTC. alice only has
// 60'000'000 BTC, so the payment will fail. The payment uses two
// paths: one through bob's funded offer and one through his
// unfunded offer. When the payment fails `flow` should return the
// unfunded offer. This test is intentionally similar to the one
// that removes unfunded offers when the payment succeeds.
Env env(*this, features);
env.fund(XRP(10'000), bob_, carol_, gw_);
env.close();
// Sets rippling on, this is different from
// the original test
fund(env, gw_, {alice_}, XRP(10'000), {}, Fund::Acct);
MPTTester btc(
{.env = env,
.issuer = gw_,
.holders = {alice_, bob_, carol_},
.flags = kMptDexFlags});
MPTTester eth(
{.env = env,
.issuer = gw_,
.holders = {alice_, bob_, carol_},
.flags = kMptDexFlags});
MPTTester gbp(
{.env = env,
.issuer = gw_,
.holders = {alice_, bob_, carol_},
.flags = kMptDexFlags});
env(pay(gw_, alice_, btc(60'000'000)));
env(pay(gw_, bob_, btc(100'000'000)));
env(pay(gw_, bob_, eth(100'000'000)));
env(pay(gw_, bob_, gbp(50'000'000)));
env(pay(gw_, carol_, gbp(1'000'000)));
env.close();
// This is multiplath, which generates limited # of offers
AMM const ammBobBtcEth(env, bob_, btc(50'000'000), eth(50'000'000));
env(offer(bob_, btc(60'000'000), gbp(50'000'000)));
env(offer(carol_, btc(1'000'000'000), gbp(1'000'000)));
env(offer(bob_, gbp(50'000'000), eth(50'000'000)));
// unfund offer
env(pay(bob_, gw_, gbp(50'000'000)));
BEAST_EXPECT(ammBobBtcEth.expectBalances(
btc(50'000'000), eth(50'000'000), ammBobBtcEth.tokens()));
BEAST_EXPECT(isOffer(env, bob_, btc(60'000'000), gbp(50'000'000)));
BEAST_EXPECT(isOffer(env, carol_, btc(1'000'000'000), gbp(1'000'000)));
BEAST_EXPECT(isOffer(env, bob_, gbp(50'000'000), eth(50'000'000)));
auto flowJournal = env.app().getLogs().journal("Flow");
auto const flowResult = [&] {
STAmount const deliver(eth(51'000'000));
STAmount smax(btc(61'000'000));
PaymentSandbox sb(env.current().get(), TapNone);
STPathSet paths;
auto ipe = [](MPTTester const& iss) {
return STPathElement(
STPathElement::TypeMpt | STPathElement::TypeIssuer,
xrpAccount(),
PathAsset{iss.issuanceID()},
iss.issuer());
};
{
// BTC -> ETH
STPath const p1({ipe(eth)});
paths.pushBack(p1);
// BTC -> GBP -> ETH
STPath const p2({ipe(gbp), ipe(eth)});
paths.pushBack(p2);
}
return flow(
sb,
deliver,
alice_,
carol_,
paths,
false,
false,
true,
OfferCrossing::No,
std::nullopt,
smax,
std::nullopt,
flowJournal);
}();
BEAST_EXPECT(flowResult.removableOffers.size() == 1);
env.app().getOpenLedger().modify([&](OpenView& view, beast::Journal j) {
if (flowResult.removableOffers.empty())
return false;
Sandbox sb(&view, TapNone);
for (auto const& o : flowResult.removableOffers)
{
if (auto ok = sb.peek(keylet::offer(o)))
{
offerDelete(sb, ok, flowJournal);
}
}
sb.apply(view);
return true;
});
// used in payment, but since payment failed should be untouched
BEAST_EXPECT(ammBobBtcEth.expectBalances(
btc(50'000'000), eth(50'000'000), ammBobBtcEth.tokens()));
BEAST_EXPECT(isOffer(env, carol_, btc(1'000'000'000), gbp(1'000'000)));
// found unfunded
BEAST_EXPECT(!isOffer(env, bob_, btc(60'000'000), gbp(50'000'000)));
}
{
// Do not produce more in the forward pass than the reverse pass
// This test uses a path that whose reverse pass will compute a
// 500 ETH input required for a 1'000 BTC output. It sets a sendmax
// of 400 ETH, so the payment engine will need to do a forward
// pass. Without limits, the 400 ETH would produce 1'000 BTC in
// the forward pass. This test checks that the payment produces
// 1'000 BTC, as expected.
auto test = [&](auto&& issue1, auto&& issue2) {
Env env(*this);
env.fund(XRP(30'000), alice_, bob_, carol_, gw_);
env.close();
auto const eth = issue1(
{.env = env,
.token = "ETH",
.issuer = gw_,
.holders = {alice_, bob_, carol_},
.limit = 10'000'000});
auto const btc = issue2(
{.env = env,
.token = "BTC",
.issuer = gw_,
.holders = {alice_, bob_, carol_},
.limit = 10'000'000});
env(pay(gw_, alice_, eth(1'000'000)));
env(pay(gw_, bob_, btc(1'000'000)));
env(pay(gw_, bob_, eth(1'000'000)));
env.close();
AMM const ammBob(env, bob_, eth(8'000), XRPAmount{21});
env(offer(bob_, drops(1), btc(1'000'000)), Txflags(tfPassive));
env(pay(alice_, carol_, btc(1'000)),
Path(~XRP, ~btc),
Sendmax(eth(400)),
Txflags(tfNoRippleDirect | tfPartialPayment));
env.require(Balance(carol_, btc(1'000)));
BEAST_EXPECT(ammBob.expectBalances(eth(8400), XRPAmount{20}, ammBob.tokens()));
};
testHelper2TokensMix(test);
}
}
void
testTransferRateNoOwnerFee(FeatureBitset features)
{
testcase("No Owner Fee");
using namespace jtx;
{
// payment via AMM
Env env(*this, features);
env.fund(XRP(1'000), gw_, alice_, bob_, carol_);
MPTTester const gbp(
{.env = env,
.issuer = gw_,
.holders = {alice_, bob_, carol_},
.transferFee = 25'000,
.pay = 1'000'000'000'000'000,
.flags = kMptDexFlags});
MPTTester const btc(
{.env = env,
.issuer = gw_,
.holders = {alice_, bob_, carol_},
.transferFee = 25'000,
.pay = 1'000'000'000'000'000,
.flags = kMptDexFlags});
AMM const amm(env, bob_, gbp(1'000'000'000'000'000), btc(1'000'000'000'000'000));
env(pay(alice_, carol_, btc(100'000'000'000'000)),
Path(~MPT(btc)),
Sendmax(gbp(150'000'000'000'000)),
Txflags(tfNoRippleDirect | tfPartialPayment));
env.close();
// alice buys 107.1428e12BTC with 120e12GBP and pays 25% tr fee on
// 120e12GBP 1,000e12 - 120e12*1.25 = 850e12GBP
env.require(Balance(alice_, gbp(850'000'000'000'000)));
BEAST_EXPECT(amm.expectBalances(
gbp(1'120'000'000'000'000), btc(892'857'142'857'143), amm.tokens()));
// 25% of 85.7142e12BTC is paid in tr fee
// 85.7142e12*1.25 = 107.1428e12BTC
env.require(Balance(carol_, btc(1'085'714'285'714'285)));
}
{
// Payment via offer and AMM
Env env(*this, features);
Account const ed("ed");
env.fund(XRP(1'000), gw_, alice_, bob_, carol_, ed);
MPTTester const gbp(
{.env = env,
.issuer = gw_,
.holders = {alice_, bob_, carol_, ed},
.transferFee = 25'000,
.pay = 1'000'000'000'000'000,
.flags = kMptDexFlags});
MPTTester const btc(
{.env = env,
.issuer = gw_,
.holders = {alice_, bob_, carol_, ed},
.transferFee = 25'000,
.pay = 1'000'000'000'000'000,
.flags = kMptDexFlags});
MPTTester const eth(
{.env = env,
.issuer = gw_,
.holders = {alice_, bob_, carol_, ed},
.transferFee = 25'000,
.pay = 1'000'000'000'000'000,
.flags = kMptDexFlags});
env(offer(ed, gbp(1'000'000'000'000'000), eth(1'000'000'000'000'000)),
Txflags(tfPassive));
env.close();
AMM const amm(env, bob_, eth(1'000'000'000'000'000), btc(1'000'000'000'000'000));
env(pay(alice_, carol_, btc(100'000'000'000'000)),
Path(~MPT(eth), ~MPT(btc)),
Sendmax(gbp(150'000'000'000'000)),
Txflags(tfNoRippleDirect | tfPartialPayment));
env.close();
// alice buys 120e12ETH with 120e12GBP via the offer
// and pays 25% tr fee on 120e12GBP
// 1,000e12 - 120e12*1.25 = 850e12GBP
env.require(Balance(alice_, gbp(850'000'000'000'000)));
// consumed offer is 120e12GBP/120e12ETH
// ed doesn't pay tr fee
env.require(Balance(ed, eth(880'000'000'000'000)));
env.require(Balance(ed, gbp(1'120'000'000'000'000)));
BEAST_EXPECT(expectOffers(
env, ed, 1, {Amounts{gbp(880'000'000'000'000), eth(880'000'000'000'000)}}));
// 25% on 96e12ETH is paid in tr fee 96e12*1.25 = 120e12ETH
// 96e12ETH is swapped in for 87.5912e12BTC
BEAST_EXPECT(amm.expectBalances(
eth(1'096'000'000'000'000), btc(912'408'759'124'088), amm.tokens()));
// 25% on 70.0729e12BTC is paid in tr fee 70.0729e12*1.25
// = 87.5912e12BTC
env.require(Balance(carol_, btc(1'070'072'992'700'729)));
}
{
// Payment via AMM, AMM
Env env(*this, features);
Account const ed("ed");
env.fund(XRP(1'000), gw_, alice_, bob_, carol_, ed);
MPTTester const gbp(
{.env = env,
.issuer = gw_,
.holders = {alice_, bob_, carol_, ed},
.transferFee = 25'000,
.pay = 1'000'000'000'000'000,
.flags = kMptDexFlags});
MPTTester const btc(
{.env = env,
.issuer = gw_,
.holders = {alice_, bob_, carol_, ed},
.transferFee = 25'000,
.pay = 1'000'000'000'000'000,
.flags = kMptDexFlags});
MPTTester const eth(
{.env = env,
.issuer = gw_,
.holders = {alice_, bob_, carol_, ed},
.transferFee = 25'000,
.pay = 1'000'000'000'000'000,
.flags = kMptDexFlags});
AMM const amm1(env, bob_, gbp(1'000'000'000'000'000), eth(1'000'000'000'000'000));
AMM const amm2(env, ed, eth(1'000'000'000'000'000), btc(1'000'000'000'000'000));
env(pay(alice_, carol_, btc(100'000'000'000'000)),
Path(~MPT(eth), ~MPT(btc)),
Sendmax(gbp(150'000'000'000'000)),
Txflags(tfNoRippleDirect | tfPartialPayment));
env.close();
env.require(Balance(alice_, gbp(850'000'000'000'000)));
// alice buys 107.1428e12ETH with 120e12GBP and pays 25% tr fee on
// 120e12GBP 1,000e12 - 120e12*1.25 = 850e12GBP 120e12GBP is swapped
// in for 107.1428e12ETH
BEAST_EXPECT(amm1.expectBalances(
gbp(1'120'000'000'000'000), eth(892'857'142'857'143), amm1.tokens()));
// 25% on 85.7142e12ETH is paid in tr fee 85.7142e12*1.25 =
// 107.1428e12ETH 85.7142e12ETH is swapped in for 78.9473e12BTC
BEAST_EXPECT(amm2.expectBalances(
eth(1'085'714'285'714'285), btc(921'052'631'578'948), amm2.tokens()));
// 25% on 63.1578e12BTC is paid in tr fee 63.1578e12*1.25
// = 78.9473e12BTC
env.require(Balance(carol_, btc(1'063'157'894'736'841)));
}
{
// AMM offer crossing
Env env(*this, features);
env.fund(XRP(1'000), gw_, alice_, bob_);
MPTTester const btc(
{.env = env,
.issuer = gw_,
.holders = {alice_, bob_},
.transferFee = 25'000,
.pay = 1'100'000,
.flags = kMptDexFlags});
MPTTester const eth(
{.env = env,
.issuer = gw_,
.holders = {alice_, bob_},
.transferFee = 25'000,
.pay = 1'100'000,
.flags = kMptDexFlags});
AMM const amm(env, bob_, btc(1'000'000), eth(1'100'000));
env(offer(alice_, eth(100'000), btc(100'000)));
env.close();
// 100e3BTC is swapped in for 100e3ETH
BEAST_EXPECT(amm.expectBalances(btc(1'100'000), eth(1'000'000), amm.tokens()));
// alice pays 25% tr fee on 100e3BTC 1100e3-100e3*1.25 = 975e3BTC
env.require(Balance(alice_, btc(975'000)));
env.require(Balance(alice_, eth(1'200'000)));
BEAST_EXPECT(expectOffers(env, alice_, 0));
}
{
// Payment via AMM with limit quality
Env env(*this, features);
env.fund(XRP(1'000), gw_, alice_, bob_, carol_);
MPTTester const btc(
{.env = env,
.issuer = gw_,
.holders = {alice_, bob_, carol_},
.transferFee = 25'000,
.pay = 1'000'000'000'000'000,
.flags = kMptDexFlags});
MPTTester const gbp(
{.env = env,
.issuer = gw_,
.holders = {alice_, bob_, carol_},
.transferFee = 25'000,
.pay = 1'000'000'000'000'000,
.flags = kMptDexFlags});
AMM const amm(env, bob_, gbp(1'000'000'000'000'000), btc(1'000'000'000'000'000));
// requested quality limit is 100e12BTC/178.58e12GBP = 0.55997
// trade quality is 100e12BTC/178.5714 = 0.55999e12
env(pay(alice_, carol_, btc(100'000'000'000'000)),
Path(~MPT(btc)),
Sendmax(gbp(178'580'000'000'000)),
Txflags(tfNoRippleDirect | tfPartialPayment | tfLimitQuality));
env.close();
// alice buys 125e12BTC with 142.8571e12GBP and pays 25% tr fee
// on 142.8571e12GBP
// 1,000e12 - 142.8571e12*1.25 = 821.4285e12GBP
env.require(Balance(alice_, gbp(821'428'571'428'571)));
// 142.8571e12GBP is swapped in for 125e12BTC
BEAST_EXPECT(amm.expectBalances(
gbp(1'142'857'142'857'143), btc(875'000'000'000'000), amm.tokens()));
// 25% on 100e12BTC is paid in tr fee
// 100e12*1.25 = 125e12BTC
env.require(Balance(carol_, btc(1'100'000'000'000'000)));
}
{
// Payment via AMM with limit quality, deliver less
// than requested
Env env(*this, features);
env.fund(XRP(1'000), gw_, alice_, bob_, carol_);
MPTTester const btc(
{.env = env,
.issuer = gw_,
.holders = {alice_, bob_, carol_},
.transferFee = 25'000,
.pay = 1'200'000'000'000'000,
.flags = kMptDexFlags});
MPTTester const gbp(
{.env = env,
.issuer = gw_,
.holders = {alice_, bob_, carol_},
.transferFee = 25'000,
.pay = 1'200'000'000'000'000,
.flags = kMptDexFlags});
AMM const amm(env, bob_, gbp(1'000'000'000'000'000), btc(1'200'000'000'000'000));
// requested quality limit is 90e12BTC/120e12GBP = 0.75
// trade quality is 22.5e12BTC/30e12GBP = 0.75
env(pay(alice_, carol_, btc(90'000'000'000'000)),
Path(~MPT(btc)),
Sendmax(gbp(120'000'000'000'000)),
Txflags(tfNoRippleDirect | tfPartialPayment | tfLimitQuality));
env.close();
// alice buys 28.125e12BTC with 24e12GBP and pays 25% tr fee
// on 24e12GBP
// 1,200e12 - 24e12*1.25 =~ 1,170e12GBP
env.require(Balance(alice_, gbp(1'170'000'000'000'000)));
// 24e12GBP is swapped in for 28.125e12BTC
BEAST_EXPECT(amm.expectBalances(
gbp(1'024'000'000'000'000), btc(1'171'875'000'000'000), amm.tokens()));
// 25% on 22.5e12BTC is paid in tr fee
// 22.5*1.25 = 28.125e12BTC
env.require(Balance(carol_, btc(1'222'500'000'000'000)));
}
{
// Payment via offer and AMM with limit quality, deliver less
// than requested
Env env(*this, features);
Account const ed("ed");
env.fund(XRP(1'000), gw_, alice_, bob_, carol_, ed);
MPTTester const btc(
{.env = env,
.issuer = gw_,
.holders = {alice_, bob_, carol_, ed},
.transferFee = 25'000,
.pay = 1'400'000'000'000'000,
.flags = kMptDexFlags});
MPTTester const gbp(
{.env = env,
.issuer = gw_,
.holders = {alice_, bob_, carol_, ed},
.transferFee = 25'000,
.pay = 1'400'000'000'000'000,
.flags = kMptDexFlags});
MPTTester const eth(
{.env = env,
.issuer = gw_,
.holders = {alice_, bob_, carol_, ed},
.transferFee = 25'000,
.pay = 1'400'000'000'000'000,
.flags = kMptDexFlags});
env(offer(ed, gbp(1'000'000'000'000'000), eth(1'000'000'000'000'000)),
Txflags(tfPassive));
env.close();
AMM const amm(env, bob_, eth(1'000'000'000'000'000), btc(1'400'000'000'000'000));
// requested quality limit is 95e12BTC/140e12GBP = 0.6785
// trade quality is 59.7321e12BTC/88.0262e12GBP = 0.6785
env(pay(alice_, carol_, btc(95'000'000'000'000)),
Path(~MPT(eth), ~MPT(btc)),
Sendmax(gbp(140'000'000'000'000)),
Txflags(tfNoRippleDirect | tfPartialPayment | tfLimitQuality));
env.close();
// alice buys 70.4210e12ETH with 70.4210e12GBP via the offer
// and pays 25% tr fee on 70.4210e12GBP
// 1,400e12 - 70.4210e12*1.25 = 1400e12 - 88.0262e12 =
// 1311.9736e12GBP
env.require(Balance(alice_, gbp(1'311'973'684'210'525)));
// ed doesn't pay tr fee, the balances reflect consumed offer
// 70.4210e12GBP/70.4210e12ETH
env.require(Balance(ed, eth(1'329'578'947'368'420)));
env.require(Balance(ed, gbp(1'470'421'052'631'580)));
BEAST_EXPECT(expectOffers(
env, ed, 1, {Amounts{gbp(929'578'947'368'420), eth(929'578'947'368'420)}}));
// 25% on 56.3368e12ETH is paid in tr fee 56.3368e12*1.25
// = 70.4210e12ETH 56.3368e12ETH is swapped in for 74.6651e12BTC
BEAST_EXPECT(amm.expectBalances(
eth(1'056'336'842'105'264), btc(1'325'334'821'428'571), amm.tokens()));
// 25% on 59.7321e12BTC is paid in tr fee 59.7321e12*1.25
// = 74.6651e12BTC
env.require(Balance(carol_, btc(1'459'732'142'857'143)));
}
{
// Payment via AMM and offer with limit quality, deliver less
// than requested
Env env(*this, features);
Account const ed("ed");
env.fund(XRP(1'000), gw_, alice_, bob_, carol_, ed);
MPTTester const btc(
{.env = env,
.issuer = gw_,
.holders = {alice_, bob_, carol_, ed},
.transferFee = 25'000,
.pay = 1'400'000'000'000'000,
.flags = kMptDexFlags});
MPTTester const gbp(
{.env = env,
.issuer = gw_,
.holders = {alice_, bob_, carol_, ed},
.transferFee = 25'000,
.pay = 1'400'000'000'000'000,
.flags = kMptDexFlags});
MPTTester const eth(
{.env = env,
.issuer = gw_,
.holders = {alice_, bob_, carol_, ed},
.transferFee = 25'000,
.pay = 1'400'000'000'000'000,
.flags = kMptDexFlags});
AMM const amm(env, bob_, gbp(1'000'000'000'000'000), eth(1'000'000'000'000'000));
env(offer(ed, eth(1'000'000'000'000'000), btc(1'400'000'000'000'000)),
Txflags(tfPassive));
env.close();
// requested quality limit is 95e12BTC/140e12GBP = 0.6785
// trade quality is 47.7857e12BTC/70.4210e12GBP = 0.6785
env(pay(alice_, carol_, btc(95'000'000'000'000)),
Path(~MPT(eth), ~MPT(btc)),
Sendmax(gbp(140'000'000'000'000)),
Txflags(tfNoRippleDirect | tfPartialPayment | tfLimitQuality));
env.close();
// alice buys 53.3322e12ETH with 56.3368e12GBP via the amm
// and pays 25% tr fee on 56.3368e12GBP
// 1,400e12 - 56.3368e12*1.25 = 1400e12 - 70.4210e12 =
// 1329.5789e12GBP
env.require(Balance(alice_, gbp(1'329'578'947'368'420)));
//// 25% on 56.3368e12ETH is paid in tr fee 56.3368e12*1.25
///= 70.4210e12ETH
// 56.3368e12GBP is swapped in for 53.3322e12ETH
BEAST_EXPECT(amm.expectBalances(
gbp(1'056'336'842'105'264), eth(946'667'729'591'836), amm.tokens()));
// 25% on 42.6658e12ETH is paid in tr fee 42.6658e12*1.25
// = 53.3322e12ETH 42.6658e12ETH/59.7321e12BTC
env.require(Balance(ed, btc(1'340'267'857'142'857)));
env.require(Balance(ed, eth(1'442'665'816'326'531)));
BEAST_EXPECT(expectOffers(
env, ed, 1, {Amounts{eth(957'334'183'673'469), btc(1'340'267'857'142'857)}}));
// 25% on 47.7857e12BTC is paid in tr fee 47.7857e12*1.25
// = 59.7321e12BTC
env.require(Balance(carol_, btc(1'447'785714285714)));
}
{
// Payment via AMM, AMM with limit quality, deliver less
// than requested
Env env(*this, features);
Account const ed("ed");
env.fund(XRP(1'000), gw_, alice_, bob_, carol_, ed);
MPTTester const btc(
{.env = env,
.issuer = gw_,
.holders = {alice_, bob_, carol_, ed},
.transferFee = 25'000,
.pay = 1'400'000'000'000'000,
.flags = kMptDexFlags});
MPTTester const gbp(
{.env = env,
.issuer = gw_,
.holders = {alice_, bob_, carol_, ed},
.transferFee = 25'000,
.pay = 1'400'000'000'000'000,
.flags = kMptDexFlags});
MPTTester const eth(
{.env = env,
.issuer = gw_,
.holders = {alice_, bob_, carol_, ed},
.transferFee = 25'000,
.pay = 1'400'000'000'000'000,
.flags = kMptDexFlags});
AMM const amm1(env, bob_, gbp(1'000'000'000'000'000), eth(1'000'000'000'000'000));
AMM const amm2(env, ed, eth(1'000'000'000'000'000), btc(1'400'000'000'000'000));
// requested quality limit is 90e12BTC/145e12GBP = 0.6206
// trade quality is 66.7432e12BTC/107.5308e12GBP = 0.6206
env(pay(alice_, carol_, btc(90'000'000'000'000)),
Path(~MPT(eth), ~MPT(btc)),
Sendmax(gbp(145'000'000'000'000)),
Txflags(tfNoRippleDirect | tfPartialPayment | tfLimitQuality));
env.close();
// alice buys 53.3322e12ETH with 107.5308e12GBP
// 25% on 86.0246e12GBP is paid in tr fee
// 1,400e12 - 86.0246e12*1.25 = 1400e12 - 107.5308e12 =
// 1229.4691e12GBP
env.require(Balance(alice_, gbp(1'292'469'135'802'465)));
// 86.0246e12GBP is swapped in for 79.2106e12ETH
BEAST_EXPECT(amm1.expectBalances(
gbp(1'086'024'691'358'028), eth(920'789'377'955'618), amm1.tokens()));
// 25% on 63.3684e12ETH is paid in tr fee 63.3684e12*1.25
// = 79.2106e12ETH 63.3684e12ETH is swapped in for 83.4291e12BTC
BEAST_EXPECT(amm2.expectBalances(
eth(1'063'368'497'635'505), btc(1'316'570'881'226'053), amm2.tokens()));
// 25% on 66.7432e12BTC is paid in tr fee 66.7432e12*1.25
// = 83.4291e12BTC
env.require(Balance(carol_, btc(1'466'743'295'019'157)));
}
{
// Payment by the issuer via AMM, AMM with limit quality,
// deliver less than requested
Env env(*this, features);
env.fund(XRP(1'000), gw_, alice_, bob_, carol_);
MPTTester const btc(
{.env = env,
.issuer = gw_,
.holders = {alice_, bob_, carol_},
.transferFee = 25'000,
.pay = 1'400'000'000'000'000,
.flags = kMptDexFlags});
MPTTester const gbp(
{.env = env,
.issuer = gw_,
.holders = {alice_, bob_, carol_},
.transferFee = 25'000,
.pay = 1'400'000'000'000'000,
.flags = kMptDexFlags});
MPTTester const eth(
{.env = env,
.issuer = gw_,
.holders = {alice_, bob_, carol_},
.transferFee = 25'000,
.pay = 1'400'000'000'000'000,
.flags = kMptDexFlags});
AMM const amm1(env, alice_, gbp(1'000'000'000'000'000), eth(1'000'000'000'000'000));
AMM const amm2(env, bob_, eth(1'000'000'000'000'000), btc(1'400'000'000'000'000));
// requested quality limit is 90e12BTC/120e12GBP = 0.75
// trade quality is 81.1111e12BTC/108.1481e12GBP = 0.75
env(pay(gw_, carol_, btc(90'000'000'000'000)),
Path(~MPT(eth), ~MPT(btc)),
Sendmax(gbp(120'000'000'000'000)),
Txflags(tfNoRippleDirect | tfPartialPayment | tfLimitQuality));
env.close();
// 108.1481e12GBP is swapped in for 97.5935e12ETH
BEAST_EXPECT(amm1.expectBalances(
gbp(1'108'148'148'148'150), eth(902'406'417'112'298), amm1.tokens()));
// 25% on 78.0748e12ETH is paid in tr fee 78.0748e12*1.25
// = 97.5935e12ETH 78.0748e12ETH is swapped in for 101.3888e12BTC
BEAST_EXPECT(amm2.expectBalances(
eth(1'078'074'866'310'161), btc(1'298'611'111'111'111), amm2.tokens()));
// 25% on 81.1111e12BTC is paid in tr fee 81.1111e12*1.25 =
// 101.3888e12BTC
env.require(Balance(carol_, btc(1'481'111'111'111'111)));
}
}
void
testLimitQuality()
{
// Single path with amm, offer, and limit quality. The quality limit
// is such that the first offer should be taken but the second
// should not. The total amount delivered should be the sum of the
// two offers and sendMax should be more than the first offer.
testcase("limitQuality");
using namespace jtx;
{
Env env(*this);
env.fund(XRP(10'000), gw_, alice_, bob_, carol_);
MPTTester const eth(
{.env = env,
.issuer = gw_,
.holders = {alice_, bob_, carol_},
.pay = 2'000'000,
.flags = kMptDexFlags});
AMM const ammBob(env, bob_, XRP(1'000), eth(1'050'000));
env(offer(bob_, XRP(100), eth(50'000)));
env(pay(alice_, carol_, eth(100'000)),
Path(~MPT(eth)),
Sendmax(XRP(100)),
Txflags(tfNoRippleDirect | tfPartialPayment | tfLimitQuality));
BEAST_EXPECT(ammBob.expectBalances(XRP(1'050), eth(1'000'000), ammBob.tokens()));
env.require(Balance(carol_, eth(2'050'000)));
BEAST_EXPECT(expectOffers(env, bob_, 1, {{{XRP(100), eth(50'000)}}}));
}
}
void
testXRPPathLoop()
{
testcase("Circular XRP");
using namespace jtx;
// Payment path starting with XRP
{
auto test = [&](auto&& issue1, auto&& issue2) {
Env env(*this);
env.fund(XRP(30'000), alice_, bob_, gw_);
env.close();
auto const eth = issue1(
{.env = env,
.token = "ETH",
.issuer = gw_,
.holders = {alice_, bob_},
.limit = 2000'000});
auto const btc = issue2(
{.env = env,
.token = "BTC",
.issuer = gw_,
.holders = {alice_, bob_},
.limit = 2000'000});
env(pay(gw_, alice_, btc(200'000)));
env(pay(gw_, bob_, btc(200'000)));
env(pay(gw_, alice_, eth(200'000)));
env(pay(gw_, bob_, eth(200'000)));
env.close();
AMM const ammAliceXrpBtc(env, alice_, XRP(100), btc(101'000));
AMM const ammAliceXrpEth(env, alice_, XRP(100), eth(101'000));
env(pay(alice_, bob_, eth(1'000)),
Path(~btc, ~XRP, ~eth),
Sendmax(XRP(1)),
Txflags(tfNoRippleDirect),
Ter(temBAD_PATH_LOOP));
};
testHelper2TokensMix(test);
}
// Payment path ending with XRP
{
auto test = [&](auto&& issue1, auto&& issue2) {
Env env(*this);
env.fund(XRP(30'000), alice_, bob_, gw_);
env.close();
auto const eth = issue1(
{.env = env,
.token = "ETH",
.issuer = gw_,
.holders = {alice_, bob_},
.limit = 2000'000});
auto const btc = issue2(
{.env = env,
.token = "BTC",
.issuer = gw_,
.holders = {alice_, bob_},
.limit = 2000'000});
env(pay(gw_, alice_, btc(200'000)));
env(pay(gw_, bob_, btc(200'000)));
env(pay(gw_, alice_, eth(200'000)));
env(pay(gw_, bob_, eth(200'000)));
env.close();
AMM const ammAliceXrpBtc(env, alice_, XRP(100), btc(100'000));
AMM const ammAliceXrpEth(env, alice_, XRP(100), eth(100'000));
// ETH -> //XRP -> //BTC ->XRP
env(pay(alice_, bob_, XRP(1)),
Path(~XRP, ~btc, ~XRP),
Sendmax(eth(1'000)),
Txflags(tfNoRippleDirect),
Ter(temBAD_PATH_LOOP));
};
testHelper2TokensMix(test);
}
// Payment where loop is formed in the middle of the path, not
// on an endpoint
{
auto test = [&](auto&& issue1, auto&& issue2, auto&& issue3) {
Env env(*this);
env.fund(XRP(10'000), gw_, alice_, bob_);
env.close();
auto const eth = issue1(
{.env = env,
.token = "ETH",
.issuer = gw_,
.holders = {alice_, bob_},
.limit = 2000'000});
auto const btc = issue2(
{.env = env,
.token = "BTC",
.issuer = gw_,
.holders = {alice_, bob_},
.limit = 2000'000});
auto const jpy = issue2(
{.env = env,
.token = "JPY",
.issuer = gw_,
.holders = {alice_, bob_},
.limit = 2000'000});
env(pay(gw_, alice_, btc(200'000)));
env(pay(gw_, bob_, btc(200'000)));
env(pay(gw_, alice_, eth(200'000)));
env(pay(gw_, bob_, eth(200'000)));
env(pay(gw_, alice_, jpy(200'000)));
env(pay(gw_, bob_, jpy(200'000)));
env.close();
AMM const ammAliceXrpBtc(env, alice_, XRP(100), btc(100'000));
AMM const ammAliceXrpEth(env, alice_, XRP(100), eth(100'000));
AMM const ammAliceXrpJpy(env, alice_, XRP(100), jpy(100'000));
env(pay(alice_, bob_, jpy(1'000)),
Path(~XRP, ~eth, ~XRP, ~jpy),
Sendmax(btc(1'000)),
Txflags(tfNoRippleDirect),
Ter(temBAD_PATH_LOOP));
};
testHelper3TokensMix(test);
}
}
void
testStepLimit(FeatureBitset features)
{
testcase("Step Limit");
using namespace jtx;
{
Env env(*this, features);
auto const dan = Account("dan");
auto const ed = Account("ed");
env.fund(XRP(100'000'000), gw_, alice_, bob_, carol_, dan, ed);
MPTTester const btc(
{.env = env, .issuer = gw_, .holders = {bob_, dan, ed}, .flags = kMptDexFlags});
env(pay(gw_, ed, btc(11'000'000'000'000)));
env(pay(gw_, bob_, btc(1'000'000'000'000)));
env(pay(gw_, dan, btc(1'000'000'000'000)));
nOffers(env, 2'000, bob_, XRP(1), btc(1'000'000'000'000));
nOffers(env, 1, dan, XRP(1), btc(1'000'000'000'000));
AMM const ammEd(env, ed, XRP(9), btc(11'000'000'000'000));
// Alice offers to buy 1000 XRP for 1000e12 BTC. She takes Bob's
// first offer, removes 999 more as unfunded, then hits the step
// limit.
env(offer(alice_, btc(1'000'000'000'000'000), XRP(1'000)));
env.require(Balance(alice_, btc(2'050'125'257'867)));
env.require(Owners(alice_, 2));
env.require(Balance(bob_, btc(0)));
env.require(Owners(bob_, 1'001));
env.require(Balance(dan, btc(1'000'000'000'000)));
env.require(Owners(dan, 2));
// Carol offers to buy 1000 XRP for 1000e12 BTC. She removes Bob's
// next 1000 offers as unfunded and hits the step limit.
env(offer(carol_, btc(1'000'000'000'000'000), XRP(1'000)));
env.require(Balance(carol_, MPT(btc)(kNone)));
env.require(Owners(carol_, 1));
env.require(Balance(bob_, btc(0)));
env.require(Owners(bob_, 1));
env.require(Balance(dan, btc(1'000'000'000'000)));
env.require(Owners(dan, 2));
}
// MPT/IOU, similar to the case above
{
Env env(*this, features);
auto const dan = Account("dan");
auto const ed = Account("ed");
env.fund(XRP(100'000), gw_, alice_, bob_, carol_, dan, ed);
env.close();
MPTTester const usd(
{.env = env,
.issuer = gw_,
.holders = {alice_, bob_, carol_, dan, ed},
.pay = 10000'000'000,
.flags = kMptDexFlags});
env.trust(BTC(11'000'000'000'000), ed);
env(pay(gw_, ed, BTC(11'000'000'000'000)));
env.trust(BTC(1'000'000'000'000), bob_);
env(pay(gw_, bob_, BTC(1'000'000'000'000)));
env.trust(BTC(1'000'000'000'000), dan);
env(pay(gw_, dan, BTC(1'000'000'000'000)));
env.close();
nOffers(env, 2'000, bob_, usd(1000000), BTC(1'000'000'000'000));
nOffers(env, 1, dan, usd(1000000), BTC(1'000'000'000'000));
AMM const ammEd(env, ed, usd(9000000), BTC(11'000'000'000'000));
env(offer(alice_, BTC(1'000'000'000'000'000), usd(1'000000000)));
env.require(Balance(alice_, STAmount{BTC, UINT64_C(2050125257867'587), -3}));
env.require(Owners(alice_, 3));
env.require(Balance(bob_, BTC(0)));
env.require(Owners(bob_, 1'002));
env.require(Balance(dan, BTC(1000000000000)));
env.require(Owners(dan, 3));
}
// IOU/MPT, similar to the case above
{
Env env(*this, features);
auto const dan = Account("dan");
auto const ed = Account("ed");
env.fund(XRP(100'000), gw_, alice_, bob_, carol_, dan, ed);
env.close();
env.trust(USD(10000'000'000), alice_);
env(pay(gw_, alice_, USD(10000'000'000)));
env.trust(USD(10000'000'000), bob_);
env(pay(gw_, bob_, USD(10000'000'000)));
env.trust(USD(10000'000'000), carol_);
env(pay(gw_, carol_, USD(10000'000'000)));
env.trust(USD(10000'000'000), dan);
env(pay(gw_, dan, USD(10000'000'000)));
env.trust(USD(10000'000'000), ed);
env(pay(gw_, ed, USD(10000'000'000)));
env.close();
MPTTester const btc(
{.env = env, .issuer = gw_, .holders = {bob_, dan, ed}, .flags = kMptDexFlags});
env(pay(gw_, ed, btc(11'000'000'000'000)));
env(pay(gw_, bob_, btc(1'000'000'000'000)));
env(pay(gw_, dan, btc(1'000'000'000'000)));
env.close();
nOffers(env, 2'000, bob_, USD(1000000), btc(1'000'000'000'000));
nOffers(env, 1, dan, USD(1000000), btc(1'000'000'000'000));
AMM const ammEd(env, ed, USD(9000000), btc(11'000'000'000'000));
env(offer(alice_, btc(1'000'000'000'000'000), USD(1'000000000)));
env.require(Balance(alice_, btc(2050125628933)));
env.require(Owners(alice_, 3));
env.require(Balance(bob_, btc(0)));
env.require(Owners(bob_, 1'002));
env.require(Balance(dan, btc(1000000000000)));
env.require(Owners(dan, 3));
}
// MPT/MPT, similar to the case above
{
Env env(*this, features);
auto const dan = Account("dan");
auto const ed = Account("ed");
env.fund(XRP(100'000), gw_, alice_, bob_, carol_, dan, ed);
env.close();
MPTTester const btc(
{.env = env, .issuer = gw_, .holders = {bob_, dan, ed}, .flags = kMptDexFlags});
MPTTester const usd(
{.env = env,
.issuer = gw_,
.holders = {alice_, bob_, carol_, dan, ed},
.pay = 10000'000'000,
.flags = kMptDexFlags});
env(pay(gw_, ed, btc(11'000'000'000'000)));
env(pay(gw_, bob_, btc(1'000'000'000'000)));
env(pay(gw_, dan, btc(1'000'000'000'000)));
env.close();
nOffers(env, 2'000, bob_, usd(1000000), btc(1'000'000'000'000));
nOffers(env, 1, dan, usd(1000000), btc(1'000'000'000'000));
AMM const ammEd(env, ed, usd(9000000), btc(11'000'000'000'000));
env(offer(alice_, btc(1'000'000'000'000'000), usd(1'000000000)));
env.require(Balance(alice_, btc(2050125257867)));
env.require(Owners(alice_, 3));
env.require(Balance(bob_, btc(0)));
env.require(Owners(bob_, 1'002));
env.require(Balance(dan, btc(1000000000000)));
env.require(Owners(dan, 3));
}
}
void
testConvertAllOfAnAsset(FeatureBitset features)
{
testcase("Convert all of an asset using DeliverMin");
using namespace jtx;
{
Env env(*this, features);
fund(env, gw_, {alice_, bob_, carol_}, XRP(10'000));
MPTTester const btc(
{.env = env,
.issuer = gw_,
.holders = {alice_, bob_, carol_},
.flags = kMptDexFlags});
env(pay(alice_, bob_, btc(10'000)), DeliverMin(btc(10'000)), Ter(temBAD_AMOUNT));
env(pay(alice_, bob_, btc(10'000)),
DeliverMin(btc(-5'000)),
Txflags(tfPartialPayment),
Ter(temBAD_AMOUNT));
env(pay(alice_, bob_, btc(10'000)),
DeliverMin(XRP(5)),
Txflags(tfPartialPayment),
Ter(temBAD_AMOUNT));
env(pay(alice_, bob_, btc(10'000)),
DeliverMin(btc(5'000)),
Txflags(tfPartialPayment),
Ter(tecPATH_DRY));
env(pay(alice_, bob_, btc(10'000)),
DeliverMin(btc(15'000)),
Txflags(tfPartialPayment),
Ter(temBAD_AMOUNT));
env(pay(gw_, carol_, btc(50'000)));
AMM const ammCarol(env, carol_, XRP(10), btc(15'000));
env(pay(alice_, bob_, btc(10'000)),
Paths(XRP),
DeliverMin(btc(7'000)),
Txflags(tfPartialPayment),
Sendmax(XRP(5)),
Ter(tecPATH_PARTIAL));
env.require(
Balance(alice_, drops(10'000'000'000 - (3 * env.current()->fees().base.drops()))));
env.require(Balance(bob_, drops(10'000'000'000 - env.current()->fees().base.drops())));
}
{
Env env(*this, features);
fund(env, gw_, {alice_, bob_}, XRP(10'000));
MPTTester const btc(
{.env = env, .issuer = gw_, .holders = {alice_, bob_}, .flags = kMptDexFlags});
env(pay(gw_, bob_, btc(1'100'000)));
AMM const ammBob(env, bob_, XRP(1'000), btc(1'100'000));
env(pay(alice_, alice_, btc(10'000'000)),
Paths(XRP),
DeliverMin(btc(100'000)),
Txflags(tfPartialPayment),
Sendmax(XRP(100)));
env.require(Balance(alice_, btc(100'000)));
}
// IOU/MPT mix, similar to the above case
{
auto test = [&](auto&& issue1, auto&& issue2) {
Env env(*this);
env.fund(XRP(30'000), alice_, bob_, carol_, gw_);
env.close();
auto const usd = issue1(
{.env = env,
.token = "USD",
.issuer = gw_,
.holders = {alice_, bob_, carol_},
.limit = 3000'000});
auto const btc = issue2(
{.env = env,
.token = "BTC",
.issuer = gw_,
.holders = {alice_, bob_, carol_},
.limit = 1'000'000});
env(pay(gw_, alice_, usd(10'000)));
env(pay(gw_, bob_, usd(10'000)));
env(pay(gw_, bob_, btc(1'200)));
env.close();
AMM const ammBob(env, bob_, usd(1'000), btc(1'100));
env(pay(alice_, alice_, btc(10'000)),
Paths(usd),
DeliverMin(btc(100)),
Txflags(tfPartialPayment),
Sendmax(usd(100)));
env.require(Balance(alice_, btc(100)));
};
testHelper2TokensMix(test);
}
{
Env env(*this, features);
fund(env, gw_, {alice_, bob_, carol_}, XRP(10'000));
MPTTester const btc(
{.env = env, .issuer = gw_, .holders = {bob_, carol_}, .flags = kMptDexFlags});
env(pay(gw_, bob_, btc(1'200'000)));
AMM const ammBob(env, bob_, XRP(5'500), btc(1'200'000));
env(pay(alice_, carol_, btc(10'000'000)),
Paths(XRP),
DeliverMin(btc(200'000)),
Txflags(tfPartialPayment),
Sendmax(XRP(1'000)),
Ter(tecPATH_PARTIAL));
env(pay(alice_, carol_, btc(10'000'000)),
Paths(XRP),
DeliverMin(btc(200'000)),
Txflags(tfPartialPayment),
Sendmax(XRP(1'100)));
BEAST_EXPECT(ammBob.expectBalances(XRP(6'600), btc(1'000'000), ammBob.tokens()));
env.require(Balance(carol_, btc(200'000)));
}
// IOU/MPT mix, similar to the above case
{
auto test = [&](auto&& issue1, auto&& issue2) {
Env env(*this);
env.fund(XRP(30'000), alice_, bob_, carol_, gw_);
env.close();
auto const usd = issue1(
{.env = env,
.token = "USD",
.issuer = gw_,
.holders = {alice_, bob_, carol_},
.limit = 3000'000});
auto const btc = issue2(
{.env = env,
.token = "BTC",
.issuer = gw_,
.holders = {alice_, bob_, carol_},
.limit = 1'000'000});
env(pay(gw_, alice_, usd(100'000)));
env(pay(gw_, bob_, usd(100'000)));
env(pay(gw_, carol_, usd(100'000)));
env(pay(gw_, bob_, btc(1'200)));
env.close();
AMM const ammBob(env, bob_, usd(5'500), btc(1'200));
env(pay(alice_, carol_, btc(10'000)),
Paths(usd),
DeliverMin(btc(200)),
Txflags(tfPartialPayment),
Sendmax(usd(1'000)),
Ter(tecPATH_PARTIAL));
env(pay(alice_, carol_, btc(10'000)),
Paths(usd),
DeliverMin(btc(200)),
Txflags(tfPartialPayment),
Sendmax(usd(1'100)));
BEAST_EXPECT(ammBob.expectBalances(usd(6'600), btc(1'000), ammBob.tokens()));
env.require(Balance(carol_, btc(200)));
};
testHelper2TokensMix(test);
}
{
auto const dan = Account("dan");
Env env(*this, features);
fund(env, gw_, {alice_, bob_, carol_, dan}, XRP(10'000));
MPTTester const btc(
{.env = env, .issuer = gw_, .holders = {bob_, carol_, dan}, .flags = kMptDexFlags});
env(pay(gw_, bob_, btc(100'000'000)));
env(pay(gw_, dan, btc(1'100'000'000)));
env(offer(bob_, XRP(100), btc(100'000'000)));
env(offer(bob_, XRP(1'000), btc(100'000'000)));
AMM const ammDan(env, dan, XRP(1'000), btc(1'100'000'000));
env(pay(alice_, carol_, btc(10'000'000'000)),
Paths(XRP),
DeliverMin(btc(200'000'000)),
Txflags(tfPartialPayment),
Sendmax(XRPAmount(200'000'001)));
env.require(Balance(bob_, btc(0)));
env.require(Balance(carol_, btc(200'000'000)));
BEAST_EXPECT(
ammDan.expectBalances(XRPAmount{1'100'000'001}, btc(1000'000000), ammDan.tokens()));
}
}
void
testPayment(FeatureBitset features)
{
testcase("Payment");
using namespace jtx;
Account const becky{"becky"};
Env env(*this, features);
fund(env, gw_, {alice_, becky}, XRP(5'000));
MPTTester const btc(
{.env = env, .issuer = gw_, .holders = {alice_, becky}, .flags = kMptDexFlags});
env(pay(gw_, alice_, btc(500'000)));
env.close();
AMM const ammAlice(env, alice_, XRP(100), btc(140'000));
// becky pays herself BTC (10'000) by consuming part of alice's offer.
// Make sure the payment works if PaymentAuth is not involved.
env(pay(becky, becky, btc(10'000)), Path(~MPT(btc)), Sendmax(XRP(10)));
env.close();
BEAST_EXPECT(
ammAlice.expectBalances(XRPAmount(107'692'308), btc(130'000), ammAlice.tokens()));
// becky decides to require authorization for deposits.
env(fset(becky, asfDepositAuth));
env.close();
// becky pays herself again.
env(pay(becky, becky, btc(10'000)), Path(~MPT(btc)), Sendmax(XRP(10)), Ter(tesSUCCESS));
env.close();
}
void
testPayMPT()
{
// Exercise MPT payments and non-direct XRP payments to an account
// that has the lsfDepositAuth flag set.
testcase("Pay MPT");
using namespace jtx;
Env env(*this);
fund(env, gw_, {alice_, bob_, carol_}, XRP(10'000));
MPTTester btc(
{.env = env, .issuer = gw_, .holders = {alice_, bob_, carol_}, .flags = kMptDexFlags});
env(pay(gw_, alice_, btc(150'000)));
env(pay(gw_, carol_, btc(150'000)));
AMM const ammCarol(env, carol_, btc(100'000), XRPAmount(101));
env(pay(alice_, bob_, btc(50'000)));
env.close();
// bob sets the lsfDepositAuth flag.
env(fset(bob_, asfDepositAuth), Require(Flags(bob_, asfDepositAuth)));
env.close();
// None of the following payments should succeed.
auto failedMptPayments = [this, &env, &btc]() {
env.require(Flags(bob_, asfDepositAuth));
// Capture bob's balances before hand to confirm they don't
// change.
PrettyAmount const bobXrpBalance{env.balance(bob_, XRP)};
PrettyAmount const bobBTCBalance{env.balance(bob_, MPT(btc))};
env(pay(alice_, bob_, btc(50'000)), Ter(tecNO_PERMISSION));
env.close();
// Note that even though alice is paying bob in XRP, the payment
// is still not allowed since the payment passes through an
// offer.
env(pay(alice_, bob_, drops(1)), Sendmax(btc(1'000)), Ter(tecNO_PERMISSION));
env.close();
BEAST_EXPECT(bobXrpBalance == env.balance(bob_, XRP));
BEAST_EXPECT(bobBTCBalance == env.balance(bob_, MPT(btc)));
};
// Test when bob has an XRP balance > base reserve.
failedMptPayments();
// Set bob's XRP balance == base reserve. Also demonstrate that
// bob can make payments while his lsfDepositAuth flag is set.
env(pay(bob_, alice_, btc(25'000)));
env.close();
{
STAmount const bobPaysXRP{env.balance(bob_, XRP) - reserve(env, 1)};
XRPAmount const bobPaysFee{reserve(env, 1) - reserve(env, 0)};
env(pay(bob_, alice_, bobPaysXRP), Fee(bobPaysFee));
env.close();
}
// Test when bob's XRP balance == base reserve.
BEAST_EXPECT(env.balance(bob_, XRP) == reserve(env, 0));
BEAST_EXPECT(env.balance(bob_, MPT(btc)) == btc(25'000));
failedMptPayments();
// Test when bob has an XRP balance == 0.
env(noop(bob_), Fee(reserve(env, 0)));
env.close();
BEAST_EXPECT(env.balance(bob_, XRP) == XRP(0));
failedMptPayments();
// Give bob enough XRP for the fee to clear the lsfDepositAuth flag.
env(pay(alice_, bob_, drops(env.current()->fees().base)));
// bob clears the lsfDepositAuth and the next payment succeeds.
env(fclear(bob_, asfDepositAuth));
env.close();
env(pay(alice_, bob_, btc(50'000)));
env.close();
env(pay(alice_, bob_, drops(1)), Sendmax(btc(1'000)));
env.close();
BEAST_EXPECT(ammCarol.expectBalances(btc(101'000), XRPAmount(100), ammCarol.tokens()));
}
void
testIndividualLock(FeatureBitset features)
{
testcase("Individual Lock");
using namespace test::jtx;
Env env(*this, features);
Account const g1{"G1"};
Account const alice{"alice"};
Account const bob{"bob"};
env.fund(XRP(1'000), g1, alice, bob);
MPTTester btc(
{.env = env,
.issuer = g1,
.holders = {alice, bob},
.flags = tfMPTCanLock | kMptDexFlags});
env(pay(g1, bob, btc(10)));
env(pay(g1, alice, btc(205)));
env.close();
AMM const ammAlice(env, alice, XRP(500), btc(105));
env.require(Balance(bob, btc(10)));
env.require(Balance(alice, btc(100)));
// Account with MPT unlocked (proving operations normally work)
// can make Payment
env(pay(alice, bob, btc(1)));
// can receive Payment
env(pay(bob, alice, btc(1)));
env.close();
// Lock MPT for bob
btc.set({.holder = bob, .flags = tfMPTLock});
{
// different from IOU. The offer is created but not crossed.
env(offer(bob, btc(5), XRP(25)));
env.close();
BEAST_EXPECT(expectOffers(env, bob, 1, {{{btc(5), XRP(25)}}}));
BEAST_EXPECT(ammAlice.expectBalances(XRP(500), btc(105), ammAlice.tokens()));
}
{
// can not sell assets
env(offer(bob, XRP(1), btc(5)), Ter(tecUNFUNDED_OFFER));
// different from IOU
// can not receive Payment when locked
env(pay(alice, bob, btc(1)), Ter(tecPATH_DRY));
// can not make Payment when locked
env(pay(bob, alice, btc(1)), Ter(tecPATH_DRY));
env.require(Balance(bob, btc(10)));
}
{
// Unlock
btc.set({.holder = bob, .flags = tfMPTUnlock});
env(offer(bob, XRP(1), btc(5)));
env(pay(bob, alice, btc(1)));
env(pay(alice, bob, btc(1)));
env.close();
}
}
void
testGlobalLock(FeatureBitset features)
{
testcase("Global Lock");
using namespace test::jtx;
Env env(*this, features);
Account const g1{"G1"};
Account a1{"A1"};
Account a2{"A2"};
Account a3{"A3"};
Account a4{"A4"};
env.fund(XRP(12'000), g1);
env.fund(XRP(1'000), a1);
env.fund(XRP(20'000), a2, a3, a4);
MPTTester const eth(
{.env = env,
.issuer = g1,
.holders = {a1, a2, a3, a4},
.flags = tfMPTCanLock | kMptDexFlags});
MPTTester btc(
{.env = env,
.issuer = g1,
.holders = {a1, a2, a3, a4},
.flags = tfMPTCanLock | kMptDexFlags});
env(pay(g1, a1, eth(1'000)));
env(pay(g1, a2, eth(100)));
env(pay(g1, a3, btc(100)));
env(pay(g1, a4, btc(100)));
env.close();
AMM const ammG1(env, g1, XRP(10'000), eth(100));
env(offer(a1, XRP(10'000), eth(100)), Txflags(tfPassive));
env(offer(a2, eth(100), XRP(10'000)), Txflags(tfPassive));
env.close();
{
// Account without Global Lock (proving operations normally
// work)
// visible offers where taker_pays is unlocked issuer
auto offers = getAccountOffers(env, a2)[jss::offers];
if (!BEAST_EXPECT(checkArraySize(offers, 1u)))
return;
// visible offers where taker_gets is unlocked issuer
offers = getAccountOffers(env, a1)[jss::offers];
if (!BEAST_EXPECT(checkArraySize(offers, 1u)))
return;
}
{
// Offers/Payments
// assets can be bought on the market
AMM ammA3(env, a3, btc(1), XRP(1));
// assets can be sold on the market
// AMM is bidirectional
env(pay(g1, a2, eth(1)));
env(pay(a2, g1, eth(1)));
env(pay(a2, a1, eth(1)));
env(pay(a1, a2, eth(1)));
ammA3.withdrawAll(std::nullopt);
}
{
// Account with Global Lock
// set Global Lock first
btc.set({.flags = tfMPTLock});
// assets can't be bought on the market
AMM const ammA3(env, a3, btc(1), XRP(1), Ter(tecFROZEN));
// direct issues can be sent
env(pay(g1, a2, btc(1)));
env(pay(a2, g1, btc(1)));
// locked
env(pay(a2, a1, btc(1)), Ter(tecPATH_DRY));
env(pay(a1, a2, btc(1)), Ter(tecPATH_DRY));
}
{
auto offers = getAccountOffers(env, a2)[jss::offers];
if (!BEAST_EXPECT(checkArraySize(offers, 1u)))
return;
offers = getAccountOffers(env, a1)[jss::offers];
if (!BEAST_EXPECT(checkArraySize(offers, 1u)))
return;
}
}
void
testOffersWhenLocked(FeatureBitset features)
{
testcase("Offers for Locked MPTs");
using namespace test::jtx;
Env env(*this, features);
Account const g1{"G1"};
Account a2{"A2"};
Account a3{"A3"};
Account a4{"A4"};
env.fund(XRP(2'000), g1, a3, a4);
env.fund(XRP(2'000), a2);
env.close();
MPTTester btc(
{.env = env,
.issuer = g1,
.holders = {a2, a3, a4},
.flags = tfMPTCanLock | kMptDexFlags});
env(pay(g1, a3, btc(2'000)));
env(pay(g1, a4, btc(2'001)));
env.close();
AMM const ammA3(env, a3, XRP(1'000), btc(1'001));
// removal after successful payment
// test: make a payment with partially consuming offer
env(pay(a2, g1, btc(1)), Paths(MPT(btc)), Sendmax(XRP(1)));
env.close();
BEAST_EXPECT(ammA3.expectBalances(XRP(1'001), btc(1'000), ammA3.tokens()));
// test: someone else creates an offer providing liquidity
env(offer(a4, XRP(999), btc(999)));
env.close();
// The offer consumes AMM offer
BEAST_EXPECT(ammA3.expectBalances(XRP(1'000), btc(1'001), ammA3.tokens()));
// test: AMM is Locked
btc.set({.holder = ammA3.ammAccount(), .flags = tfMPTLock});
auto const info = ammA3.ammRpcInfo();
BEAST_EXPECT(info[jss::amm][jss::asset2_frozen].asBool());
env.close();
// test: Can make a payment via the new offer
env(pay(a2, g1, btc(1)), Paths(MPT(btc)), Sendmax(XRP(1)));
env.close();
// AMM is not consumed
BEAST_EXPECT(ammA3.expectBalances(XRP(1'000), btc(1'001), ammA3.tokens()));
// removal buy successful OfferCreate
// test: lock the new offer
btc.set({.holder = a4, .flags = tfMPTUnlock});
env.close();
// test: can no longer create a crossing offer
env(offer(a2, btc(999), XRP(999)));
env.close();
// test: offer was removed by offer_create
auto offers = getAccountOffers(env, a4)[jss::offers];
if (!BEAST_EXPECT(checkArraySize(offers, 0u)))
return;
}
void
testTxMultisign(FeatureBitset features)
{
testcase("Multisign AMM Transactions");
using namespace jtx;
Env env{*this, features};
Account const bogie{"bogie", KeyType::Secp256k1};
Account const alice{"alice", KeyType::Secp256k1};
Account const becky{"becky", KeyType::Ed25519};
Account const zelda{"zelda", KeyType::Secp256k1};
fund(env, gw_, {alice, becky, zelda}, XRP(20'000));
MPTTester const btc(
{.env = env,
.issuer = gw_,
.holders = {alice, becky, zelda},
.pay = 20'000'000'000,
.flags = kMptDexFlags});
// alice uses a regular key with the master disabled.
Account const alie{"alie", KeyType::Secp256k1};
env(regkey(alice, alie));
env(fset(alice, asfDisableMaster), Sig(alice));
// Attach signers to alice.
env(signers(alice, 2, {{becky, 1}, {bogie, 1}}), Sig(alie));
env.close();
static constexpr int kSignerListOwners{2};
env.require(Owners(alice, kSignerListOwners + 0));
Msig const ms{becky, bogie};
// Multisign all AMM transactions
AMM ammAlice(
env,
alice,
XRP(10'000),
btc(10'000),
false,
0,
ammCrtFee(env).drops(),
std::nullopt,
std::nullopt,
ms,
Ter(tesSUCCESS));
BEAST_EXPECT(ammAlice.expectBalances(XRP(10'000), btc(10'000), ammAlice.tokens()));
ammAlice.deposit(alice, 1'000'000);
BEAST_EXPECT(ammAlice.expectBalances(XRP(11'000), btc(11'000), IOUAmount{11'000'000, 0}));
ammAlice.withdraw(alice, 1'000'000);
BEAST_EXPECT(ammAlice.expectBalances(XRP(10'000), btc(10'000), ammAlice.tokens()));
ammAlice.vote({}, 1'000);
BEAST_EXPECT(ammAlice.expectTradingFee(1'000));
env(ammAlice.bid({.account = alice, .bidMin = 100}), ms).close();
BEAST_EXPECT(ammAlice.expectAuctionSlot(100, 0, IOUAmount{4'000}));
// 4000 tokens burnt
BEAST_EXPECT(ammAlice.expectBalances(XRP(10'000), btc(10'000), IOUAmount{9'996'000, 0}));
}
void
testToStrand(FeatureBitset features)
{
testcase("To Strand");
using namespace jtx;
// cannot have more than one offer with the same output issue
{
auto test = [&](auto&& issue1, auto&& issue2) {
Env env(*this);
env.fund(XRP(30'000), alice_, bob_, carol_, gw_);
env.close();
auto const eth = issue1(
{.env = env,
.token = "ETH",
.issuer = gw_,
.holders = {alice_, bob_, carol_},
.limit = 1'000'000});
auto const btc = issue2(
{.env = env,
.token = "BTC",
.issuer = gw_,
.holders = {alice_, bob_, carol_},
.limit = 1'000'000});
env(pay(gw_, alice_, btc(50000)));
env(pay(gw_, bob_, btc(50000)));
env(pay(gw_, carol_, btc(50000)));
env(pay(gw_, alice_, eth(50000)));
env(pay(gw_, bob_, eth(50000)));
env(pay(gw_, carol_, eth(50000)));
env.close();
AMM const bobXrpBtc(env, bob_, XRP(1'000), btc(1'000));
AMM const bobBtcEth(env, bob_, btc(1'000), eth(1'000));
// payment path: XRP -> XRP/BTC -> BTC/ETH -> ETH/BTC
env(pay(alice_, carol_, btc(100)),
Path(~btc, ~eth, ~btc),
Sendmax(XRP(200)),
Txflags(tfNoRippleDirect),
Ter(temBAD_PATH_LOOP));
};
testHelper2TokensMix(test);
}
}
void
testRIPD1373(FeatureBitset features)
{
using namespace jtx;
testcase("RIPD1373");
{
Env env(*this, features);
fund(env, gw_, {alice_, bob_}, XRP(10'000));
MPTTester btc(
{.env = env,
.issuer = bob_,
.holders = {alice_, gw_},
.pay = 100'000'000,
.flags = kMptDexFlags});
MPTTester eth(
{.env = env,
.issuer = bob_,
.holders = {alice_, gw_},
.pay = 100'000'000,
.flags = kMptDexFlags});
AMM const ammXrpBtc(env, bob_, XRP(100), btc(100'000));
env(offer(gw_, XRP(100), btc(100'000)), Txflags(tfPassive));
AMM const ammBtcEth(env, bob_, btc(100'000), eth(100'000));
env(offer(gw_, btc(100'000), eth(100'000)), Txflags(tfPassive));
TestPath const p = [&] {
TestPath result;
result.pushBack(allPathElements(gw_, MPT(btc)));
result.pushBack(cpe(eth.issuanceID()));
return result;
}();
PathSet const paths(p);
env(pay(alice_, alice_, eth(1'000)),
Json(paths.json()),
Sendmax(XRP(10)),
Txflags(tfNoRippleDirect | tfPartialPayment),
Ter(temBAD_PATH));
}
{
Env env(*this, features);
fund(env, gw_, {alice_, bob_, carol_}, XRP(10'000));
MPTTester const btc(
{.env = env,
.issuer = gw_,
.holders = {alice_, bob_, carol_},
.pay = 100'000,
.flags = kMptDexFlags});
AMM const ammBob(env, bob_, XRP(100), btc(100));
// payment path: XRP -> XRP/BTC -> BTC/XRP
env(pay(alice_, carol_, XRP(100)),
Path(~MPT(btc), ~XRP),
Txflags(tfNoRippleDirect),
Ter(temBAD_SEND_XRP_PATHS));
}
{
Env env(*this, features);
fund(env, gw_, {alice_, bob_, carol_}, XRP(10'000));
MPTTester const btc(
{.env = env,
.issuer = gw_,
.holders = {alice_, bob_, carol_},
.pay = 100'000,
.flags = kMptDexFlags});
AMM const ammBob(env, bob_, XRP(100), btc(100));
// payment path: XRP -> XRP/BTC -> BTC/XRP
env(pay(alice_, carol_, XRP(100)),
Path(~MPT(btc), ~XRP),
Sendmax(XRP(200)),
Txflags(tfNoRippleDirect),
Ter(temBAD_SEND_XRP_MAX));
}
}
void
testLoop(FeatureBitset features)
{
testcase("test loop");
using namespace jtx;
{
Env env(*this, features);
env.fund(XRP(10'000), alice_, bob_, carol_, gw_);
MPTTester const btc(
{.env = env,
.issuer = gw_,
.holders = {alice_, bob_, carol_},
.flags = kMptDexFlags});
env(pay(gw_, bob_, btc(100'000'000)));
env(pay(gw_, alice_, btc(100'000'000)));
env.close();
AMM const ammBob(env, bob_, XRP(100), btc(100'000'000));
// payment path: BTC -> BTC/XRP -> XRP/BTC
env(pay(alice_, carol_, btc(100'000'000)),
Sendmax(btc(100'000'000)),
Path(~XRP, ~MPT(btc)),
Txflags(tfNoRippleDirect),
Ter(temBAD_PATH_LOOP));
}
{
auto test = [&](auto&& issue1, auto&& issue2, auto&& issue3) {
Env env(*this, features);
env.fund(XRP(10'000), alice_, bob_, carol_, gw_);
env.close();
auto const btc = issue1(
{.env = env, .token = "BTC", .issuer = gw_, .holders = {alice_, bob_, carol_}});
auto const eth = issue2(
{.env = env, .token = "ETH", .issuer = gw_, .holders = {alice_, bob_, carol_}});
auto const cny = issue3(
{.env = env, .token = "CNY", .issuer = gw_, .holders = {alice_, bob_, carol_}});
env(pay(gw_, bob_, btc(200)));
env(pay(gw_, bob_, eth(200)));
env(pay(gw_, bob_, cny(100)));
env.close();
AMM const ammBobXrpBtc(env, bob_, XRP(100), btc(100));
AMM const ammBobBtcEth(env, bob_, btc(100), eth(100));
AMM const ammBobEthCny(env, bob_, eth(100), cny(100));
// payment path: XRP->XRP/BTC->BTC/ETH->BTC/CNY
env(pay(alice_, carol_, cny(100)),
Sendmax(XRP(100)),
Path(~btc, ~eth, ~btc, ~cny),
Txflags(tfNoRippleDirect),
Ter(temBAD_PATH_LOOP));
};
testHelper3TokensMix(test);
}
}
void
testPaths()
{
pathFindConsumeAll();
viaOffersViaGateway();
receiveMax();
pathFind01();
pathFind02();
pathFind06();
}
void
testFlow()
{
using namespace jtx;
FeatureBitset const all{testableAmendments()};
testFalseDry(all);
testBookStep(all);
testTransferRateNoOwnerFee(all);
testLimitQuality();
testXRPPathLoop();
}
void
testCrossingLimits()
{
using namespace jtx;
FeatureBitset const all{testableAmendments()};
testStepLimit(all);
}
void
testDeliverMin()
{
using namespace jtx;
FeatureBitset const all{testableAmendments()};
testConvertAllOfAnAsset(all);
}
void
testDepositAuth()
{
auto const supported{jtx::testableAmendments()};
testPayment(supported);
testPayMPT();
}
void
testLock()
{
using namespace test::jtx;
auto const sa = testableAmendments();
testIndividualLock(sa);
testGlobalLock(sa);
testOffersWhenLocked(sa);
}
void
testMultisign()
{
using namespace jtx;
auto const all = testableAmendments();
testTxMultisign(all);
}
void
testPayStrand()
{
using namespace jtx;
auto const all = testableAmendments();
testToStrand(all);
testRIPD1373(all);
testLoop(all);
}
void
run() override
{
testOffers();
testPaths();
testFlow();
testCrossingLimits();
testDeliverMin();
testDepositAuth();
testLock();
testMultisign();
testPayStrand();
}
};
BEAST_DEFINE_TESTSUITE_PRIO(AMMExtendedMPT, app, xrpl, 1);
} // namespace xrpl::test
Reference in New Issue View Git Blame Copy Permalink