rippled
Loading...
Searching...
No Matches
CrossingLimits_test.cpp
1#include <test/jtx.h>
2
3#include <xrpl/beast/unit_test.h>
4#include <xrpl/protocol/Feature.h>
5
6namespace xrpl {
7namespace test {
8
9class CrossingLimits_test : public beast::unit_test::suite
10{
11public:
12 void
13 testStepLimit(FeatureBitset features)
14 {
15 testcase("Step Limit");
16
17 using namespace jtx;
18 Env env(*this, features);
19
20 auto const gw = Account("gateway");
21 auto const USD = gw["USD"];
22
23 env.fund(XRP(100000000), gw, "alice", "bob", "carol", "dan");
24 env.trust(USD(1), "bob");
25 env(pay(gw, "bob", USD(1)));
26 env.trust(USD(1), "dan");
27 env(pay(gw, "dan", USD(1)));
28 n_offers(env, 2000, "bob", XRP(1), USD(1));
29 n_offers(env, 1, "dan", XRP(1), USD(1));
30
31 // Alice offers to buy 1000 XRP for 1000 USD. She takes Bob's first
32 // offer, removes 999 more as unfunded, then hits the step limit.
33 env(offer("alice", USD(1000), XRP(1000)));
34 env.require(balance("alice", USD(1)));
35 env.require(owners("alice", 2));
36 env.require(balance("bob", USD(0)));
37 env.require(owners("bob", 1001));
38 env.require(balance("dan", USD(1)));
39 env.require(owners("dan", 2));
40
41 // Carol offers to buy 1000 XRP for 1000 USD. She removes Bob's next
42 // 1000 offers as unfunded and hits the step limit.
43 env(offer("carol", USD(1000), XRP(1000)));
44 env.require(balance("carol", USD(none)));
45 env.require(owners("carol", 1));
46 env.require(balance("bob", USD(0)));
47 env.require(owners("bob", 1));
48 env.require(balance("dan", USD(1)));
49 env.require(owners("dan", 2));
50 }
51
52 void
53 testCrossingLimit(FeatureBitset features)
54 {
55 testcase("Crossing Limit");
56
57 using namespace jtx;
58 Env env(*this, features);
59
60 auto const gw = Account("gateway");
61 auto const USD = gw["USD"];
62
63 // The payment engine allows 1000 offers to cross.
64 int const maxConsumed = 1000;
65
66 env.fund(XRP(100000000), gw, "alice", "bob", "carol");
67 int const bobOfferCount = maxConsumed + 150;
68 env.trust(USD(bobOfferCount), "bob");
69 env(pay(gw, "bob", USD(bobOfferCount)));
70 env.close();
71 n_offers(env, bobOfferCount, "bob", XRP(1), USD(1));
72
73 // Alice offers to buy Bob's offers. However she hits the offer
74 // crossing limit, so she can't buy them all at once.
75 env(offer("alice", USD(bobOfferCount), XRP(bobOfferCount)));
76 env.close();
77 env.require(balance("alice", USD(maxConsumed)));
78 env.require(balance("bob", USD(150)));
79 env.require(owners("bob", 150 + 1));
80
81 // Carol offers to buy 1000 XRP for 1000 USD. She takes Bob's
82 // remaining 150 offers without hitting a limit.
83 env(offer("carol", USD(1000), XRP(1000)));
84 env.close();
85 env.require(balance("carol", USD(150)));
86 env.require(balance("bob", USD(0)));
87 env.require(owners("bob", 1));
88 }
89
90 void
91 testStepAndCrossingLimit(FeatureBitset features)
92 {
93 testcase("Step And Crossing Limit");
94
95 using namespace jtx;
96 Env env(*this, features);
97
98 auto const gw = Account("gateway");
99 auto const USD = gw["USD"];
100
101 env.fund(XRP(100000000), gw, "alice", "bob", "carol", "dan", "evita");
102
103 // The payment engine allows 1000 offers to cross.
104 int const maxConsumed = 1000;
105
106 int const evitaOfferCount{maxConsumed + 49};
107 env.trust(USD(1000), "alice");
108 env(pay(gw, "alice", USD(1000)));
109 env.trust(USD(1000), "carol");
110 env(pay(gw, "carol", USD(1)));
111 env.trust(USD(evitaOfferCount + 1), "evita");
112 env(pay(gw, "evita", USD(evitaOfferCount + 1)));
113
114 // The payment engine has a limit of 1000 funded or unfunded offers.
115 int const carolsOfferCount{700};
116 n_offers(env, 400, "alice", XRP(1), USD(1));
117 n_offers(env, carolsOfferCount, "carol", XRP(1), USD(1));
118 n_offers(env, evitaOfferCount, "evita", XRP(1), USD(1));
119
120 // Bob offers to buy 1000 XRP for 1000 USD. He takes all 400 USD from
121 // Alice's offers, 1 USD from Carol's and then removes 599 of Carol's
122 // offers as unfunded, before hitting the step limit.
123 env(offer("bob", USD(1000), XRP(1000)));
124 env.require(balance("bob", USD(401)));
125 env.require(balance("alice", USD(600)));
126 env.require(owners("alice", 1));
127 env.require(balance("carol", USD(0)));
128 env.require(owners("carol", carolsOfferCount - 599));
129 env.require(balance("evita", USD(evitaOfferCount + 1)));
130 env.require(owners("evita", evitaOfferCount + 1));
131
132 // Dan offers to buy maxConsumed + 50 XRP USD. He removes all of
133 // Carol's remaining offers as unfunded, then takes
134 // (maxConsumed - 100) USD from Evita's, hitting the crossing limit.
135 env(offer("dan", USD(maxConsumed + 50), XRP(maxConsumed + 50)));
136 env.require(balance("dan", USD(maxConsumed - 100)));
137 env.require(owners("dan", 2));
138 env.require(balance("alice", USD(600)));
139 env.require(owners("alice", 1));
140 env.require(balance("carol", USD(0)));
141 env.require(owners("carol", 1));
142 env.require(balance("evita", USD(150)));
143 env.require(owners("evita", 150));
144 }
145
146 void
147 testAutoBridgedLimitsTaker(FeatureBitset features)
148 {
149 testcase("Auto Bridged Limits Taker");
150
151 using namespace jtx;
152 Env env(*this, features);
153
154 auto const gw = Account("gateway");
155 auto const USD = gw["USD"];
156 auto const EUR = gw["EUR"];
157
158 env.fund(XRP(100000000), gw, "alice", "bob", "carol", "dan", "evita");
159
160 env.trust(USD(2000), "alice");
161 env(pay(gw, "alice", USD(2000)));
162 env.trust(USD(1000), "carol");
163 env(pay(gw, "carol", USD(3)));
164 env.trust(USD(1000), "evita");
165 env(pay(gw, "evita", USD(1000)));
166
167 n_offers(env, 302, "alice", EUR(2), XRP(1));
168 n_offers(env, 300, "alice", XRP(1), USD(4));
169 n_offers(env, 497, "carol", XRP(1), USD(3));
170 n_offers(env, 1001, "evita", EUR(1), USD(1));
171
172 // Bob offers to buy 2000 USD for 2000 EUR, even though he only has
173 // 1000 EUR.
174 // 1. He spends 600 EUR taking Alice's auto-bridged offers and
175 // gets 1200 USD for that.
176 // 2. He spends another 2 EUR taking one of Alice's EUR->XRP and
177 // one of Carol's XRP-USD offers. He gets 3 USD for that.
178 // 3. The remainder of Carol's offers are now unfunded. We've
179 // consumed 602 offers so far. We now chew through 398 more
180 // of Carol's unfunded offers until we hit the 1000 offer limit.
181 // This sets have_bridge to false -- we will handle no more
182 // bridged offers.
183 // 4. However, have_direct is still true. So we go around one more
184 // time and take one of Evita's offers.
185 // 5. After taking one of Evita's offers we notice (again) that our
186 // offer count was exceeded. So we completely stop after taking
187 // one of Evita's offers.
188 env.trust(EUR(10000), "bob");
189 env.close();
190 env(pay(gw, "bob", EUR(1000)));
191 env.close();
192 env(offer("bob", USD(2000), EUR(2000)));
193 env.require(balance("bob", USD(1204)));
194 env.require(balance("bob", EUR(397)));
195
196 env.require(balance("alice", USD(800)));
197 env.require(balance("alice", EUR(602)));
198 env.require(offers("alice", 1));
199 env.require(owners("alice", 3));
200
201 env.require(balance("carol", USD(0)));
202 env.require(balance("carol", EUR(none)));
203 env.require(offers("carol", 100));
204 env.require(owners("carol", 101));
205
206 env.require(balance("evita", USD(999)));
207 env.require(balance("evita", EUR(1)));
208 env.require(offers("evita", 1000));
209 env.require(owners("evita", 1002));
210
211 // Dan offers to buy 900 EUR for 900 USD.
212 // 1. He removes all 100 of Carol's remaining unfunded offers.
213 // 2. Then takes 850 USD from Evita's offers.
214 // 3. Consuming 850 of Evita's funded offers hits the crossing
215 // limit. So Dan's offer crossing stops even though he would
216 // be willing to take another 50 of Evita's offers.
217 env.trust(EUR(10000), "dan");
218 env.close();
219 env(pay(gw, "dan", EUR(1000)));
220 env.close();
221
222 env(offer("dan", USD(900), EUR(900)));
223 env.require(balance("dan", USD(850)));
224 env.require(balance("dan", EUR(150)));
225
226 env.require(balance("alice", USD(800)));
227 env.require(balance("alice", EUR(602)));
228 env.require(offers("alice", 1));
229 env.require(owners("alice", 3));
230
231 env.require(balance("carol", USD(0)));
232 env.require(balance("carol", EUR(none)));
233 env.require(offers("carol", 0));
234 env.require(owners("carol", 1));
235
236 env.require(balance("evita", USD(149)));
237 env.require(balance("evita", EUR(851)));
238 env.require(offers("evita", 150));
239 env.require(owners("evita", 152));
240 }
241
242 void
243 testAutoBridgedLimits(FeatureBitset features)
244 {
245 testcase("Auto Bridged Limits");
246
247 // If any book step in a payment strand consumes 1000 offers, the
248 // liquidity from the offers is used, but that strand will be marked as
249 // dry for the remainder of the transaction.
250
251 using namespace jtx;
252
253 auto const gw = Account("gateway");
254 auto const alice = Account("alice");
255 auto const bob = Account("bob");
256 auto const carol = Account("carol");
257
258 auto const USD = gw["USD"];
259 auto const EUR = gw["EUR"];
260
261 // There are two almost identical tests. There is a strand with a large
262 // number of unfunded offers that will cause the strand to be marked dry
263 // even though there will still be liquidity available on that strand.
264 // In the first test, the strand has the best initial quality. In the
265 // second test the strand does not have the best quality (the
266 // implementation has to handle this case correct and not mark the
267 // strand dry until the liquidity is actually used)
268
269 // The implementation allows any single step to consume at most 1000
270 // offers.If the total number of offers consumed by all the steps
271 // combined exceeds 1500, the payment stops.
272 {
273 Env env(*this, features);
274
275 env.fund(XRP(100000000), gw, alice, bob, carol);
276
277 env.trust(USD(4000), alice);
278 env(pay(gw, alice, USD(4000)));
279 env.trust(USD(1000), carol);
280 env(pay(gw, carol, USD(3)));
281
282 // Notice the strand with the 800 unfunded offers has the initial
283 // best quality
284 n_offers(env, 2000, alice, EUR(2), XRP(1));
285 n_offers(env, 100, alice, XRP(1), USD(4));
286 n_offers(env, 801, carol, XRP(1), USD(3)); // only one offer is funded
287 n_offers(env, 1000, alice, XRP(1), USD(3));
288
289 n_offers(env, 1, alice, EUR(500), USD(500));
290
291 // Bob offers to buy 2000 USD for 2000 EUR; He starts with 2000 EUR
292 // 1. The best quality is the autobridged offers that take 2 EUR
293 // and give 4 USD.
294 // Bob spends 200 EUR and receives 400 USD.
295 // 100 EUR->XRP offers consumed.
296 // 100 XRP->USD offers consumed.
297 // 200 total offers consumed.
298 //
299 // 2. The best quality is the autobridged offers that take 2 EUR
300 // and give 3 USD.
301 // a. One of Carol's offers is taken. This leaves her other
302 // offers unfunded.
303 // b. Carol's remaining 800 offers are consumed as unfunded.
304 // c. 199 of alice's XRP(1) to USD(3) offers are consumed.
305 // A book step is allowed to consume a maximum of 1000 offers
306 // at a given quality, and that limit is now reached.
307 // d. Now the strand is dry, even though there are still funded
308 // XRP(1) to USD(3) offers available.
309 // Bob has spent 400 EUR and received 600 USD in this step.
310 // 200 EUR->XRP offers consumed
311 // 800 unfunded XRP->USD offers consumed
312 // 200 funded XRP->USD offers consumed (1 carol, 199 alice)
313 // 1400 total offers consumed so far (100 left before the
314 // limit)
315 // 3. The best is the non-autobridged offers that takes 500 EUR and
316 // gives 500 USD.
317 // Bob started with 2000 EUR
318 // Bob spent 500 EUR (100+400)
319 // Bob has 1500 EUR left
320 // In this step:
321 // Bob spents 500 EUR and receives 500 USD.
322 // In total:
323 // Bob spent 1100 EUR (200 + 400 + 500)
324 // Bob has 900 EUR remaining (2000 - 1100)
325 // Bob received 1500 USD (400 + 600 + 500)
326 // Alice spent 1497 USD (100*4 + 199*3 + 500)
327 // Alice has 2503 remaining (4000 - 1497)
328 // Alice received 1100 EUR (200 + 400 + 500)
329 env.trust(EUR(10000), bob);
330 env.close();
331 env(pay(gw, bob, EUR(2000)));
332 env.close();
333 env(offer(bob, USD(4000), EUR(4000)));
334 env.close();
335
336 env.require(balance(bob, USD(1500)));
337 env.require(balance(bob, EUR(900)));
338 env.require(offers(bob, 1));
339 env.require(owners(bob, 3));
340
341 env.require(balance(alice, USD(2503)));
342 env.require(balance(alice, EUR(1100)));
343 auto const numAOffers = 2000 + 100 + 1000 + 1 - (2 * 100 + 2 * 199 + 1 + 1);
344 env.require(offers(alice, numAOffers));
345 env.require(owners(alice, numAOffers + 2));
346
347 env.require(offers(carol, 0));
348 }
349 {
350 Env env(*this, features);
351
352 env.fund(XRP(100000000), gw, alice, bob, carol);
353
354 env.trust(USD(4000), alice);
355 env(pay(gw, alice, USD(4000)));
356 env.trust(USD(1000), carol);
357 env(pay(gw, carol, USD(3)));
358
359 // Notice the strand with the 800 unfunded offers does not have the
360 // initial best quality
361 n_offers(env, 1, alice, EUR(1), USD(10));
362 n_offers(env, 2000, alice, EUR(2), XRP(1));
363 n_offers(env, 100, alice, XRP(1), USD(4));
364 n_offers(env, 801, carol, XRP(1), USD(3)); // only one offer is funded
365 n_offers(env, 1000, alice, XRP(1), USD(3));
366
367 n_offers(env, 1, alice, EUR(499), USD(499));
368
369 // Bob offers to buy 2000 USD for 2000 EUR; He starts with 2000 EUR
370 // 1. The best quality is the offer that takes 1 EUR and gives 10
371 // USD
372 // Bob spends 1 EUR and receives 10 USD.
373 //
374 // 2. The best quality is the autobridged offers that takes 2 EUR
375 // and gives 4 USD.
376 // Bob spends 200 EUR and receives 400 USD.
377 //
378 // 3. The best quality is the autobridged offers that takes 2 EUR
379 // and gives 3 USD.
380 // a. One of Carol's offers is taken. This leaves her other
381 // offers unfunded.
382 // b. Carol's remaining 800 offers are consumed as unfunded.
383 // c. 199 of alice's XRP(1) to USD(3) offers are consumed.
384 // A book step is allowed to consume a maximum of 1000 offers
385 // at a given quality, and that limit is now reached.
386 // d. Now the strand is dry, even though there are still funded
387 // XRP(1) to USD(3) offers available. Bob has spent 400 EUR and
388 // received 600 USD in this step. (200 funded offers consumed
389 // 800 unfunded offers)
390 // 4. The best is the non-autobridged offers that takes 499 EUR and
391 // gives 499 USD.
392 // Bob has 2000 EUR, and has spent 1+200+400=601 EUR. He has
393 // 1399 left. Bob spent 499 EUR and receives 499 USD.
394 // In total: Bob spent EUR(1 + 200 + 400 + 499) = EUR(1100). He
395 // started with 2000 so has 900 remaining
396 // Bob received USD(10 + 400 + 600 + 499) = USD(1509).
397 // Alice spent 10 + 100*4 + 199*3 + 499 = 1506 USD. She
398 // started with 4000 so has 2494 USD remaining. Alice
399 // received 200 + 400 + 500 = 1100 EUR
400 env.trust(EUR(10000), bob);
401 env.close();
402 env(pay(gw, bob, EUR(2000)));
403 env.close();
404 env(offer(bob, USD(4000), EUR(4000)));
405 env.close();
406
407 env.require(balance(bob, USD(1509)));
408 env.require(balance(bob, EUR(900)));
409 env.require(offers(bob, 1));
410 env.require(owners(bob, 3));
411
412 env.require(balance(alice, USD(2494)));
413 env.require(balance(alice, EUR(1100)));
414 auto const numAOffers = 1 + 2000 + 100 + 1000 + 1 - (1 + 2 * 100 + 2 * 199 + 1 + 1);
415 env.require(offers(alice, numAOffers));
416 env.require(owners(alice, numAOffers + 2));
417
418 env.require(offers(carol, 0));
419 }
420 }
421
422 void
423 testOfferOverflow(FeatureBitset features)
424 {
425 testcase("Offer Overflow");
426
427 using namespace jtx;
428
429 auto const gw = Account("gateway");
430 auto const alice = Account("alice");
431 auto const bob = Account("bob");
432
433 auto const USD = gw["USD"];
434
435 Env env(*this, features);
436
437 env.fund(XRP(100000000), gw, alice, bob);
438
439 env.trust(USD(8000), alice);
440 env.trust(USD(8000), bob);
441 env.close();
442
443 env(pay(gw, alice, USD(8000)));
444 env.close();
445
446 // The new flow cross handles consuming excessive offers differently
447 // than the old offer crossing code. In the old code, the total number
448 // of consumed offers is tracked, and the crossings will stop after this
449 // limit is hit. In the new code, the number of offers is tracked per
450 // offerbook and per quality. This test shows how they can differ. Set
451 // up a book with many offers. At each quality keep the number of offers
452 // below the limit. However, if all the offers are consumed it would
453 // create a tecOVERSIZE error.
454
455 // The implementation allows any single step to consume at most 1000
456 // offers. If the total number of offers consumed by all the steps
457 // combined exceeds 1500, the payment stops. Since the first set of
458 // offers consumes 998 offers, the second set will consume 998, which is
459 // not over the limit and the payment stops. So 2*998, or 1996 is the
460 // expected value.
461 n_offers(env, 998, alice, XRP(1.00), USD(1));
462 n_offers(env, 998, alice, XRP(0.99), USD(1));
463 n_offers(env, 998, alice, XRP(0.98), USD(1));
464 n_offers(env, 998, alice, XRP(0.97), USD(1));
465 n_offers(env, 998, alice, XRP(0.96), USD(1));
466 n_offers(env, 998, alice, XRP(0.95), USD(1));
467
468 env(offer(bob, USD(8000), XRP(8000)), ter(tesSUCCESS));
469 env.close();
470
471 env.require(balance(bob, USD(1996)));
472 }
473
474 void
475 run() override
476 {
477 auto testAll = [this](FeatureBitset features) {
478 testStepLimit(features);
479 testCrossingLimit(features);
480 testStepAndCrossingLimit(features);
481 testAutoBridgedLimits(features);
482 testOfferOverflow(features);
483 };
484 using namespace jtx;
485 auto const sa = testable_amendments();
486 testAll(sa);
487 testAll(sa - featurePermissionedDEX);
488 }
489};
490
491BEAST_DEFINE_TESTSUITE_MANUAL_PRIO(CrossingLimits, app, xrpl, 10);
492
493} // namespace test
494} // namespace xrpl
beast::unit_test::suite
A testsuite class.
Definition suite.h:51
beast::unit_test::suite::testcase
testcase_t testcase
Memberspace for declaring test cases.
Definition suite.h:147
xrpl::test::CrossingLimits_test
Definition CrossingLimits_test.cpp:10
xrpl::test::CrossingLimits_test::run
void run() override
Runs the suite.
Definition CrossingLimits_test.cpp:475
xrpl::test::CrossingLimits_test::testAutoBridgedLimitsTaker
void testAutoBridgedLimitsTaker(FeatureBitset features)
Definition CrossingLimits_test.cpp:147
xrpl::test::CrossingLimits_test::testStepAndCrossingLimit
void testStepAndCrossingLimit(FeatureBitset features)
Definition CrossingLimits_test.cpp:91
xrpl::test::CrossingLimits_test::testOfferOverflow
void testOfferOverflow(FeatureBitset features)
Definition CrossingLimits_test.cpp:423
xrpl::test::CrossingLimits_test::testAutoBridgedLimits
void testAutoBridgedLimits(FeatureBitset features)
Definition CrossingLimits_test.cpp:243
xrpl::test::CrossingLimits_test::testStepLimit
void testStepLimit(FeatureBitset features)
Definition CrossingLimits_test.cpp:13
xrpl::test::CrossingLimits_test::testCrossingLimit
void testCrossingLimit(FeatureBitset features)
Definition CrossingLimits_test.cpp:53
xrpl::test::jtx::Account
Immutable cryptographic account descriptor.
Definition Account.h:19
xrpl::test::jtx::Env
A transaction testing environment.
Definition Env.h:119
xrpl::test::jtx::Env::close
bool close(NetClock::time_point closeTime, std::optional< std::chrono::milliseconds > consensusDelay=std::nullopt)
Close and advance the ledger.
Definition Env.cpp:98
xrpl::test::jtx::Env::fund
void fund(bool setDefaultRipple, STAmount const &amount, Account const &account)
Definition Env.cpp:261
xrpl::test::jtx::Env::trust
void trust(STAmount const &amount, Account const &account)
Establish trust lines.
Definition Env.cpp:284
xrpl::test::jtx::Env::require
void require(Args const &... args)
Check a set of requirements.
Definition Env.h:533
xrpl::test::jtx::balance
A balance matches.
Definition balance.h:19
xrpl::test::jtx::owners
Match the number of items in the account's owner directory.
Definition owners.h:48
xrpl::test::jtx::ter
Set the expected result code for a JTx The test will fail if the code doesn't match.
Definition ter.h:15
xrpl::test::jtx::XRP
XRP_t const XRP
Converts to XRP Issue or STAmount.
Definition amount.cpp:90
xrpl::test::jtx::pay
Json::Value pay(AccountID const &account, AccountID const &to, AnyAmount amount)
Create a payment.
Definition pay.cpp:11
xrpl::test::jtx::none
static none_t const none
Definition tags.h:14
xrpl::test::jtx::testable_amendments
FeatureBitset testable_amendments()
Definition Env.h:76
xrpl::test::jtx::offers
owner_count< ltOFFER > offers
Match the number of offers in the account's owner directory.
Definition owners.h:66
xrpl::test::jtx::n_offers
void n_offers(Env &env, std::size_t n, Account const &account, STAmount const &in, STAmount const &out)
Definition TestHelpers.cpp:284
xrpl::test::jtx::offer
Json::Value offer(Account const &account, STAmount const &takerPays, STAmount const &takerGets, std::uint32_t flags)
Create an offer.
Definition offer.cpp:10
xrpl
Use hash_* containers for keys that do not need a cryptographically secure hashing algorithm.
Definition algorithm.h:5
xrpl::tesSUCCESS
@ tesSUCCESS
Definition TER.h:225
Generated by doxygen 1.9.8