mirror of
https://github.com/XRPLF/rippled.git
synced 2026-04-29 15:37:57 +00:00
2150 lines
83 KiB
C++
2150 lines
83 KiB
C++
#include <test/jtx/Account.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/mpt.h>
|
|
#include <test/jtx/owners.h>
|
|
#include <test/jtx/paths.h>
|
|
#include <test/jtx/pay.h>
|
|
#include <test/jtx/sendmax.h>
|
|
#include <test/jtx/ter.h>
|
|
#include <test/jtx/trust.h>
|
|
#include <test/jtx/txflags.h>
|
|
|
|
#include <xrpl/basics/base_uint.h>
|
|
#include <xrpl/beast/unit_test/suite.h>
|
|
#include <xrpl/core/ServiceRegistry.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/DirectoryHelpers.h>
|
|
#include <xrpl/ledger/helpers/OfferHelpers.h>
|
|
#include <xrpl/protocol/AccountID.h>
|
|
#include <xrpl/protocol/Asset.h>
|
|
#include <xrpl/protocol/Feature.h>
|
|
#include <xrpl/protocol/Keylet.h>
|
|
#include <xrpl/protocol/LedgerFormats.h>
|
|
#include <xrpl/protocol/SField.h>
|
|
#include <xrpl/protocol/STAmount.h>
|
|
#include <xrpl/protocol/STPathSet.h>
|
|
#include <xrpl/protocol/TER.h>
|
|
#include <xrpl/protocol/TxFlags.h>
|
|
#include <xrpl/protocol/XRPAmount.h>
|
|
#include <xrpl/tx/paths/Flow.h>
|
|
#include <xrpl/tx/paths/detail/Steps.h>
|
|
|
|
#include <cstdint>
|
|
#include <memory>
|
|
#include <optional>
|
|
#include <string>
|
|
#include <type_traits>
|
|
#include <vector>
|
|
|
|
namespace xrpl::test {
|
|
|
|
struct FlowMPT_test : public beast::unit_test::suite
|
|
{
|
|
using Accounts = std::vector<jtx::Account>;
|
|
|
|
void
|
|
testDirectStep(FeatureBitset features)
|
|
{
|
|
testcase("Direct Step");
|
|
|
|
using namespace jtx;
|
|
auto const alice = Account("alice");
|
|
auto const bob = Account("bob");
|
|
auto const carol = Account("carol");
|
|
auto const gw = Account("gw");
|
|
{
|
|
// Pay USD, trivial path
|
|
Env env(*this, features);
|
|
|
|
env.fund(XRP(10000), alice, bob, gw);
|
|
MPT const USD = MPTTester({.env = env, .issuer = gw, .holders = {alice, bob}});
|
|
env(pay(gw, alice, USD(100)));
|
|
env(pay(alice, bob, USD(10)), paths(USD));
|
|
env.require(balance(bob, USD(10)));
|
|
}
|
|
{
|
|
// Partial payments
|
|
Env env(*this, features);
|
|
|
|
env.fund(XRP(10000), alice, bob, gw);
|
|
MPT const USD = MPTTester({.env = env, .issuer = gw, .holders = {alice, bob}});
|
|
env(pay(gw, alice, USD(100)));
|
|
env(pay(alice, bob, USD(110)), paths(USD), ter(tecPATH_PARTIAL));
|
|
env.require(balance(bob, USD(0)));
|
|
env(pay(alice, bob, USD(110)), paths(USD), txflags(tfPartialPayment));
|
|
env.require(balance(bob, USD(100)));
|
|
}
|
|
|
|
{
|
|
// Limit quality
|
|
auto test = [&](auto&& issue1, auto&& issue2) {
|
|
Env env(*this, features);
|
|
|
|
env.fund(XRP(10'000), gw, alice, bob, carol);
|
|
env.close();
|
|
|
|
auto const USD =
|
|
issue1({.env = env, .token = "USD", .issuer = gw, .holders = {alice, carol}});
|
|
auto const EUR =
|
|
issue2({.env = env, .token = "EUR", .issuer = gw, .holders = {bob}});
|
|
|
|
env(pay(gw, alice, USD(100)));
|
|
env(pay(gw, bob, EUR(100)));
|
|
|
|
env(offer(alice, EUR(4), USD(4)));
|
|
env.close();
|
|
|
|
env(pay(bob, carol, USD(5)),
|
|
sendmax(EUR(4)),
|
|
txflags(tfLimitQuality | tfPartialPayment),
|
|
ter(tecPATH_DRY));
|
|
env.require(balance(carol, USD(0)));
|
|
|
|
env(pay(bob, carol, USD(5)), sendmax(EUR(4)), txflags(tfPartialPayment));
|
|
env.require(balance(carol, USD(4)));
|
|
};
|
|
testHelper2TokensMix(test);
|
|
}
|
|
}
|
|
|
|
void
|
|
testBookStep(FeatureBitset features)
|
|
{
|
|
testcase("Book Step");
|
|
|
|
using namespace jtx;
|
|
|
|
auto const gw = Account("gateway");
|
|
Account const alice("alice");
|
|
Account const bob("bob");
|
|
Account const carol("carol");
|
|
|
|
{
|
|
// simple [MPT|IOU]/[IOU|MPT] offer
|
|
auto test = [&](auto&& issue1, auto&& issue2) {
|
|
Env env(*this, features);
|
|
|
|
env.fund(XRP(10'000), alice, bob, carol, gw);
|
|
env.close();
|
|
|
|
auto const USD = issue1(
|
|
{.env = env, .token = "USD", .issuer = gw, .holders = {alice, bob, carol}});
|
|
auto const BTC = issue2(
|
|
{.env = env, .token = "BTC", .issuer = gw, .holders = {alice, bob, carol}});
|
|
|
|
env(pay(gw, alice, BTC(50)));
|
|
env(pay(gw, bob, USD(50)));
|
|
|
|
env(offer(bob, BTC(50), USD(50)));
|
|
|
|
env(pay(alice, carol, USD(50)), path(~USD), sendmax(BTC(50)));
|
|
|
|
env.require(balance(alice, BTC(0)));
|
|
env.require(balance(bob, BTC(50)));
|
|
env.require(balance(bob, USD(0)));
|
|
env.require(balance(carol, USD(50)));
|
|
BEAST_EXPECT(!isOffer(env, bob, BTC(50), USD(50)));
|
|
};
|
|
testHelper2TokensMix(test);
|
|
}
|
|
{
|
|
// simple [MPT|IOU]/XRP XRP/[IOU|MPT] offer
|
|
auto test = [&](auto&& issue1, auto&& issue2) {
|
|
Env env(*this, features);
|
|
|
|
env.fund(XRP(10'000), alice, bob, carol, gw);
|
|
env.close();
|
|
|
|
auto const USD = issue1(
|
|
{.env = env, .token = "USD", .issuer = gw, .holders = {alice, bob, carol}});
|
|
auto const BTC = issue2(
|
|
{.env = env, .token = "BTC", .issuer = gw, .holders = {alice, bob, carol}});
|
|
|
|
env(pay(gw, alice, BTC(50)));
|
|
env(pay(gw, bob, USD(50)));
|
|
|
|
env(offer(bob, BTC(50), XRP(50)));
|
|
env(offer(bob, XRP(50), USD(50)));
|
|
|
|
env(pay(alice, carol, USD(50)), path(~XRP, ~USD), sendmax(BTC(50)));
|
|
|
|
env.require(balance(alice, BTC(0)));
|
|
env.require(balance(bob, BTC(50)));
|
|
env.require(balance(bob, USD(0)));
|
|
env.require(balance(carol, USD(50)));
|
|
BEAST_EXPECT(!isOffer(env, bob, XRP(50), USD(50)));
|
|
BEAST_EXPECT(!isOffer(env, bob, BTC(50), XRP(50)));
|
|
};
|
|
testHelper2TokensMix(test);
|
|
}
|
|
{
|
|
// simple XRP -> USD through offer and sendmax
|
|
Env env(*this, features);
|
|
|
|
env.fund(XRP(10'000), alice, bob, carol, gw);
|
|
env.close();
|
|
|
|
MPT const USD = MPTTester({.env = env, .issuer = gw, .holders = {alice, bob, carol}});
|
|
MPT const BTC = MPTTester({.env = env, .issuer = gw, .holders = {alice, bob, carol}});
|
|
|
|
env(pay(gw, bob, USD(50)));
|
|
|
|
env(offer(bob, XRP(50), USD(50)));
|
|
|
|
env(pay(alice, carol, USD(50)), path(~USD), sendmax(XRP(50)));
|
|
|
|
// fee: MPTokenAuthorize * 2(EUR, USD) + pay
|
|
env.require(balance(alice, XRP(10'000 - 50) - txfee(env, 3)));
|
|
// fee: MPTokenAuthorize * 2(EUR, USD) + offer
|
|
env.require(balance(bob, XRP(10'000 + 50) - txfee(env, 3)));
|
|
env.require(balance(bob, USD(0)));
|
|
env.require(balance(carol, USD(50)));
|
|
BEAST_EXPECT(!isOffer(env, bob, XRP(50), USD(50)));
|
|
}
|
|
{
|
|
// simple USD -> XRP through offer and sendmax
|
|
Env env(*this, features);
|
|
|
|
env.fund(XRP(10'000), alice, bob, carol, gw);
|
|
env.close();
|
|
|
|
MPT const USD = MPTTester({.env = env, .issuer = gw, .holders = {alice, bob, carol}});
|
|
MPT const BTC = MPTTester({.env = env, .issuer = gw, .holders = {alice, bob, carol}});
|
|
|
|
env(pay(gw, alice, USD(50)));
|
|
|
|
env(offer(bob, USD(50), XRP(50)));
|
|
|
|
env(pay(alice, carol, XRP(50)), path(~XRP), sendmax(USD(50)));
|
|
|
|
env.require(balance(alice, USD(0)));
|
|
env.require(balance(bob, XRP(10'000 - 50) - txfee(env, 3)));
|
|
env.require(balance(bob, USD(50)));
|
|
env.require(balance(carol, XRP(10'000 + 50) - txfee(env, 2)));
|
|
BEAST_EXPECT(!isOffer(env, bob, USD(50), XRP(50)));
|
|
}
|
|
{
|
|
// 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 USD = issue1(
|
|
{.env = env, .token = "USD", .issuer = gw, .holders = {alice, bob, carol}});
|
|
auto const BTC = issue2(
|
|
{.env = env, .token = "BTC", .issuer = gw, .holders = {alice, bob, carol}});
|
|
auto const EUR = issue3(
|
|
{.env = env, .token = "EUR", .issuer = gw, .holders = {alice, bob, carol}});
|
|
|
|
env(pay(gw, alice, BTC(60)));
|
|
env(pay(gw, bob, USD(50)));
|
|
env(pay(gw, bob, EUR(50)));
|
|
|
|
env(offer(bob, BTC(50), USD(50)));
|
|
env(offer(bob, BTC(40), EUR(50)));
|
|
env(offer(bob, EUR(50), USD(50)));
|
|
|
|
// unfund offer
|
|
env(pay(bob, gw, EUR(50)));
|
|
env.require(balance(bob, EUR(0)));
|
|
BEAST_EXPECT(isOffer(env, bob, BTC(50), USD(50)));
|
|
BEAST_EXPECT(isOffer(env, bob, BTC(40), EUR(50)));
|
|
BEAST_EXPECT(isOffer(env, bob, EUR(50), USD(50)));
|
|
|
|
env(pay(alice, carol, USD(50)), path(~USD), path(~EUR, ~USD), sendmax(BTC(60)));
|
|
|
|
env.require(balance(alice, BTC(10)));
|
|
env.require(balance(bob, BTC(50)));
|
|
env.require(balance(bob, USD(0)));
|
|
env.require(balance(bob, EUR(0)));
|
|
env.require(balance(carol, USD(50)));
|
|
// used in the payment
|
|
BEAST_EXPECT(!isOffer(env, bob, BTC(50), USD(50)));
|
|
// found unfunded
|
|
BEAST_EXPECT(!isOffer(env, bob, BTC(40), EUR(50)));
|
|
// unfunded, but should not yet be found unfunded
|
|
BEAST_EXPECT(isOffer(env, bob, EUR(50), USD(50)));
|
|
};
|
|
testHelper3TokensMix(test);
|
|
}
|
|
{
|
|
// test unfunded offers are returned when the payment fails.
|
|
// bob makes two offers: a funded 5000 USD for 50 BTC and an
|
|
// unfunded 5000 EUR for 60 BTC. alice pays carol 6100 USD with 61
|
|
// BTC. alice only has 60 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.
|
|
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 USD = issue1(
|
|
{.env = env,
|
|
.token = "USD",
|
|
.issuer = gw,
|
|
.holders = {alice, bob, carol},
|
|
.limit = 100'000});
|
|
auto const BTC = issue2(
|
|
{.env = env,
|
|
.token = "BTC",
|
|
.issuer = gw,
|
|
.holders = {alice, bob, carol},
|
|
.limit = 100'000});
|
|
auto const EUR = issue3(
|
|
{.env = env,
|
|
.token = "EUR",
|
|
.issuer = gw,
|
|
.holders = {alice, bob, carol},
|
|
.limit = 100'000});
|
|
|
|
env(pay(gw, alice, BTC(60)));
|
|
env(pay(gw, bob, USD(6'000)));
|
|
env(pay(gw, bob, EUR(5'000)));
|
|
env(pay(gw, carol, EUR(100)));
|
|
|
|
env(offer(bob, BTC(50), USD(5'000)));
|
|
env(offer(bob, BTC(60), EUR(5'000)));
|
|
env(offer(carol, BTC(1'000), EUR(100)));
|
|
env(offer(bob, EUR(5'000), USD(5'000)));
|
|
|
|
// unfund offer
|
|
env(pay(bob, gw, EUR(5'000)));
|
|
BEAST_EXPECT(isOffer(env, bob, BTC(50), USD(5'000)));
|
|
BEAST_EXPECT(isOffer(env, bob, BTC(60), EUR(5'000)));
|
|
BEAST_EXPECT(isOffer(env, carol, BTC(1'000), EUR(100)));
|
|
|
|
auto flowJournal = env.app().getLogs().journal("Flow");
|
|
auto const flowResult = [&] {
|
|
STAmount const deliver(USD(5'100));
|
|
STAmount smax(BTC(61));
|
|
PaymentSandbox sb(env.current().get(), tapNONE);
|
|
STPathSet paths;
|
|
auto IPE = [](Asset const& asset) {
|
|
return STPathElement(
|
|
STPathElement::typeAsset | STPathElement::typeIssuer,
|
|
xrpAccount(),
|
|
asset,
|
|
asset.getIssuer());
|
|
};
|
|
{
|
|
// BTC -> USD
|
|
STPath const p1({IPE(USD)});
|
|
paths.push_back(p1);
|
|
// BTC -> EUR -> USD
|
|
STPath const p2({IPE(EUR), IPE(USD)});
|
|
paths.push_back(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(isOffer(env, bob, BTC(50), USD(5'000)));
|
|
BEAST_EXPECT(isOffer(env, carol, BTC(1'000), EUR(100)));
|
|
// found unfunded
|
|
BEAST_EXPECT(!isOffer(env, bob, BTC(60), EUR(5'000)));
|
|
};
|
|
testHelper3TokensMix(test);
|
|
}
|
|
{
|
|
// Do not produce more in the forward pass than the
|
|
// reverse pass. This test uses a path whose reverse
|
|
// pass will compute a 0.5 USD input required for a 1
|
|
// EUR output. It sets a sendmax of 0.4 USD, so the
|
|
// payment engine will need to do a forward pass.
|
|
// Without limits, the 0.4 USD would produce 1000 EUR in
|
|
// the forward pass. This test checks that the payment
|
|
// produces 1 EUR, as expected.
|
|
auto test = [&](auto&& issue1, auto&& issue2) {
|
|
Env env(*this, features);
|
|
env.fund(XRP(10'000), alice, bob, carol, gw);
|
|
|
|
auto const USD = issue1(
|
|
{.env = env, .token = "USD", .issuer = gw, .holders = {alice, bob, carol}});
|
|
auto const EUR = issue1(
|
|
{.env = env, .token = "EUR", .issuer = gw, .holders = {alice, bob, carol}});
|
|
|
|
env(pay(gw, alice, USD(1'000)));
|
|
env(pay(gw, bob, EUR(1'000)));
|
|
|
|
Keylet const bobUsdOffer = keylet::offer(bob, env.seq(bob));
|
|
env(offer(bob, USD(10), drops(2)), txflags(tfPassive));
|
|
env(offer(bob, drops(1), EUR(1'000)), txflags(tfPassive));
|
|
|
|
bool const reducedOffersV2 = features[fixReducedOffersV2];
|
|
|
|
// With reducedOffersV2, it is not allowed to accept
|
|
// less than USD(0.5) of bob's USD offer. If we
|
|
// provide 1 drop for less than USD(0.5), then the
|
|
// remaining fractional offer would block the order
|
|
// book.
|
|
TER const expectedTER = reducedOffersV2 ? TER(tecPATH_DRY) : TER(tesSUCCESS);
|
|
env(pay(alice, carol, EUR(1)),
|
|
path(~XRP, ~EUR),
|
|
sendmax(USD(4)),
|
|
txflags(tfNoRippleDirect | tfPartialPayment),
|
|
ter(expectedTER));
|
|
|
|
if (!reducedOffersV2)
|
|
{
|
|
env.require(balance(carol, EUR(1)));
|
|
env.require(balance(bob, USD(4)));
|
|
env.require(balance(bob, EUR(999)));
|
|
|
|
// Show that bob's USD offer is now a blocker.
|
|
std::shared_ptr<SLE const> const usdOffer = env.le(bobUsdOffer);
|
|
if (BEAST_EXPECT(usdOffer))
|
|
{
|
|
std::uint64_t const bookRate = [&usdOffer]() {
|
|
// Extract the least significant 64
|
|
// bits from the book page. That's
|
|
// where the quality is stored.
|
|
std::string bookDirStr = to_string(usdOffer->at(sfBookDirectory));
|
|
bookDirStr.erase(0, 48);
|
|
return std::stoull(bookDirStr, nullptr, 16);
|
|
}();
|
|
std::uint64_t const actualRate =
|
|
getRate(usdOffer->at(sfTakerGets), usdOffer->at(sfTakerPays));
|
|
|
|
// We expect the actual rate of the offer to
|
|
// be worse (larger) than the rate of the
|
|
// book page holding the offer. This is a
|
|
// defect which is corrected by
|
|
// fixReducedOffersV2.
|
|
BEAST_EXPECT(actualRate > bookRate);
|
|
}
|
|
}
|
|
};
|
|
testHelper2TokensMix(test);
|
|
}
|
|
}
|
|
|
|
void
|
|
testTransferRate(FeatureBitset features)
|
|
{
|
|
testcase("Transfer Rate");
|
|
|
|
using namespace jtx;
|
|
|
|
auto const gw = Account("gateway");
|
|
Account const alice("alice");
|
|
Account const bob("bob");
|
|
Account const carol("carol");
|
|
|
|
{
|
|
// Simple payment through a gateway with a
|
|
// transfer rate
|
|
Env env(*this, features);
|
|
|
|
env.fund(XRP(10000), alice, bob, carol, gw);
|
|
|
|
MPT const USD = MPTTester(
|
|
{.env = env,
|
|
.issuer = gw,
|
|
.holders = {alice, bob, carol},
|
|
.transferFee = 25'000,
|
|
.maxAmt = 1'000});
|
|
|
|
env(pay(gw, alice, USD(50)));
|
|
env.require(balance(alice, USD(50)));
|
|
env(pay(alice, bob, USD(40)), sendmax(USD(50)));
|
|
env.require(balance(bob, USD(40)), balance(alice, USD(0)));
|
|
}
|
|
{
|
|
// transfer rate is not charged when issuer is src or
|
|
// dst
|
|
Env env(*this, features);
|
|
|
|
env.fund(XRP(10'000), alice, bob, carol, gw);
|
|
|
|
MPT const USD = MPTTester(
|
|
{.env = env,
|
|
.issuer = gw,
|
|
.holders = {alice, bob, carol},
|
|
.transferFee = 25'000,
|
|
.maxAmt = 1'000});
|
|
|
|
env(pay(gw, alice, USD(50)));
|
|
env.require(balance(alice, USD(50)));
|
|
env(pay(alice, gw, USD(40)), sendmax(USD(40)));
|
|
env.require(balance(alice, USD(10)));
|
|
}
|
|
{
|
|
// transfer fee on an offer
|
|
Env env(*this, features);
|
|
|
|
env.fund(XRP(10'000), alice, bob, carol, gw);
|
|
|
|
MPT const USD = MPTTester(
|
|
{.env = env,
|
|
.issuer = gw,
|
|
.holders = {alice, bob, carol},
|
|
.transferFee = 25'000,
|
|
.maxAmt = 10'000});
|
|
|
|
// scale by 1
|
|
env(pay(gw, bob, USD(650)));
|
|
|
|
env(offer(bob, XRP(50), USD(500)));
|
|
|
|
env(pay(alice, carol, USD(500)),
|
|
path(~USD),
|
|
sendmax(XRP(50)),
|
|
txflags(tfPartialPayment));
|
|
|
|
// bob pays 25% on 500USD -> 100USD; 400USD goes to carol
|
|
env.require(
|
|
balance(alice, XRP(10'000 - 50) - txfee(env, 2)),
|
|
balance(bob, USD(150)),
|
|
balance(carol, USD(400)));
|
|
}
|
|
{
|
|
// Transfer fee two consecutive offers
|
|
auto test = [&](auto&& issue1, auto&& issue2) {
|
|
Env env(*this, features);
|
|
|
|
env.fund(XRP(10'000), alice, bob, carol, gw);
|
|
env.close();
|
|
|
|
auto const USD = issue1(
|
|
{.env = env,
|
|
.token = "USD",
|
|
.issuer = gw,
|
|
.holders = {alice, bob, carol},
|
|
.limit = 1'000,
|
|
.transferFee = 25'000});
|
|
auto const EUR = issue2(
|
|
{.env = env,
|
|
.token = "EUR",
|
|
.issuer = gw,
|
|
.holders = {alice, bob, carol},
|
|
.limit = 1'000,
|
|
.transferFee = 25'000});
|
|
|
|
env(pay(gw, bob, USD(50)));
|
|
env(pay(gw, bob, EUR(50)));
|
|
|
|
env(offer(bob, XRP(50), USD(50)));
|
|
env(offer(bob, USD(50), EUR(50)));
|
|
|
|
env(pay(alice, carol, EUR(40)),
|
|
path(~USD, ~EUR),
|
|
sendmax(XRP(40)),
|
|
txflags(tfPartialPayment));
|
|
// +1 for fset in helperIssueIOU
|
|
using tEUR = std::decay_t<decltype(EUR)>;
|
|
auto const fee = txfee(env, 3);
|
|
// bob pays 25% on 40USD (40 since sendmax is 40XRP)
|
|
// 8USD goes to gw and 32USD goes back to bob ->
|
|
// bob's USD balance is 42USD. USD/EUR offer is 32USD/32EUR.
|
|
// bob pays 25% on 32EUR -> 7EUR if MPT, 6.4EUR if IOU,
|
|
// therefore carl gets 25EUR if MPT, 25.6EUR if IOU.
|
|
auto const carolEUR = [&]() {
|
|
if constexpr (std::is_same_v<tEUR, IOU>)
|
|
{
|
|
return EUR(25.6);
|
|
}
|
|
else
|
|
{
|
|
return EUR(25);
|
|
}
|
|
}();
|
|
env.require(
|
|
balance(alice, XRP(10'000 - 40) - fee),
|
|
balance(bob, USD(42)),
|
|
balance(bob, EUR(18)),
|
|
balance(carol, carolEUR));
|
|
};
|
|
testHelper2TokensMix(test);
|
|
}
|
|
{
|
|
// Offer where the owner is also the issuer, sender pays
|
|
// fee
|
|
Env env(*this, features);
|
|
|
|
env.fund(XRP(10'000), alice, bob, gw);
|
|
|
|
MPT const USD = MPTTester(
|
|
{.env = env,
|
|
.issuer = gw,
|
|
.holders = {alice, bob},
|
|
.transferFee = 25'000,
|
|
.maxAmt = 1'000});
|
|
|
|
env(offer(gw, XRP(100), USD(100)));
|
|
env(pay(alice, bob, USD(100)), sendmax(XRP(100)), txflags(tfPartialPayment));
|
|
env.require(balance(alice, XRP(10'000 - 100) - txfee(env, 2)), balance(bob, USD(80)));
|
|
}
|
|
{
|
|
// Offer where the owner is also the issuer, sender pays
|
|
// fee
|
|
Env env(*this, features);
|
|
|
|
env.fund(XRP(10'000), alice, bob, gw);
|
|
|
|
MPT const USD = MPTTester(
|
|
{.env = env,
|
|
.issuer = gw,
|
|
.holders = {alice, bob},
|
|
.transferFee = 25'000,
|
|
.maxAmt = 1'000});
|
|
|
|
env(offer(gw, XRP(125), USD(125)));
|
|
env(pay(alice, bob, USD(100)), sendmax(XRP(200)));
|
|
env.require(balance(alice, XRP(10'000 - 125) - txfee(env, 2)), balance(bob, USD(100)));
|
|
}
|
|
}
|
|
|
|
void
|
|
testFalseDry(FeatureBitset features)
|
|
{
|
|
testcase("falseDryChanges");
|
|
|
|
using namespace jtx;
|
|
|
|
auto const gw = Account("gateway");
|
|
Account const alice("alice");
|
|
Account const bob("bob");
|
|
Account const carol("carol");
|
|
|
|
auto test = [&](auto&& issue1, auto&& issue2) {
|
|
Env env(*this, features);
|
|
|
|
env.fund(XRP(10'000), alice, carol, gw);
|
|
env.fund(reserve(env, 5), bob);
|
|
env.close();
|
|
|
|
auto const USD =
|
|
issue1({.env = env, .token = "USD", .issuer = gw, .holders = {alice, carol, bob}});
|
|
auto const EUR =
|
|
issue2({.env = env, .token = "EUR", .issuer = gw, .holders = {alice, carol, bob}});
|
|
|
|
env(pay(gw, alice, EUR(50)));
|
|
env(pay(gw, bob, USD(50)));
|
|
|
|
// 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/USD offer will
|
|
// require two recursive calls to the EUR/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, EUR(50), XRP(50)));
|
|
env(offer(bob, XRP(50), USD(50)));
|
|
|
|
env(pay(alice, carol, USD(1'000'000)),
|
|
path(~XRP, ~USD),
|
|
sendmax(EUR(500)),
|
|
txflags(tfNoRippleDirect | tfPartialPayment));
|
|
|
|
auto const carolUSD = env.balance(carol, USD).value();
|
|
BEAST_EXPECT(carolUSD > USD(0) && carolUSD < USD(50));
|
|
};
|
|
testHelper2TokensMix(test);
|
|
}
|
|
|
|
void
|
|
testLimitQuality()
|
|
{
|
|
// Single path with two offers 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;
|
|
|
|
auto const gw = Account("gateway");
|
|
Account const alice("alice");
|
|
Account const bob("bob");
|
|
Account const carol("carol");
|
|
|
|
{
|
|
Env env(*this);
|
|
|
|
env.fund(XRP(10'000), alice, bob, carol, gw);
|
|
|
|
MPT const USD = MPTTester({.env = env, .issuer = gw, .holders = {alice, bob, carol}});
|
|
|
|
env(pay(gw, bob, USD(100)));
|
|
env(offer(bob, XRP(50), USD(50)));
|
|
env(offer(bob, XRP(100), USD(50)));
|
|
|
|
env(pay(alice, carol, USD(100)),
|
|
path(~USD),
|
|
sendmax(XRP(100)),
|
|
txflags(tfNoRippleDirect | tfPartialPayment | tfLimitQuality));
|
|
|
|
env.require(balance(carol, USD(50)));
|
|
}
|
|
}
|
|
|
|
// Helper function that returns the reserve on an account based on
|
|
// the passed in number of owners.
|
|
static XRPAmount
|
|
reserve(jtx::Env& env, std::uint32_t count)
|
|
{
|
|
return env.current()->fees().accountReserve(count);
|
|
}
|
|
|
|
// Helper function that returns the Offers on an account.
|
|
static std::vector<std::shared_ptr<SLE const>>
|
|
offersOnAccount(jtx::Env& env, jtx::Account account)
|
|
{
|
|
std::vector<std::shared_ptr<SLE const>> result;
|
|
forEachItem(*env.current(), account, [&result](std::shared_ptr<SLE const> const& sle) {
|
|
if (sle->getType() == ltOFFER)
|
|
result.push_back(sle);
|
|
});
|
|
return result;
|
|
}
|
|
|
|
void
|
|
testSelfPayment1(FeatureBitset features)
|
|
{
|
|
testcase("Self-payment 1");
|
|
|
|
// In this test case the new flow code mis-computes the
|
|
// amount of money to move. Fortunately the new code's
|
|
// re-execute check catches the problem and throws out the
|
|
// transaction.
|
|
//
|
|
// The old payment code handles the payment correctly.
|
|
using namespace jtx;
|
|
|
|
auto test = [&](auto&& issue1, auto&& issue2) {
|
|
auto const gw1 = Account("gw1");
|
|
auto const gw2 = Account("gw2");
|
|
auto const alice = Account("alice");
|
|
|
|
Env env(*this, features);
|
|
|
|
env.fund(XRP(1'000'000), gw1, gw2);
|
|
env.close();
|
|
|
|
// The fee that's charged for transactions.
|
|
auto const f = env.current()->fees().base;
|
|
|
|
env.fund(reserve(env, 3) + f * 4, alice);
|
|
env.close();
|
|
|
|
auto const USD = issue1(
|
|
{.env = env, .token = "USD", .issuer = gw1, .holders = {alice}, .limit = 20'000});
|
|
auto const EUR = issue2(
|
|
{.env = env, .token = "EUR", .issuer = gw2, .holders = {alice}, .limit = 20'000});
|
|
|
|
env(pay(gw1, alice, USD(10)));
|
|
env(pay(gw2, alice, EUR(10'000)));
|
|
env.close();
|
|
|
|
env(offer(alice, USD(5'000), EUR(6'000)));
|
|
env.close();
|
|
|
|
env.require(owners(alice, 3));
|
|
env.require(balance(alice, USD(10)));
|
|
env.require(balance(alice, EUR(10'000)));
|
|
|
|
auto aliceOffers = offersOnAccount(env, alice);
|
|
BEAST_EXPECT(aliceOffers.size() == 1);
|
|
for (auto const& offerPtr : aliceOffers)
|
|
{
|
|
auto const offer = *offerPtr;
|
|
BEAST_EXPECT(offer[sfLedgerEntryType] == ltOFFER);
|
|
BEAST_EXPECT(offer[sfTakerGets] == EUR(6'000));
|
|
BEAST_EXPECT(offer[sfTakerPays] == USD(5'000));
|
|
}
|
|
|
|
env(pay(alice, alice, EUR(6'000)), sendmax(USD(5'000)), txflags(tfPartialPayment));
|
|
env.close();
|
|
|
|
env.require(owners(alice, 3));
|
|
env.require(balance(alice, USD(10)));
|
|
env.require(balance(alice, EUR(10'000)));
|
|
aliceOffers = offersOnAccount(env, alice);
|
|
BEAST_EXPECT(aliceOffers.size() == 1);
|
|
for (auto const& offerPtr : aliceOffers)
|
|
{
|
|
auto const offer = *offerPtr;
|
|
BEAST_EXPECT(offer[sfLedgerEntryType] == ltOFFER);
|
|
if constexpr (std::is_same_v<std::decay_t<decltype(EUR)>, IOU>)
|
|
{
|
|
BEAST_EXPECT(offer[sfTakerGets] == EUR(5'988));
|
|
}
|
|
else
|
|
{
|
|
BEAST_EXPECT(offer[sfTakerGets] == EUR(5'989));
|
|
}
|
|
BEAST_EXPECT(offer[sfTakerPays] == USD(4'990));
|
|
}
|
|
};
|
|
testHelper2TokensMix(test);
|
|
}
|
|
|
|
template <typename TGets, typename TPays>
|
|
struct TokenData
|
|
{
|
|
TGets gets;
|
|
TPays pays;
|
|
jtx::PrettyAmount remTakerGets;
|
|
jtx::PrettyAmount remTakerPays;
|
|
};
|
|
|
|
void
|
|
testSelfPayment2(FeatureBitset features)
|
|
{
|
|
testcase("Self-payment 2");
|
|
|
|
using namespace jtx;
|
|
|
|
// This test shows a difference between IOU and MPT
|
|
// self-payment result depending on IOU trustline limit.
|
|
|
|
auto const gw1 = Account("gw1");
|
|
auto const gw2 = Account("gw2");
|
|
auto const alice = Account("alice");
|
|
|
|
auto initMPT = [&](Env& env) {
|
|
MPT const USD =
|
|
MPTTester({.env = env, .issuer = gw1, .holders = {alice}, .maxAmt = 506});
|
|
MPT const EUR =
|
|
MPTTester({.env = env, .issuer = gw2, .holders = {alice}, .maxAmt = 606});
|
|
// Payment's engine last step overflows
|
|
// OutstandingAmount since it doesn't know if the
|
|
// BookStep redeems or not. The BookStep then has 600EUR
|
|
// available. Consequently, the entire offer is crossed.
|
|
// Note remaining takerGets is 541 rather than 540 due to integral
|
|
// rounding. XRP has a similar result.
|
|
return TokenData<MPT, MPT>{
|
|
.gets = EUR, .pays = USD, .remTakerGets = EUR(541), .remTakerPays = USD(450)};
|
|
};
|
|
|
|
auto initXRP = [&](Env& env) {
|
|
MPT const USD =
|
|
MPTTester({.env = env, .issuer = gw1, .holders = {alice}, .maxAmt = 1'000});
|
|
// Payment's engine last step overflows
|
|
// OutstandingAmount since it doesn't know if the
|
|
// BookStep redeems or not. The BookStep then has 600EUR
|
|
// available. Consequently, the entire offer is crossed.
|
|
// Note remaining takerGets is 540.000001 rather than 540 due to
|
|
// integral rounding.
|
|
return TokenData<XRP_t, MPT>{
|
|
.gets = XRP,
|
|
.pays = USD,
|
|
.remTakerGets = XRP(540.000001),
|
|
.remTakerPays = USD(450)};
|
|
};
|
|
|
|
auto initIOU = [&](Env& env) {
|
|
auto const USD = gw1["USD"];
|
|
auto const EUR = gw2["EUR"];
|
|
env(trust(alice, USD(506)));
|
|
env(trust(alice, EUR(606)));
|
|
env.close();
|
|
// Payment's engine last step is limited by alice's
|
|
// trustline - 606. Therefore, only 6EUR is delivered
|
|
// and the offer is partially crossed.
|
|
return TokenData<IOU, IOU>{
|
|
.gets = EUR, .pays = USD, .remTakerGets = EUR(594), .remTakerPays = USD(495)};
|
|
};
|
|
|
|
auto initIOU1 = [&](Env& env) {
|
|
auto const USD = gw1["USD"];
|
|
auto const EUR = gw2["EUR"];
|
|
env(trust(alice, USD(1'000)));
|
|
env(trust(alice, EUR(1'000)));
|
|
env.close();
|
|
// Payment's engine last step is not limited by alice's
|
|
// trustline. Therefore, the entire offer is crossed.
|
|
// This the same result as with MPT.
|
|
return TokenData<IOU, IOU>{
|
|
.gets = EUR, .pays = USD, .remTakerGets = EUR(540), .remTakerPays = USD(450)};
|
|
};
|
|
|
|
auto test = [&](auto&& initToken) {
|
|
Env env(*this, features);
|
|
|
|
env.fund(XRP(2'000), gw1, gw2, alice);
|
|
env.close();
|
|
|
|
auto const f = env.current()->fees().base;
|
|
|
|
auto const tok = initToken(env);
|
|
|
|
auto const& TOK1 = tok.pays;
|
|
auto const& TOK2 = tok.gets;
|
|
bool const isTakerGetsXRP = isXRP(Asset{TOK2});
|
|
std::uint32_t const ownerCnt = isTakerGetsXRP ? 2 : 3;
|
|
|
|
env(pay(gw1, alice, TOK1(500)));
|
|
if (!isTakerGetsXRP)
|
|
env(pay(gw2, alice, TOK2(600)));
|
|
env.close();
|
|
|
|
env(offer(alice, TOK1(500), TOK2(600)));
|
|
env.close();
|
|
|
|
env.require(owners(alice, ownerCnt));
|
|
env.require(balance(alice, TOK1(500)));
|
|
if (isTakerGetsXRP)
|
|
{
|
|
env.require(balance(alice, TOK2(2'000) - 2 * f));
|
|
}
|
|
else
|
|
{
|
|
env.require(balance(alice, TOK2(600)));
|
|
}
|
|
|
|
auto aliceOffers = offersOnAccount(env, alice);
|
|
BEAST_EXPECT(aliceOffers.size() == 1);
|
|
for (auto const& offerPtr : aliceOffers)
|
|
{
|
|
auto const offer = *offerPtr;
|
|
BEAST_EXPECT(offer[sfLedgerEntryType] == ltOFFER);
|
|
BEAST_EXPECT(offer[sfTakerGets] == TOK2(600));
|
|
BEAST_EXPECT(offer[sfTakerPays] == TOK1(500));
|
|
}
|
|
|
|
env(pay(alice, alice, TOK2(60)), sendmax(TOK1(50)), txflags(tfPartialPayment));
|
|
env.close();
|
|
|
|
env.require(owners(alice, ownerCnt));
|
|
env.require(balance(alice, TOK1(500)));
|
|
if (isTakerGetsXRP)
|
|
{
|
|
env.require(balance(alice, TOK2(2'000) - 3 * f));
|
|
}
|
|
else
|
|
{
|
|
env.require(balance(alice, TOK2(600)));
|
|
}
|
|
aliceOffers = offersOnAccount(env, alice);
|
|
BEAST_EXPECT(aliceOffers.size() == 1);
|
|
for (auto const& offerPtr : aliceOffers)
|
|
{
|
|
auto const offer = *offerPtr;
|
|
BEAST_EXPECT(offer[sfLedgerEntryType] == ltOFFER);
|
|
BEAST_EXPECT(offer[sfTakerGets] == tok.remTakerGets);
|
|
BEAST_EXPECT(offer[sfTakerPays] == tok.remTakerPays);
|
|
}
|
|
};
|
|
|
|
test(initXRP);
|
|
test(initMPT);
|
|
test(initIOU);
|
|
test(initIOU1);
|
|
}
|
|
|
|
void
|
|
testSelfFundedXRPEndpoint(bool consumeOffer, FeatureBitset features)
|
|
{
|
|
// Test that the deferred credit table is not bypassed for
|
|
// XRPEndpointSteps. If the account in the first step is
|
|
// sending XRP and that account also owns an offer that
|
|
// receives XRP, it should not be possible for that step to
|
|
// use the XRP received in the offer as part of the payment.
|
|
testcase("Self funded XRPEndpoint");
|
|
|
|
using namespace jtx;
|
|
|
|
Env env(*this, features);
|
|
|
|
auto const alice = Account("alice");
|
|
auto const gw = Account("gw");
|
|
|
|
env.fund(XRP(10'000), alice, gw);
|
|
|
|
MPT const USD = MPTTester({.env = env, .issuer = gw, .holders = {alice}, .maxAmt = 20});
|
|
|
|
env(pay(gw, alice, USD(10)));
|
|
env(offer(alice, XRP(50'000), USD(10)));
|
|
|
|
// Consuming the offer changes the owner count, which could
|
|
// also cause liquidity to decrease in the forward pass
|
|
auto const toSend = consumeOffer ? USD(10) : USD(9);
|
|
env(pay(alice, alice, toSend),
|
|
path(~USD),
|
|
sendmax(XRP(20'000)),
|
|
txflags(tfPartialPayment | tfNoRippleDirect));
|
|
}
|
|
|
|
void
|
|
testUnfundedOffer(FeatureBitset features)
|
|
{
|
|
testcase("Unfunded Offer");
|
|
|
|
using namespace jtx;
|
|
{
|
|
// Test reverse
|
|
Env env(*this, features);
|
|
|
|
auto const alice = Account("alice");
|
|
auto const bob = Account("bob");
|
|
auto const gw = Account("gw");
|
|
|
|
env.fund(XRP(100'000), alice, bob, gw);
|
|
|
|
MPT const USD =
|
|
MPTTester({.env = env, .issuer = gw, .holders = {alice, bob}, .maxAmt = 20E+17});
|
|
|
|
// scale by 17
|
|
STAmount const tinyAmt1{USD, 9'000'000'000'000'000ll, 0, false, STAmount::unchecked{}};
|
|
STAmount const tinyAmt3{USD, 9'000'000'000'000'003ll, 0, false, STAmount::unchecked{}};
|
|
|
|
env(offer(gw, drops(9'000'000'000), tinyAmt3));
|
|
|
|
env(pay(alice, bob, tinyAmt1),
|
|
path(~USD),
|
|
sendmax(drops(9'000'000'000)),
|
|
txflags(tfNoRippleDirect));
|
|
|
|
BEAST_EXPECT(!isOffer(env, gw, XRP(0), USD(0)));
|
|
}
|
|
{
|
|
// Test forward
|
|
Env env(*this, features);
|
|
|
|
auto const alice = Account("alice");
|
|
auto const bob = Account("bob");
|
|
auto const gw = Account("gw");
|
|
|
|
env.fund(XRP(100'000), alice, bob, gw);
|
|
|
|
MPT const USD =
|
|
MPTTester({.env = env, .issuer = gw, .holders = {alice, bob}, .maxAmt = 20E+17});
|
|
|
|
// scale by 17
|
|
STAmount const tinyAmt1{USD, 9'000'000'000'000'000ll, 0, false, STAmount::unchecked{}};
|
|
STAmount const tinyAmt3{USD, 9'000'000'000'000'003ll, 0, false, STAmount::unchecked{}};
|
|
|
|
env(pay(gw, alice, tinyAmt1));
|
|
|
|
env(offer(gw, tinyAmt3, drops(9'000'000'000)));
|
|
env(pay(alice, bob, drops(9'000'000'000)),
|
|
path(~XRP),
|
|
sendmax(USD(static_cast<std::uint64_t>(1E+17))),
|
|
txflags(tfNoRippleDirect));
|
|
|
|
BEAST_EXPECT(!isOffer(env, gw, USD(0), XRP(0)));
|
|
}
|
|
}
|
|
|
|
void
|
|
testReExecuteDirectStep(FeatureBitset features)
|
|
{
|
|
testcase("ReexecuteDirectStep");
|
|
|
|
using namespace jtx;
|
|
Env env(*this, features);
|
|
|
|
auto const alice = Account("alice");
|
|
auto const bob = Account("bob");
|
|
auto const gw = Account("gw");
|
|
|
|
env.fund(XRP(10'000), alice, bob, gw);
|
|
|
|
// scale by 16
|
|
MPT const USD =
|
|
MPTTester({.env = env, .issuer = gw, .holders = {alice, bob}, .maxAmt = 100E+16});
|
|
|
|
env(
|
|
pay(gw,
|
|
alice,
|
|
// 12.55....
|
|
STAmount{USD, std::uint64_t(1255555555555555ull), 2, false}));
|
|
|
|
env(offer(
|
|
gw,
|
|
// 5.0...
|
|
STAmount{USD, std::uint64_t(5000000000000000ull), 1, false},
|
|
XRP(1000)));
|
|
|
|
env(offer(
|
|
gw,
|
|
// .555...
|
|
STAmount{USD, std::uint64_t(5555555555555555ull), 0, false},
|
|
XRP(10)));
|
|
|
|
env(offer(
|
|
gw,
|
|
// 4.44....
|
|
STAmount{USD, std::uint64_t(4444444444444444ull), 1, false},
|
|
XRP(.1)));
|
|
|
|
env(offer(
|
|
alice,
|
|
// 17
|
|
STAmount{USD, std::uint64_t(1700000000000000ull), 0, false},
|
|
XRP(.001)));
|
|
|
|
env(pay(alice, bob, XRP(10'000)),
|
|
path(~XRP),
|
|
sendmax(USD(static_cast<std::uint64_t>(100E+16))),
|
|
txflags(tfPartialPayment | tfNoRippleDirect));
|
|
}
|
|
|
|
void
|
|
testSelfPayLowQualityOffer(FeatureBitset features)
|
|
{
|
|
// The new payment code used to assert if an offer was made
|
|
// for more XRP than the offering account held. This unit
|
|
// test reproduces that failing case.
|
|
testcase("Self crossing low quality offer");
|
|
|
|
using namespace jtx;
|
|
|
|
Env env(*this, features);
|
|
|
|
auto const ann = Account("ann");
|
|
auto const gw = Account("gateway");
|
|
|
|
auto const fee = env.current()->fees().base;
|
|
env.fund(reserve(env, 2) + drops(9999640) + fee, ann);
|
|
env.fund(reserve(env, 2) + fee * 4, gw);
|
|
|
|
// scale by 5
|
|
MPT const CTB = MPTTester(
|
|
{.env = env,
|
|
.issuer = gw,
|
|
.holders = {ann},
|
|
.transferFee = 2'000, // 2%
|
|
.maxAmt = 1'000'000});
|
|
|
|
env(pay(gw, ann, CTB(285'600)));
|
|
env.close();
|
|
|
|
env(offer(ann, drops(365'611'702'030), CTB(571'300)));
|
|
env.close();
|
|
|
|
// This payment caused assert.
|
|
env(pay(ann, ann, CTB(68'700)), sendmax(drops(20'000'000'000)), txflags(tfPartialPayment));
|
|
}
|
|
|
|
void
|
|
testEmptyStrand(FeatureBitset features)
|
|
{
|
|
testcase("Empty Strand");
|
|
using namespace jtx;
|
|
|
|
auto const alice = Account("alice");
|
|
|
|
Env env(*this, features);
|
|
|
|
env.fund(XRP(10000), alice);
|
|
|
|
MPT const USD;
|
|
|
|
env(pay(alice, alice, USD(100)), path(~USD), ter(temBAD_PATH));
|
|
}
|
|
|
|
void
|
|
testXRPPathLoop()
|
|
{
|
|
testcase("Circular XRP");
|
|
|
|
using namespace jtx;
|
|
auto const alice = Account("alice");
|
|
auto const bob = Account("bob");
|
|
auto const gw = Account("gw");
|
|
|
|
{
|
|
// Payment path starting with XRP
|
|
auto test = [&](auto&& issue1, auto&& issue2) {
|
|
Env env(*this);
|
|
env.fund(XRP(10'000), alice, bob, gw);
|
|
|
|
auto const USD =
|
|
issue1({.env = env, .token = "USD", .issuer = gw, .holders = {alice, bob}});
|
|
auto const EUR =
|
|
issue2({.env = env, .token = "EUR", .issuer = gw, .holders = {alice, bob}});
|
|
env(pay(gw, alice, USD(100)));
|
|
env(pay(gw, alice, EUR(100)));
|
|
env.close();
|
|
|
|
env(offer(alice, XRP(100), USD(100)), txflags(tfPassive));
|
|
env(offer(alice, USD(100), XRP(100)), txflags(tfPassive));
|
|
env(offer(alice, XRP(100), EUR(100)), txflags(tfPassive));
|
|
env.close();
|
|
|
|
TER const expectedTer = TER{temBAD_PATH_LOOP};
|
|
env(pay(alice, bob, EUR(1)),
|
|
path(~USD, ~XRP, ~EUR),
|
|
sendmax(XRP(1)),
|
|
txflags(tfNoRippleDirect),
|
|
ter(expectedTer));
|
|
};
|
|
testHelper2TokensMix(test);
|
|
}
|
|
{
|
|
// Payment path ending with XRP
|
|
auto test = [&](auto&& issue1, auto&& issue2) {
|
|
Env env(*this);
|
|
env.fund(XRP(10'000), alice, bob, gw);
|
|
auto const USD =
|
|
issue1({.env = env, .token = "USD", .issuer = gw, .holders = {alice, bob}});
|
|
auto const EUR =
|
|
issue2({.env = env, .token = "EUR", .issuer = gw, .holders = {alice, bob}});
|
|
env(pay(gw, alice, USD(100)));
|
|
env(pay(gw, alice, EUR(100)));
|
|
env.close();
|
|
|
|
env(offer(alice, XRP(100), USD(100)), txflags(tfPassive));
|
|
env(offer(alice, EUR(100), XRP(100)), txflags(tfPassive));
|
|
env.close();
|
|
// EUR -> //XRP -> //USD ->XRP
|
|
env(pay(alice, bob, XRP(1)),
|
|
path(~XRP, ~USD, ~XRP),
|
|
sendmax(EUR(1)),
|
|
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), alice, bob, gw);
|
|
env.close();
|
|
auto const USD =
|
|
issue1({.env = env, .token = "USD", .issuer = gw, .holders = {alice, bob}});
|
|
auto const EUR =
|
|
issue2({.env = env, .token = "EUR", .issuer = gw, .holders = {alice, bob}});
|
|
auto const JPY =
|
|
issue3({.env = env, .token = "JPY", .issuer = gw, .holders = {alice, bob}});
|
|
env(pay(gw, alice, USD(100)));
|
|
env(pay(gw, alice, EUR(100)));
|
|
env(pay(gw, alice, JPY(100)));
|
|
env.close();
|
|
|
|
env(offer(alice, USD(100), XRP(100)), txflags(tfPassive));
|
|
env(offer(alice, XRP(100), EUR(100)), txflags(tfPassive));
|
|
env(offer(alice, EUR(100), XRP(100)), txflags(tfPassive));
|
|
env(offer(alice, XRP(100), JPY(100)), txflags(tfPassive));
|
|
env.close();
|
|
|
|
env(pay(alice, bob, JPY(1)),
|
|
path(~XRP, ~EUR, ~XRP, ~JPY),
|
|
sendmax(USD(1)),
|
|
txflags(tfNoRippleDirect),
|
|
ter(temBAD_PATH_LOOP));
|
|
};
|
|
testHelper3TokensMix(test);
|
|
}
|
|
}
|
|
|
|
void
|
|
testMaxAndSelfPaymentEdgeCases(FeatureBitset features)
|
|
{
|
|
testcase("Max Flow/Self Payment Edge Cases");
|
|
using namespace jtx;
|
|
Account const gw("gw");
|
|
Account const alice("alice");
|
|
Account const carol("carol");
|
|
Account const bob("bob");
|
|
|
|
// Direct payment between holders.
|
|
{
|
|
Env env(*this);
|
|
|
|
env.fund(XRP(1'000), gw, alice, carol);
|
|
|
|
MPT const USD =
|
|
MPTTester({.env = env, .issuer = gw, .holders = {alice, carol}, .maxAmt = 100});
|
|
|
|
env(pay(gw, alice, USD(100)));
|
|
|
|
env(pay(alice, carol, USD(100)));
|
|
|
|
BEAST_EXPECT(env.balance(gw, USD) == USD(-100));
|
|
BEAST_EXPECT(env.balance(carol, USD) == USD(100));
|
|
BEAST_EXPECT(env.balance(alice, USD) == USD(0));
|
|
}
|
|
|
|
// Direct payment between holders. Partial payment limited
|
|
// by holder funds.
|
|
{
|
|
Env env(*this);
|
|
|
|
env.fund(XRP(1'000), gw, alice, carol);
|
|
|
|
MPT const USD =
|
|
MPTTester({.env = env, .issuer = gw, .holders = {alice, carol}, .maxAmt = 100});
|
|
|
|
env(pay(gw, alice, USD(80)));
|
|
|
|
env(pay(alice, carol, USD(100)), txflags(tfPartialPayment));
|
|
|
|
BEAST_EXPECT(env.balance(gw, USD) == USD(-80));
|
|
BEAST_EXPECT(env.balance(alice, USD) == USD(0));
|
|
BEAST_EXPECT(env.balance(carol, USD) == USD(80));
|
|
}
|
|
|
|
// Direct payment between holders. Partial payment limited
|
|
// by holder funds. OutstandingAmount is already at max
|
|
// before the payment.
|
|
{
|
|
Env env(*this);
|
|
|
|
env.fund(XRP(1'000), gw, alice, carol, bob);
|
|
|
|
MPT const USD = MPTTester(
|
|
{.env = env, .issuer = gw, .holders = {alice, carol, bob}, .maxAmt = 100});
|
|
|
|
env(pay(gw, bob, USD(20)));
|
|
env(pay(gw, alice, USD(80)));
|
|
|
|
env(pay(alice, carol, USD(100)), txflags(tfPartialPayment));
|
|
|
|
BEAST_EXPECT(env.balance(gw, USD) == USD(-100));
|
|
BEAST_EXPECT(env.balance(alice, USD) == USD(0));
|
|
BEAST_EXPECT(env.balance(carol, USD) == USD(80));
|
|
}
|
|
|
|
// Cross-currency payment holder to holder. Holder owns an
|
|
// offer. OutstandingAmount is already at max before the
|
|
// payment.
|
|
{
|
|
Env env(*this);
|
|
|
|
env.fund(XRP(1'000), gw, alice, carol, bob);
|
|
|
|
MPT const USD =
|
|
MPTTester({.env = env, .issuer = gw, .holders = {alice, carol}, .maxAmt = 100});
|
|
|
|
env(pay(gw, alice, USD(100)));
|
|
|
|
env(offer(alice, XRP(100), USD(100)));
|
|
|
|
env(pay(bob, carol, USD(100)), sendmax(XRP(100)), path(~USD));
|
|
|
|
BEAST_EXPECT(env.balance(gw, USD) == USD(-100));
|
|
BEAST_EXPECT(env.balance(alice, USD) == USD(0));
|
|
BEAST_EXPECT(env.balance(carol, USD) == USD(100));
|
|
}
|
|
|
|
// Cross-currency payment holder to holder. Issuer owns an
|
|
// offer. OutstandingAmount is already at max before the
|
|
// payment. Since an issuer owns the offer, it issues more
|
|
// tokens to another holder, and the payment fails.
|
|
{
|
|
Env env(*this);
|
|
|
|
env.fund(XRP(1'000), gw, alice, carol);
|
|
|
|
MPT const USD =
|
|
MPTTester({.env = env, .issuer = gw, .holders = {carol}, .maxAmt = 100});
|
|
|
|
env(pay(gw, carol, USD(100)));
|
|
|
|
env(offer(gw, XRP(100), USD(100)));
|
|
|
|
env(pay(alice, carol, USD(100)),
|
|
sendmax(XRP(100)),
|
|
path(~USD),
|
|
txflags(tfPartialPayment),
|
|
ter(tecPATH_DRY));
|
|
|
|
BEAST_EXPECT(env.balance(gw, USD) == USD(-100));
|
|
BEAST_EXPECT(env.balance(carol, USD) == USD(100));
|
|
}
|
|
|
|
// Cross-currency payment holder to holder. Issuer owns an
|
|
// offer. OutstandingAmount is at 80USD before the payment.
|
|
// Consequently, the issuer can issue 20USD more.
|
|
{
|
|
Env env(*this);
|
|
|
|
env.fund(XRP(1'000), gw, alice, carol);
|
|
|
|
MPT const USD =
|
|
MPTTester({.env = env, .issuer = gw, .holders = {carol}, .maxAmt = 100});
|
|
|
|
env(pay(gw, carol, USD(80)));
|
|
|
|
env(offer(gw, XRP(100), USD(100)));
|
|
|
|
env(pay(alice, carol, USD(100)),
|
|
sendmax(XRP(100)),
|
|
path(~USD),
|
|
txflags(tfPartialPayment));
|
|
|
|
BEAST_EXPECT(env.balance(gw, USD) == USD(-100));
|
|
BEAST_EXPECT(env.balance(carol, USD) == USD(100));
|
|
}
|
|
|
|
// Cross-currency payment holder to holder. Holder owns an
|
|
// offer. The offer buys more MPT's. The payment fails since
|
|
// OutstandingAmount is already at max.
|
|
{
|
|
Env env(*this);
|
|
|
|
env.fund(XRP(1'000), gw, alice);
|
|
|
|
MPT const USD =
|
|
MPTTester({.env = env, .issuer = gw, .holders = {alice}, .maxAmt = 100});
|
|
|
|
env(pay(gw, alice, USD(100)));
|
|
|
|
env(offer(alice, USD(100), XRP(100)));
|
|
|
|
env(pay(gw, alice, XRP(100)), sendmax(USD(100)), path(~XRP), ter(tecPATH_PARTIAL));
|
|
|
|
BEAST_EXPECT(env.balance(gw, USD) == USD(-100));
|
|
BEAST_EXPECT(env.balance(alice, USD) == USD(100));
|
|
}
|
|
|
|
// Cross-currency payment issuer to holder. Holder owns an
|
|
// offer. The offer buys EUR, OutstandingAmount goes to max,
|
|
// no overflow. The offer redeems USD to the issuer. While
|
|
// OutstandingAmount is already at max, the payment succeeds
|
|
// since USD is redeemed.
|
|
{
|
|
auto test = [&](auto&& issue1, auto&& issue2) {
|
|
Env env(*this);
|
|
|
|
env.fund(XRP(1'000), gw, alice, carol);
|
|
env.close();
|
|
|
|
auto const USD = issue1(
|
|
{.env = env,
|
|
.token = "USD",
|
|
.issuer = gw,
|
|
.holders = {alice, carol},
|
|
.limit = 100});
|
|
using tUSD = std::decay_t<decltype(USD)>;
|
|
auto const EUR = issue2(
|
|
{.env = env,
|
|
.token = "EUR",
|
|
.issuer = gw,
|
|
.holders = {alice, carol},
|
|
.limit = 100});
|
|
|
|
env(pay(gw, alice, USD(100)));
|
|
|
|
env(offer(alice, EUR(100), USD(100)));
|
|
|
|
env(pay(gw, carol, USD(100)), sendmax(EUR(100)), path(~USD));
|
|
|
|
if constexpr (std::is_same_v<tUSD, MPT>)
|
|
BEAST_EXPECT(env.balance(gw, USD) == USD(-100));
|
|
BEAST_EXPECT(env.balance(alice, USD) == USD(0));
|
|
BEAST_EXPECT(env.balance(alice, EUR) == EUR(100));
|
|
BEAST_EXPECT(env.balance(carol, USD) == USD(100));
|
|
};
|
|
testHelper2TokensMix(test);
|
|
}
|
|
|
|
// Cross-currency payment holder to holder. Offer is owned
|
|
// by destination account. OutstandingAmount is not at max.
|
|
{
|
|
Env env(*this);
|
|
|
|
env.fund(XRP(1'000), gw, alice, carol);
|
|
|
|
MPT const USD =
|
|
MPTTester({.env = env, .issuer = gw, .holders = {carol}, .maxAmt = 120});
|
|
|
|
env(pay(gw, carol, USD(100)));
|
|
|
|
env(offer(carol, XRP(100), USD(100)));
|
|
|
|
env(pay(alice, carol, USD(100)),
|
|
path(~USD),
|
|
sendmax(XRP(100)),
|
|
txflags(tfPartialPayment));
|
|
|
|
BEAST_EXPECT(env.balance(carol, USD) == USD(100));
|
|
}
|
|
|
|
// Cross-currency payment holder to holder. Offer is owned
|
|
// by destination account. OutstandingAmount is already at
|
|
// max.
|
|
{
|
|
Env env(*this);
|
|
|
|
env.fund(XRP(1'000), gw, alice, carol);
|
|
|
|
MPT const USD =
|
|
MPTTester({.env = env, .issuer = gw, .holders = {carol}, .maxAmt = 100});
|
|
|
|
env(pay(gw, carol, USD(100)));
|
|
|
|
env(offer(carol, XRP(100), USD(100)));
|
|
|
|
env(pay(alice, carol, USD(100)),
|
|
path(~USD),
|
|
sendmax(XRP(100)),
|
|
txflags(tfPartialPayment));
|
|
|
|
BEAST_EXPECT(env.balance(carol, USD) == USD(100));
|
|
}
|
|
|
|
// Cross-currency payment holder to holder. Multiple offers
|
|
// with different owners - some holders, some issuer.
|
|
{
|
|
auto test = [&](auto&& issue1, auto&& issue2) {
|
|
Env env(*this);
|
|
|
|
env.fund(XRP(1'000), gw, alice, carol, bob);
|
|
env.close();
|
|
|
|
auto const USD = issue1(
|
|
{.env = env,
|
|
.token = "USD",
|
|
.issuer = gw,
|
|
.holders = {alice, carol, bob},
|
|
.limit = 1'000});
|
|
using tUSD = std::decay_t<decltype(USD)>;
|
|
auto const EUR = issue2(
|
|
{.env = env,
|
|
.token = "EUR",
|
|
.issuer = gw,
|
|
.holders = {alice, carol, bob},
|
|
.limit = 1'000});
|
|
using tEUR = std::decay_t<decltype(EUR)>;
|
|
|
|
env(pay(gw, alice, USD(600)));
|
|
env(pay(gw, carol, EUR(700)));
|
|
|
|
env(offer(alice, EUR(100), USD(105)));
|
|
env(offer(gw, EUR(100), USD(104)));
|
|
env(offer(gw, EUR(100), USD(103)));
|
|
env(offer(gw, EUR(100), USD(102)));
|
|
env(offer(gw, EUR(100), USD(101)));
|
|
env(offer(gw, EUR(100), USD(100)));
|
|
|
|
env(pay(carol, bob, USD(2'000)),
|
|
sendmax(EUR(2'000)),
|
|
path(~USD),
|
|
txflags(tfPartialPayment));
|
|
|
|
if constexpr (std::is_same_v<tUSD, MPT>)
|
|
{
|
|
BEAST_EXPECT(env.balance(gw, USD) == USD(-1'000));
|
|
BEAST_EXPECT(env.balance(alice, USD) == USD(495));
|
|
BEAST_EXPECT(env.balance(bob, USD) == USD(505));
|
|
}
|
|
else
|
|
{
|
|
BEAST_EXPECT(env.balance(gw, USD) == USD(0));
|
|
BEAST_EXPECT(env.balance(alice, USD) == USD(495));
|
|
// all offers are consumed since the limit is different
|
|
// for the holders
|
|
BEAST_EXPECT(env.balance(bob, USD) == USD(615));
|
|
}
|
|
if constexpr (std::is_same_v<tEUR, MPT>)
|
|
{
|
|
if constexpr (std::is_same_v<tUSD, MPT>)
|
|
{
|
|
BEAST_EXPECT(env.balance(carol, EUR) == EUR(210));
|
|
}
|
|
else
|
|
{
|
|
// carol sells 600USD since all offers are consumed
|
|
BEAST_EXPECT(env.balance(carol, EUR) == EUR(100));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
BEAST_EXPECT(
|
|
env.balance(carol, EUR) == STAmount(EUR, UINT64_C(209'9009900990099), -13));
|
|
}
|
|
// 100/101 is partially crossed (90/91) and 100/100 is
|
|
// unfunded when MPT. All offers are consumed if IOU.
|
|
env.require(offers(gw, 0));
|
|
// alice's offer is consumed.
|
|
env.require(offers(alice, 0));
|
|
};
|
|
testHelper2TokensMix(test);
|
|
}
|
|
|
|
// Cross-currency payment holder to holder. Multiple offers
|
|
// with different owners - some holders, some issuer. Source
|
|
// and destination account is the same.
|
|
{
|
|
Env env(*this);
|
|
|
|
env.fund(XRP(1'000), gw, alice, carol);
|
|
|
|
MPT const USD =
|
|
MPTTester({.env = env, .issuer = gw, .holders = {alice, carol}, .maxAmt = 2'000});
|
|
|
|
env(pay(gw, carol, USD(1'000)));
|
|
env(pay(gw, alice, USD(600)));
|
|
|
|
env(offer(gw, XRP(5), USD(11)));
|
|
env(offer(gw, XRP(6), USD(13)));
|
|
env(offer(carol, XRP(7), USD(15)));
|
|
env(offer(carol, XRP(17), USD(35)));
|
|
env(offer(carol, XRP(23), USD(47)));
|
|
env(offer(alice, XRP(10), USD(19)));
|
|
env(offer(alice, XRP(15), USD(28)));
|
|
env(offer(alice, XRP(25), USD(46)));
|
|
|
|
env(pay(carol, carol, USD(200)), sendmax(XRP(100)), txflags(tfPartialPayment));
|
|
|
|
BEAST_EXPECT(env.balance(gw, USD) == USD(-1'624));
|
|
BEAST_EXPECT(env.balance(carol, USD) == USD(1'102));
|
|
env.require(offers(carol, 0));
|
|
env.require(offers(gw, 0));
|
|
// 100 XRP's = 5+6+7+17+23+10+15+17(25-8)
|
|
BEAST_EXPECT(isOffer(env, alice, XRP(8), USD(15)));
|
|
}
|
|
|
|
// Cross-currency payment holder to holder. Multiple offers
|
|
// with different owners - some holders, some issuer.
|
|
{
|
|
Env env(*this);
|
|
env.fund(XRP(1'000), gw, alice, carol, bob);
|
|
|
|
MPT const USD =
|
|
MPTTester({.env = env, .issuer = gw, .holders = {alice, carol, bob}, .maxAmt = 30});
|
|
|
|
env(pay(gw, alice, USD(12))); // 12, 15, 20
|
|
env(pay(gw, bob, USD(5))); // 5, 5, 10
|
|
|
|
env(offer(alice, XRP(10), USD(12)));
|
|
env(offer(gw, XRP(10), USD(11)));
|
|
env(offer(bob, XRP(10), USD(10)));
|
|
|
|
env(pay(carol, bob, USD(30)), sendmax(XRP(30)), txflags(tfPartialPayment), path(~USD));
|
|
BEAST_EXPECT(env.balance(gw, USD) == USD(-28));
|
|
BEAST_EXPECT(env.balance(alice, USD) == USD(0));
|
|
// 12+11+5
|
|
BEAST_EXPECT(env.balance(bob, USD) == USD(28));
|
|
}
|
|
|
|
// Cross-currency payment two steps. Second book step
|
|
// issues, first book step redeems.
|
|
{
|
|
Account const dan{"dan"};
|
|
Account const john{"john"};
|
|
Account const ed{"ed"};
|
|
Account const sam{"sam"};
|
|
Account const bill{"bill"};
|
|
|
|
struct TestData
|
|
{
|
|
int maxAmt;
|
|
int sendMax;
|
|
int dstTrustLimit;
|
|
int dstExpectEUR;
|
|
int outstandingUSD;
|
|
int expEdBuyUSD;
|
|
int expDanBuyUSD;
|
|
int expBobSellUSD;
|
|
int expGwXRP; // whole XRP excluding the fees
|
|
std::uint8_t expOffersGw;
|
|
bool lastGwBuyUSD;
|
|
[[nodiscard]] std::uint8_t
|
|
expOffersBob() const
|
|
{
|
|
return expBobSellUSD == 0 ? 1 : 0;
|
|
}
|
|
[[nodiscard]] std::uint8_t
|
|
expOffersEd() const
|
|
{
|
|
// partially crossed if < 100
|
|
return expEdBuyUSD < 100 ? 1 : 0;
|
|
}
|
|
[[nodiscard]] std::uint8_t
|
|
expOffersDan() const
|
|
{
|
|
return expDanBuyUSD == 0 ? 1 : 0;
|
|
}
|
|
};
|
|
|
|
auto test = [&](TestData const& d) {
|
|
Env env(*this);
|
|
env.fund(XRP(1'000), gw, alice, carol, bob, dan, john, ed, sam, bill);
|
|
env.close();
|
|
|
|
MPT const USD = MPTTester(
|
|
{.env = env, .issuer = gw, .holders = {alice, carol, bob}, .maxAmt = d.maxAmt});
|
|
auto const EUR = gw["EUR"];
|
|
|
|
env(pay(gw, alice, USD(100)));
|
|
env(pay(gw, carol, USD(100)));
|
|
env(pay(gw, bob, USD(100)));
|
|
|
|
BEAST_EXPECT(env.balance(gw, USD) == USD(-300));
|
|
|
|
env(trust(john, EUR(100)));
|
|
env(trust(dan, EUR(100)));
|
|
env(trust(ed, EUR(100)));
|
|
env(trust(bill, EUR(d.dstTrustLimit)));
|
|
|
|
env(pay(gw, john, EUR(100)));
|
|
env(pay(gw, dan, EUR(100)));
|
|
env(pay(gw, ed, EUR(100)));
|
|
env.close();
|
|
|
|
// Sell USD
|
|
env(offer(alice, XRP(100), USD(100)));
|
|
env.close(); // close after each create to ensure
|
|
// the order
|
|
env(offer(carol, XRP(100), USD(100)));
|
|
env.close();
|
|
if (!d.lastGwBuyUSD)
|
|
{
|
|
env(offer(gw, XRP(100), USD(100)));
|
|
env.close();
|
|
}
|
|
env(offer(bob, XRP(100), USD(100)));
|
|
env.close();
|
|
if (d.lastGwBuyUSD)
|
|
{
|
|
env(offer(gw, XRP(100), USD(100)));
|
|
env.close();
|
|
}
|
|
BEAST_EXPECT(expectOffers(env, alice, 1));
|
|
BEAST_EXPECT(expectOffers(env, carol, 1));
|
|
BEAST_EXPECT(expectOffers(env, gw, 1));
|
|
BEAST_EXPECT(expectOffers(env, bob, 1));
|
|
|
|
// Buy USD
|
|
env(offer(john, USD(100), EUR(100)));
|
|
env.close();
|
|
env(offer(gw, USD(100), EUR(100)));
|
|
env.close();
|
|
env(offer(dan, USD(100), EUR(100)));
|
|
env.close();
|
|
env(offer(ed, USD(100), EUR(100)));
|
|
env.close();
|
|
BEAST_EXPECT(expectOffers(env, john, 1));
|
|
BEAST_EXPECT(expectOffers(env, gw, 2));
|
|
BEAST_EXPECT(expectOffers(env, dan, 1));
|
|
BEAST_EXPECT(expectOffers(env, ed, 1));
|
|
|
|
env(pay(sam, bill, EUR(400)),
|
|
sendmax(XRP(d.sendMax)),
|
|
path(~USD, ~EUR),
|
|
txflags(tfPartialPayment | tfNoRippleDirect));
|
|
env.close();
|
|
|
|
auto const baseFee = env.current()->fees().base.drops();
|
|
BEAST_EXPECT(env.balance(bill, EUR) == EUR(d.dstExpectEUR));
|
|
BEAST_EXPECT(env.balance(john, USD) == USD(100));
|
|
BEAST_EXPECT(env.balance(dan, USD) == USD(d.expDanBuyUSD));
|
|
BEAST_EXPECT(env.balance(ed, USD) == USD(d.expEdBuyUSD));
|
|
BEAST_EXPECT(env.balance(gw, USD) == USD(-d.outstandingUSD));
|
|
BEAST_EXPECT(env.balance(alice, USD) == USD(0));
|
|
BEAST_EXPECT(env.balance(carol, USD) == USD(0));
|
|
BEAST_EXPECT(env.balance(bob, USD) == USD(100 - d.expBobSellUSD));
|
|
BEAST_EXPECT(
|
|
env.balance(gw) == XRPAmount{d.expGwXRP * DROPS_PER_XRP - baseFee * 9});
|
|
BEAST_EXPECT(expectOffers(env, john, 0));
|
|
BEAST_EXPECT(expectOffers(env, gw, d.expOffersGw));
|
|
BEAST_EXPECT(expectOffers(env, dan, d.expOffersDan()));
|
|
BEAST_EXPECT(expectOffers(env, ed, d.expOffersEd()));
|
|
BEAST_EXPECT(expectOffers(env, alice, 0));
|
|
BEAST_EXPECT(expectOffers(env, carol, 0));
|
|
BEAST_EXPECT(expectOffers(env, bob, d.expOffersBob()));
|
|
};
|
|
|
|
// clang-format off
|
|
std::vector<TestData> const tests = {
|
|
// Sell USD: alice, carol, bob, gw are consumed.
|
|
// Buy USD: john, gw, dan, ed are consumed.
|
|
// gw's sell USD is consumed because there is sufficient available balance (100USD).
|
|
// but OutstandingAmount is 300USD because gw's sell offer is balanced out by
|
|
// gw's buy offer.
|
|
//*maxAmt sendMax limitEUR expectEUR outstandingUSD edBuy danBuy bobSell gwXRP offersGw lastGw
|
|
{ 400, 400, 400, 400, 300, 100, 100, 100, 1100, 0, false},
|
|
// Sell USD: alice, carol, bob, gw are consumed.
|
|
// Buy USD: john, gw, dan, ed (partially) are consumed.
|
|
// gw's sell USD is partially consumed because there is available balance (50USD).
|
|
// OutstandingAmount is 250USD because gw's sell offer is partially balanced by
|
|
// gw's buy offer. ed's offer is on the books because it's partially crossed.
|
|
// gw's offer is removed from the order book because it's partially consumed and
|
|
// the remaining offer is unfunded.
|
|
//*maxAmt sendMax limitEUR expectEUR outstandingUSD edBuy danBuy bobSell gwXRP offersGw lastGw
|
|
{ 350, 400, 400, 350, 250, 50, 100, 100, 1050, 0, false},
|
|
// Sell USD: alice, carol, bob are consumed; gw's is unfunded
|
|
// since OutstandingAmount is initially at MaximumAmount.
|
|
// Buy USD: john, gw, dan are consumed; ed's remains on the order
|
|
// book since 300USD is the sell limit.
|
|
//*maxAmt sendMax limitEUR expectEUR outstandingUSD edBuy danBuy bobSell gwXRP offersGw lastGw
|
|
{ 300, 400, 400, 300, 200, 0, 100, 100, 1000, 0, false},
|
|
// Same as above. bill's trustline limit sets the output to 300USD.
|
|
//*maxAmt sendMax limitEUR expectEUR outstandingUSD edBuy danBuy bobSell gwXRP offersGw lastGw
|
|
{ 300, 400, 300, 300, 200, 0, 100, 100, 1000, 0, false},
|
|
// Sell USD: alice, carol, bob are consumed; gw's removed from
|
|
// the order book since it's unfunded.
|
|
// Buy USD: john, gw, dan are consumed; ed's remains on the order
|
|
// book since 300USD is the limit.
|
|
//*maxAmt sendMax limitEUR expectEUR outstandingUSD edBuy danBuy bobSell gwXRP offersGw lastGw
|
|
{ 300, 400, 300, 300, 200, 0, 100, 100, 1000, 0, true},
|
|
// Sell USD: alice, carol are consumed; gw's removed from
|
|
// the order book in rev pass since it's unfunded; bob's
|
|
// remains on the order book.
|
|
// Buy USD: john, gw; ed's, dan's remains on the order
|
|
// book since 300USD is the limit.
|
|
//*maxAmt sendMax limitEUR expectEUR outstandingUSD edBuy danBuy bobSell gwXRP offersGw lastGw
|
|
{ 300, 200, 300, 200, 200, 0, 0, 0, 1000, 0, false},
|
|
// Same as three tests above since limited by buy 300USD (gw offer is unfunded)
|
|
//*maxAmt sendMax limitEUR expectEUR outstandingUSD edBuy danBuy bobSell gwXRP offersGw lastGw
|
|
{ 300, 380, 400, 300, 200, 0, 100, 100, 1000, 0, false},
|
|
};
|
|
// clang-format on
|
|
for (auto const& t : tests)
|
|
test(t);
|
|
}
|
|
|
|
// Cross-currency payment. BookStep issues, the first step
|
|
// redeems.
|
|
{
|
|
Account const ed{"ed"};
|
|
|
|
struct TestData
|
|
{
|
|
int maxAmt;
|
|
int sendMax;
|
|
int gwOffer; // quality == 1
|
|
int dstExpectXRP;
|
|
int outstandingUSD;
|
|
int expBobBuyUSD;
|
|
int expGwXRP; // whole XRP excluding the fees
|
|
std::uint8_t expOffersGw;
|
|
bool lastGwBuyUSD;
|
|
[[nodiscard]] std::uint8_t
|
|
expOffersBob() const
|
|
{
|
|
// partially crossed if < 100
|
|
return expBobBuyUSD < 100 ? 1 : 0;
|
|
}
|
|
};
|
|
|
|
auto test = [&](TestData const& d) {
|
|
Env env(*this);
|
|
env.fund(XRP(1'000), gw, alice, carol, bob, ed);
|
|
env.close();
|
|
|
|
MPT const USD =
|
|
MPTTester({.env = env, .issuer = gw, .holders = {alice}, .maxAmt = d.maxAmt});
|
|
|
|
env(pay(gw, alice, USD(300)));
|
|
env.close();
|
|
|
|
env(offer(carol, USD(100), XRP(100)));
|
|
env.close();
|
|
if (!d.lastGwBuyUSD)
|
|
{
|
|
env(offer(gw, USD(d.gwOffer), XRP(d.gwOffer)));
|
|
env.close();
|
|
}
|
|
env(offer(bob, USD(100), XRP(100)));
|
|
env.close();
|
|
if (d.lastGwBuyUSD)
|
|
{
|
|
env(offer(gw, USD(d.gwOffer), XRP(d.gwOffer)));
|
|
env.close();
|
|
}
|
|
|
|
BEAST_EXPECT(expectOffers(env, carol, 1));
|
|
BEAST_EXPECT(expectOffers(env, bob, 1));
|
|
BEAST_EXPECT(expectOffers(env, gw, 1));
|
|
BEAST_EXPECT(env.balance(gw, USD) == USD(-300));
|
|
|
|
env(pay(alice, ed, XRP(300)),
|
|
sendmax(USD(d.sendMax)),
|
|
path(~XRP),
|
|
txflags(tfPartialPayment | tfNoRippleDirect));
|
|
env.close();
|
|
|
|
auto const baseFee = env.current()->fees().base.drops();
|
|
BEAST_EXPECT(env.balance(alice, USD) == USD(300 - d.sendMax));
|
|
BEAST_EXPECT(env.balance(carol, USD) == USD(100));
|
|
BEAST_EXPECT(env.balance(bob, USD) == USD(d.expBobBuyUSD));
|
|
BEAST_EXPECT(env.balance(ed) == XRP(d.dstExpectXRP));
|
|
BEAST_EXPECT(env.balance(gw, USD) == USD(-d.outstandingUSD));
|
|
BEAST_EXPECT(
|
|
env.balance(gw) == XRPAmount{d.expGwXRP * DROPS_PER_XRP - baseFee * 3});
|
|
BEAST_EXPECT(expectOffers(env, carol, 0));
|
|
BEAST_EXPECT(expectOffers(env, bob, d.expOffersBob()));
|
|
BEAST_EXPECT(expectOffers(env, gw, d.expOffersGw));
|
|
};
|
|
|
|
// clang-format off
|
|
std::vector<TestData> const tests = {
|
|
// Buy USD: carol, gw, bob are consumed.
|
|
// Gw gets 300USD from alice; carol and bob buy 200USD,
|
|
// therefore OutstandingAmount is 200.
|
|
//*maxAmt sendMax gwOffer dstXRP outstandingUSD bobBuy gwXRP offersGw lastGw
|
|
{ 300, 300, 100, 1300, 200, 100, 900, 0, false},
|
|
// Same as above. Gw offer location in the order book doesn't matter
|
|
//*maxAmt sendMax gwOffer dstXRP outstandingUSD bobBuy gwXRP offersGw lastGw
|
|
{ 300, 300, 100, 1300, 200, 100, 900, 0, true},
|
|
// Buy USD: carol, gw are consumed. bob's offer remains on the order book.
|
|
// Gw gets 300USD from alice; carol buys 100USD,
|
|
// therefore OutstandingAmount is 100.
|
|
//*maxAmt sendMax gwOffer dstXRP outstandingUSD bobBuy gwXRP offersGw lastGw
|
|
{ 300, 300, 200, 1300, 100, 0, 800, 0, false},
|
|
// Buy USD: carol, bob are consumed; gw's is partially consumed (100/100) since it's last.
|
|
// Gw gets 300USD from alice; carol and bob buy 200USD,
|
|
// therefore OutstandingAmount is 200.
|
|
//*maxAmt sendMax gwOffer dstXRP outstandingUSD bobBuy gwXRP offersGw lastGw
|
|
{ 300, 300, 200, 1300, 200, 100, 900, 1, true},
|
|
// Buy USD: carol, bob are consumed; gw's is partially consumed (50/50) since it's last
|
|
// and sendMax limits the output.
|
|
// Gw gets 250USD from alice; carol and bob buy 200USD, alice has 50USD left,
|
|
// therefore OutstandingAmount is 200.
|
|
//*maxAmt sendMax gwOffer dstXRP outstandingUSD bobBuy gwXRP offersGw lastGw
|
|
{ 300, 250, 200, 1250, 250, 100, 950, 1, true},
|
|
};
|
|
// clang-format on
|
|
for (auto const& t : tests)
|
|
test(t);
|
|
}
|
|
|
|
// Cross-currency payment. BookStep redeems, the last step
|
|
// issues.
|
|
{
|
|
Account const ed{"ed"};
|
|
|
|
struct TestData
|
|
{
|
|
int maxAmt;
|
|
int sendMax;
|
|
int initDst;
|
|
int gwOffer; // quality == 1
|
|
int dstExpectUSD;
|
|
int outstandingUSD;
|
|
int expAliceXRP; // whole XRP excluding the fees
|
|
int expBobSellUSD;
|
|
int expGwXRP;
|
|
std::uint8_t expOffersGw;
|
|
bool lastGwBuyUSD;
|
|
[[nodiscard]] std::uint8_t
|
|
expOffersBob() const
|
|
{
|
|
return expBobSellUSD > 0 && expBobSellUSD < 100 ? 1 : 0;
|
|
}
|
|
};
|
|
|
|
auto test = [&](TestData const& d) {
|
|
Env env(*this);
|
|
env.fund(XRP(1'000), gw, alice, carol, bob, ed);
|
|
env.close();
|
|
|
|
MPT const USD = MPTTester(
|
|
{.env = env, .issuer = gw, .holders = {carol, bob, ed}, .maxAmt = d.maxAmt});
|
|
|
|
if (d.initDst != 0)
|
|
env(pay(gw, ed, USD(d.initDst)));
|
|
env(pay(gw, carol, USD(100)));
|
|
env(pay(gw, bob, USD(100)));
|
|
env.close();
|
|
|
|
env(offer(carol, XRP(100), USD(100)));
|
|
env.close();
|
|
if (!d.lastGwBuyUSD)
|
|
{
|
|
env(offer(gw, XRP(d.gwOffer), USD(d.gwOffer)));
|
|
env.close();
|
|
}
|
|
env(offer(bob, XRP(100), USD(100)));
|
|
env.close();
|
|
if (d.lastGwBuyUSD)
|
|
{
|
|
env(offer(gw, XRP(d.gwOffer), USD(d.gwOffer)));
|
|
env.close();
|
|
}
|
|
|
|
BEAST_EXPECT(expectOffers(env, carol, 1));
|
|
BEAST_EXPECT(expectOffers(env, bob, 1));
|
|
BEAST_EXPECT(expectOffers(env, gw, 1));
|
|
BEAST_EXPECT(env.balance(gw, USD) == USD(-200 - d.initDst));
|
|
|
|
env(pay(alice, ed, USD(300)),
|
|
sendmax(XRP(d.sendMax)),
|
|
path(~USD),
|
|
txflags(tfPartialPayment | tfNoRippleDirect));
|
|
env.close();
|
|
|
|
auto const baseFee = env.current()->fees().base.drops();
|
|
BEAST_EXPECT(
|
|
env.balance(alice) == XRPAmount{d.expAliceXRP * DROPS_PER_XRP - baseFee});
|
|
BEAST_EXPECT(env.balance(carol, USD) == USD(0));
|
|
BEAST_EXPECT(env.balance(bob, USD) == USD(100 - d.expBobSellUSD));
|
|
BEAST_EXPECT(env.balance(ed, USD) == USD(d.dstExpectUSD));
|
|
BEAST_EXPECT(env.balance(gw, USD) == USD(-d.outstandingUSD));
|
|
BEAST_EXPECT(
|
|
env.balance(gw) ==
|
|
XRPAmount{
|
|
d.expGwXRP * DROPS_PER_XRP - baseFee * (4 + (d.initDst != 0 ? 1 : 0))});
|
|
BEAST_EXPECT(expectOffers(env, carol, 0));
|
|
BEAST_EXPECT(expectOffers(env, bob, d.expOffersBob()));
|
|
BEAST_EXPECT(expectOffers(env, gw, d.expOffersGw));
|
|
};
|
|
|
|
// clang-format off
|
|
std::vector<TestData> const tests = {
|
|
// Sell USD: carol, gw, bob are consumed.
|
|
// ed buys 300USD from carol, gw, bob therefore OutstandingAmount is 300.
|
|
//*maxAmt sendMax initDst gwOffer dstUSD outstandingUSD aliceXRP bobSell gwXRP offersGw lastGw
|
|
{ 300, 300, 0, 100, 300, 300, 700, 100, 1100, 0, false},
|
|
// Same as above. Gw offer location in the order book doesn't matter
|
|
//*maxAmt sendMax initDst gwOffer dstUSD outstandingUSD aliceXRP bobSell gwXRP offersGw lastGw
|
|
{ 300, 300, 0, 100, 300, 300, 700, 100, 1100, 0, true},
|
|
// Sell USD: carol, bob are consumed, gw is partially consumed.
|
|
// ed buys 200 from carol and bob and 50 from gw because gw can only issue 50
|
|
// (300(max) - 200(carol+bob) - 50(ed)). ed buys 250 from carol, gw, bob and has 50 initially,
|
|
// therefore OutstandingAmount is 300.
|
|
// gw's offer is removed from the order book because it's partially consumed and the remaining
|
|
// offer is unfunded.
|
|
//*maxAmt sendMax initDst gwOffer dstUSD outstandingUSD aliceXRP bobSell gwXRP offersGw lastGw
|
|
{ 300, 300, 50, 100, 300, 300, 750, 100, 1050, 0, false},
|
|
// Same as above. Gw offer location in the order book doesn't matter.
|
|
//*maxAmt sendMax initDst gwOffer dstUSD outstandingUSD aliceXRP bobSell gwXRP offersGw lastGw
|
|
{ 300, 300, 50, 100, 300, 300, 750, 100, 1050, 0, true},
|
|
// Same as above. Gw offer size doesn't matter.
|
|
//*maxAmt sendMax initDst gwOffer dstUSD outstandingUSD aliceXRP bobSell gwXRP offersGw lastGw
|
|
{ 300, 300, 50, 200, 300, 300, 750, 100, 1050, 0, true},
|
|
// Sell USD: carol, gw are consumed, bob is partially consumed.
|
|
// ed buys 200 from carol and gw and 50 form bob because of sendMax limit. bob keeps 50,
|
|
// therefore OutstandingAmount is 300.
|
|
//*maxAmt sendMax initDst gwOffer dstUSD outstandingUSD aliceXRP bobSell gwXRP offersGw lastGw
|
|
{ 300, 250, 0, 100, 250, 300, 750, 50, 1100, 0, false},
|
|
// Sell USD: carol, bob are consumed, gw is partially consumed because of sendMax limit.
|
|
// ed buys 200 from carol and bob and 50 from gw. Therefore, OutstandingAmount is 250.
|
|
// gw's offer remains on the order book because it's partially consumed and has more funds.
|
|
//*maxAmt sendMax initDst gwOffer dstUSD outstandingUSD aliceXRP bobSell gwXRP offersGw lastGw
|
|
{ 300, 250, 0, 100, 250, 250, 750, 100, 1050, 1, true},
|
|
// Sell USD: carol, bob are consumed, gw is partially consumed because of sendMax limit, also
|
|
// there is only 50 available to issue. ed buys 200 from carol and bob and 50 from gw, plus
|
|
// he has initially 50, therefore OutstandingAmount is 300.
|
|
//*maxAmt sendMax initDst gwOffer dstUSD outstandingUSD aliceXRP bobSell gwXRP offersGw lastGw
|
|
{ 300, 250, 50, 100, 300, 300, 750, 100, 1050, 0, true},
|
|
// Sell USD: carol, bob are consumed, gw is not consumed because there is not available funds
|
|
// to issue. ed buys 200 from carol and bob and, plus he has initially 100,
|
|
// therefore OutstandingAmount is 300. gw offer is removed because it's unfunded.
|
|
//*maxAmt sendMax initDst gwOffer dstUSD outstandingUSD aliceXRP bobSell gwXRP offersGw lastGw
|
|
{ 300, 250, 100, 100, 300, 300, 800, 100, 1000, 0, true},
|
|
};
|
|
// clang-format on
|
|
for (auto const& t : tests)
|
|
test(t);
|
|
}
|
|
|
|
// Cross-currency payment with BookStep as the first step.
|
|
// BookStep limits the buy amount.
|
|
{
|
|
auto test = [&](int sendMax, std::uint16_t dstXRP, std::uint8_t expGwOffers) {
|
|
Env env(*this);
|
|
env.fund(XRP(1'000), gw, alice, carol);
|
|
|
|
MPT const USD = MPTTester({.env = env, .issuer = gw, .maxAmt = 300});
|
|
|
|
env(offer(carol, USD(400), XRP(400)));
|
|
env(offer(gw, USD(100), XRP(100)));
|
|
BEAST_EXPECT(expectOffers(env, carol, 1));
|
|
BEAST_EXPECT(expectOffers(env, gw, 1));
|
|
|
|
env(pay(gw, alice, XRP(500)),
|
|
sendmax(USD(sendMax)),
|
|
path(~XRP),
|
|
txflags(tfPartialPayment | tfNoRippleDirect));
|
|
|
|
BEAST_EXPECT(env.balance(alice) == XRP(dstXRP));
|
|
BEAST_EXPECT(env.balance(gw, USD) == USD(-300));
|
|
BEAST_EXPECT(env.balance(carol, USD) == USD(300));
|
|
BEAST_EXPECT(expectOffers(env, carol, 0));
|
|
BEAST_EXPECT(expectOffers(env, gw, expGwOffers));
|
|
};
|
|
// carol's offer is partially consumed - 300USD/300XRP
|
|
// because available amount to issue is 300USD. gw's
|
|
// offer is fully consumed because it doesn't change
|
|
// OutstandingAmount. Both offers are removed from the
|
|
// order book - carol's offer is unfunded and gw's offer
|
|
// is fully consumed.
|
|
test(500, 1'400, 0);
|
|
// carol's offer is partially consumed - 300USD/300XRP
|
|
// because available amount to issue is 300USD. gw's
|
|
// offer is partially consumed because of sendMax limit.
|
|
// carol's offer is removed from the order book because
|
|
// it's unfunded. gw's offer remains on the order book
|
|
// because it's partially consumed and gw has more
|
|
// funds.
|
|
test(350, 1'350, 1);
|
|
}
|
|
}
|
|
|
|
void
|
|
testWithFeats(FeatureBitset features)
|
|
{
|
|
using namespace jtx;
|
|
|
|
testMaxAndSelfPaymentEdgeCases(features);
|
|
testFalseDry(features);
|
|
testDirectStep(features);
|
|
testBookStep(features);
|
|
testTransferRate(features);
|
|
testSelfPayment1(features);
|
|
testSelfPayment2(features);
|
|
testSelfFundedXRPEndpoint(false, features);
|
|
testSelfFundedXRPEndpoint(true, features);
|
|
testUnfundedOffer(features);
|
|
testReExecuteDirectStep(features);
|
|
testSelfPayLowQualityOffer(features);
|
|
}
|
|
|
|
void
|
|
run() override
|
|
{
|
|
using namespace jtx;
|
|
auto const sa = testable_amendments();
|
|
testLimitQuality();
|
|
testXRPPathLoop();
|
|
testWithFeats(sa);
|
|
testEmptyStrand(sa);
|
|
}
|
|
};
|
|
|
|
BEAST_DEFINE_TESTSUITE_PRIO(FlowMPT, app, xrpl, 2);
|
|
|
|
} // namespace xrpl::test
|