rippled
Loading...
Searching...
No Matches
Freeze_test.cpp
1#include <test/jtx.h>
2#include <test/jtx/AMM.h>
3
4#include <xrpl/protocol/AccountID.h>
5#include <xrpl/protocol/Feature.h>
6#include <xrpl/protocol/SField.h>
7#include <xrpl/protocol/TxFlags.h>
8#include <xrpl/protocol/jss.h>
9
10namespace xrpl {
11
12class Freeze_test : public beast::unit_test::suite
13{
14 void
15 testRippleState(FeatureBitset features)
16 {
17 testcase("RippleState Freeze");
18
19 using namespace test::jtx;
20 Env env(*this, features);
21
22 Account const G1{"G1"};
23 Account const alice{"alice"};
24 Account const bob{"bob"};
25
26 env.fund(XRP(1000), G1, alice, bob);
27 env.close();
28
29 env.trust(G1["USD"](100), bob);
30 env.trust(G1["USD"](100), alice);
31 env.close();
32
33 env(pay(G1, bob, G1["USD"](10)));
34 env(pay(G1, alice, G1["USD"](100)));
35 env.close();
36
37 env(offer(alice, XRP(500), G1["USD"](100)));
38 env.close();
39
40 {
41 auto lines = getAccountLines(env, bob);
42 if (!BEAST_EXPECT(checkArraySize(lines[jss::lines], 1u)))
43 return;
44 BEAST_EXPECT(lines[jss::lines][0u][jss::account] == G1.human());
45 BEAST_EXPECT(lines[jss::lines][0u][jss::limit] == "100");
46 BEAST_EXPECT(lines[jss::lines][0u][jss::balance] == "10");
47 }
48
49 {
50 auto lines = getAccountLines(env, alice);
51 if (!BEAST_EXPECT(checkArraySize(lines[jss::lines], 1u)))
52 return;
53 BEAST_EXPECT(lines[jss::lines][0u][jss::account] == G1.human());
54 BEAST_EXPECT(lines[jss::lines][0u][jss::limit] == "100");
55 BEAST_EXPECT(lines[jss::lines][0u][jss::balance] == "100");
56 }
57
58 {
59 // Account with line unfrozen (proving operations normally work)
60 // test: can make Payment on that line
61 env(pay(alice, bob, G1["USD"](1)));
62
63 // test: can receive Payment on that line
64 env(pay(bob, alice, G1["USD"](1)));
65 env.close();
66 }
67
68 {
69 // Is created via a TrustSet with SetFreeze flag
70 // test: sets LowFreeze | HighFreeze flags
71 env(trust(G1, bob["USD"](0), tfSetFreeze));
72 auto affected = env.meta()->getJson(JsonOptions::none)[sfAffectedNodes.fieldName];
73 if (!BEAST_EXPECT(checkArraySize(affected, 2u)))
74 return;
75 auto ff = affected[1u][sfModifiedNode.fieldName][sfFinalFields.fieldName];
76 BEAST_EXPECT(
77 ff[sfLowLimit.fieldName] == G1["USD"](0).value().getJson(JsonOptions::none));
78 BEAST_EXPECT(ff[jss::Flags].asUInt() & lsfLowFreeze);
79 BEAST_EXPECT(!(ff[jss::Flags].asUInt() & lsfHighFreeze));
80 env.close();
81 }
82
83 {
84 // Account with line frozen by issuer
85 // test: can buy more assets on that line
86 env(offer(bob, G1["USD"](5), XRP(25)));
87 auto affected = env.meta()->getJson(JsonOptions::none)[sfAffectedNodes.fieldName];
88 if (!BEAST_EXPECT(checkArraySize(affected, 5u)))
89 return;
90 auto ff = affected[3u][sfModifiedNode.fieldName][sfFinalFields.fieldName];
91 BEAST_EXPECT(
92 ff[sfHighLimit.fieldName] == bob["USD"](100).value().getJson(JsonOptions::none));
93 auto amt = STAmount{Issue{to_currency("USD"), noAccount()}, -15}.value().getJson(
94 JsonOptions::none);
95 BEAST_EXPECT(ff[sfBalance.fieldName] == amt);
96 env.close();
97 }
98
99 {
100 // test: can not sell assets from that line
101 env(offer(bob, XRP(1), G1["USD"](5)), ter(tecUNFUNDED_OFFER));
102
103 // test: can receive Payment on that line
104 env(pay(alice, bob, G1["USD"](1)));
105
106 // test: can not make Payment from that line
107 env(pay(bob, alice, G1["USD"](1)), ter(tecPATH_DRY));
108 }
109
110 {
111 // check G1 account lines
112 // test: shows freeze
113 auto lines = getAccountLines(env, G1);
114 Json::Value bobLine;
115 for (auto const& it : lines[jss::lines])
116 {
117 if (it[jss::account] == bob.human())
118 {
119 bobLine = it;
120 break;
121 }
122 }
123 if (!BEAST_EXPECT(bobLine))
124 return;
125 BEAST_EXPECT(bobLine[jss::freeze] == true);
126 BEAST_EXPECT(bobLine[jss::balance] == "-16");
127 }
128
129 {
130 // test: shows freeze peer
131 auto lines = getAccountLines(env, bob);
132 Json::Value g1Line;
133 for (auto const& it : lines[jss::lines])
134 {
135 if (it[jss::account] == G1.human())
136 {
137 g1Line = it;
138 break;
139 }
140 }
141 if (!BEAST_EXPECT(g1Line))
142 return;
143 BEAST_EXPECT(g1Line[jss::freeze_peer] == true);
144 BEAST_EXPECT(g1Line[jss::balance] == "16");
145 }
146
147 {
148 // Is cleared via a TrustSet with ClearFreeze flag
149 // test: sets LowFreeze | HighFreeze flags
150 env(trust(G1, bob["USD"](0), tfClearFreeze));
151 auto affected = env.meta()->getJson(JsonOptions::none)[sfAffectedNodes.fieldName];
152 if (!BEAST_EXPECT(checkArraySize(affected, 2u)))
153 return;
154 auto ff = affected[1u][sfModifiedNode.fieldName][sfFinalFields.fieldName];
155 BEAST_EXPECT(
156 ff[sfLowLimit.fieldName] == G1["USD"](0).value().getJson(JsonOptions::none));
157 BEAST_EXPECT(!(ff[jss::Flags].asUInt() & lsfLowFreeze));
158 BEAST_EXPECT(!(ff[jss::Flags].asUInt() & lsfHighFreeze));
159 env.close();
160 }
161 }
162
163 void
164 testDeepFreeze(FeatureBitset features)
165 {
166 testcase("Deep Freeze");
167
168 using namespace test::jtx;
169 Env env(*this, features);
170
171 Account const G1{"G1"};
172 Account const A1{"A1"};
173
174 env.fund(XRP(10000), G1, A1);
175 env.close();
176
177 env.trust(G1["USD"](1000), A1);
178 env.close();
179
180 if (features[featureDeepFreeze])
181 {
182 // test: Issuer deep freezing the trust line in a single
183 // transaction
184 env(trust(G1, A1["USD"](0), tfSetFreeze | tfSetDeepFreeze));
185 {
186 auto const flags = getTrustlineFlags(env, 2u, 1u);
187 BEAST_EXPECT(flags & lsfLowFreeze);
188 BEAST_EXPECT(flags & lsfLowDeepFreeze);
189 BEAST_EXPECT(!(flags & (lsfHighFreeze | lsfHighDeepFreeze)));
190 env.close();
191 }
192
193 // test: Issuer clearing deep freeze and normal freeze in a single
194 // transaction
195 env(trust(G1, A1["USD"](0), tfClearFreeze | tfClearDeepFreeze));
196 {
197 auto const flags = getTrustlineFlags(env, 2u, 1u);
198 BEAST_EXPECT(!(flags & (lsfLowFreeze | lsfLowDeepFreeze)));
199 BEAST_EXPECT(!(flags & (lsfHighFreeze | lsfHighDeepFreeze)));
200 env.close();
201 }
202
203 // test: Issuer deep freezing not already frozen line must fail
204 env(trust(G1, A1["USD"](0), tfSetDeepFreeze), ter(tecNO_PERMISSION));
205
206 env(trust(G1, A1["USD"](0), tfSetFreeze));
207 env.close();
208
209 // test: Issuer deep freezing already frozen trust line
210 env(trust(G1, A1["USD"](0), tfSetDeepFreeze));
211 {
212 auto const flags = getTrustlineFlags(env, 2u, 1u);
213 BEAST_EXPECT(flags & lsfLowFreeze);
214 BEAST_EXPECT(flags & lsfLowDeepFreeze);
215 BEAST_EXPECT(!(flags & (lsfHighFreeze | lsfHighDeepFreeze)));
216 env.close();
217 }
218
219 // test: Holder clearing freeze flags has no effect. Each sides'
220 // flags are independent
221 env(trust(A1, G1["USD"](0), tfClearFreeze | tfClearDeepFreeze));
222 {
223 auto const flags = getTrustlineFlags(env, 2u, 1u);
224 BEAST_EXPECT(flags & lsfLowFreeze);
225 BEAST_EXPECT(flags & lsfLowDeepFreeze);
226 BEAST_EXPECT(!(flags & (lsfHighFreeze | lsfHighDeepFreeze)));
227 env.close();
228 }
229
230 // test: Issuer can't clear normal freeze when line is deep frozen
231 env(trust(G1, A1["USD"](0), tfClearFreeze), ter(tecNO_PERMISSION));
232
233 // test: Issuer clearing deep freeze but normal freeze is still in
234 // effect
235 env(trust(G1, A1["USD"](0), tfClearDeepFreeze));
236 {
237 auto const flags = getTrustlineFlags(env, 2u, 1u);
238 BEAST_EXPECT(flags & lsfLowFreeze);
239 BEAST_EXPECT(!(flags & lsfLowDeepFreeze));
240 BEAST_EXPECT(!(flags & (lsfHighFreeze | lsfHighDeepFreeze)));
241 env.close();
242 }
243 }
244 else
245 {
246 // test: applying deep freeze before amendment fails
247 env(trust(G1, A1["USD"](0), tfSetDeepFreeze), ter(temINVALID_FLAG));
248
249 // test: clearing deep freeze before amendment fails
250 env(trust(G1, A1["USD"](0), tfClearDeepFreeze), ter(temINVALID_FLAG));
251 }
252 }
253
254 void
255 testCreateFrozenTrustline(FeatureBitset features)
256 {
257 testcase("Create Frozen Trustline");
258
259 using namespace test::jtx;
260 Env env(*this, features);
261
262 Account const G1{"G1"};
263 Account const A1{"A1"};
264
265 env.fund(XRP(10000), G1, A1);
266 env.close();
267
268 // test: can create frozen trustline
269 {
270 env(trust(G1, A1["USD"](1000), tfSetFreeze));
271 auto const flags = getTrustlineFlags(env, 5u, 3u, false);
272 BEAST_EXPECT(flags & lsfLowFreeze);
273 env.close();
274 env.require(lines(A1, 1));
275 }
276
277 // Cleanup
278 env(trust(G1, A1["USD"](0), tfClearFreeze));
279 env.close();
280 env.require(lines(G1, 0));
281 env.require(lines(A1, 0));
282
283 // test: cannot create deep frozen trustline without normal freeze
284 if (features[featureDeepFreeze])
285 {
286 env(trust(G1, A1["USD"](1000), tfSetDeepFreeze), ter(tecNO_PERMISSION));
287 env.close();
288 env.require(lines(A1, 0));
289 }
290
291 // test: can create deep frozen trustline together with normal freeze
292 if (features[featureDeepFreeze])
293 {
294 env(trust(G1, A1["USD"](1000), tfSetFreeze | tfSetDeepFreeze));
295 auto const flags = getTrustlineFlags(env, 5u, 3u, false);
296 BEAST_EXPECT(flags & lsfLowFreeze);
297 BEAST_EXPECT(flags & lsfLowDeepFreeze);
298 env.close();
299 env.require(lines(A1, 1));
300 }
301 }
302
303 void
304 testSetAndClear(FeatureBitset features)
305 {
306 testcase("Freeze Set and Clear");
307
308 using namespace test::jtx;
309 Env env(*this, features);
310
311 Account const G1{"G1"};
312 Account const A1{"A1"};
313
314 env.fund(XRP(10000), G1, A1);
315 env.close();
316
317 env.trust(G1["USD"](1000), A1);
318 env.close();
319
320 if (features[featureDeepFreeze])
321 {
322 // test: can't have both set and clear flag families in the same
323 // transaction
324 env(trust(G1, A1["USD"](0), tfSetFreeze | tfClearFreeze), ter(tecNO_PERMISSION));
325 env(trust(G1, A1["USD"](0), tfSetFreeze | tfClearDeepFreeze), ter(tecNO_PERMISSION));
326 env(trust(G1, A1["USD"](0), tfSetDeepFreeze | tfClearFreeze), ter(tecNO_PERMISSION));
327 env(trust(G1, A1["USD"](0), tfSetDeepFreeze | tfClearDeepFreeze),
328 ter(tecNO_PERMISSION));
329 }
330 else
331 {
332 // test: old behavior, transaction succeed with no effect on a
333 // trust line
334 env(trust(G1, A1["USD"](0), tfSetFreeze | tfClearFreeze));
335 {
336 auto affected = env.meta()->getJson(JsonOptions::none)[sfAffectedNodes.fieldName];
337 BEAST_EXPECT(checkArraySize(affected, 1u)); // means no trustline changes
338 }
339 }
340 }
341
342 void
343 testGlobalFreeze(FeatureBitset features)
344 {
345 testcase("Global Freeze");
346
347 using namespace test::jtx;
348 Env env(*this, features);
349
350 Account const G1{"G1"};
351 Account const A1{"A1"};
352 Account const A2{"A2"};
353 Account const A3{"A3"};
354 Account const A4{"A4"};
355
356 env.fund(XRP(12000), G1);
357 env.fund(XRP(1000), A1);
358 env.fund(XRP(20000), A2, A3, A4);
359 env.close();
360
361 env.trust(G1["USD"](1200), A1);
362 env.trust(G1["USD"](200), A2);
363 env.trust(G1["BTC"](100), A3);
364 env.trust(G1["BTC"](100), A4);
365 env.close();
366
367 env(pay(G1, A1, G1["USD"](1000)));
368 env(pay(G1, A2, G1["USD"](100)));
369 env(pay(G1, A3, G1["BTC"](100)));
370 env(pay(G1, A4, G1["BTC"](100)));
371 env.close();
372
373 env(offer(G1, XRP(10000), G1["USD"](100)), txflags(tfPassive));
374 env(offer(G1, G1["USD"](100), XRP(10000)), txflags(tfPassive));
375 env(offer(A1, XRP(10000), G1["USD"](100)), txflags(tfPassive));
376 env(offer(A2, G1["USD"](100), XRP(10000)), txflags(tfPassive));
377 env.close();
378
379 {
380 // Is toggled via AccountSet using SetFlag and ClearFlag
381 // test: SetFlag GlobalFreeze
382 env.require(nflags(G1, asfGlobalFreeze));
383 env(fset(G1, asfGlobalFreeze));
384 env.require(flags(G1, asfGlobalFreeze));
385 env.require(nflags(G1, asfNoFreeze));
386
387 // test: ClearFlag GlobalFreeze
388 env(fclear(G1, asfGlobalFreeze));
389 env.require(nflags(G1, asfGlobalFreeze));
390 env.require(nflags(G1, asfNoFreeze));
391 }
392
393 {
394 // Account without GlobalFreeze (proving operations normally work)
395 // test: visible offers where taker_pays is unfrozen issuer
396 auto offers = env.rpc(
397 "book_offers", std::string("USD/") + G1.human(), "XRP")[jss::result][jss::offers];
398 if (!BEAST_EXPECT(checkArraySize(offers, 2u)))
399 return;
400 std::set<std::string> accounts;
401 for (auto const& offer : offers)
402 {
403 accounts.insert(offer[jss::Account].asString());
404 }
405 BEAST_EXPECT(accounts.find(A2.human()) != std::end(accounts));
406 BEAST_EXPECT(accounts.find(G1.human()) != std::end(accounts));
407
408 // test: visible offers where taker_gets is unfrozen issuer
409 offers = env.rpc(
410 "book_offers", "XRP", std::string("USD/") + G1.human())[jss::result][jss::offers];
411 if (!BEAST_EXPECT(checkArraySize(offers, 2u)))
412 return;
413 accounts.clear();
414 for (auto const& offer : offers)
415 {
416 accounts.insert(offer[jss::Account].asString());
417 }
418 BEAST_EXPECT(accounts.find(A1.human()) != std::end(accounts));
419 BEAST_EXPECT(accounts.find(G1.human()) != std::end(accounts));
420 }
421
422 {
423 // Offers/Payments
424 // test: assets can be bought on the market
425 env(offer(A3, G1["BTC"](1), XRP(1)));
426
427 // test: assets can be sold on the market
428 env(offer(A4, XRP(1), G1["BTC"](1)));
429
430 // test: direct issues can be sent
431 env(pay(G1, A2, G1["USD"](1)));
432
433 // test: direct redemptions can be sent
434 env(pay(A2, G1, G1["USD"](1)));
435
436 // test: via rippling can be sent
437 env(pay(A2, A1, G1["USD"](1)));
438
439 // test: via rippling can be sent back
440 env(pay(A1, A2, G1["USD"](1)));
441 }
442
443 {
444 // Account with GlobalFreeze
445 // set GlobalFreeze first
446 // test: SetFlag GlobalFreeze will toggle back to freeze
447 env.require(nflags(G1, asfGlobalFreeze));
448 env(fset(G1, asfGlobalFreeze));
449 env.require(flags(G1, asfGlobalFreeze));
450 env.require(nflags(G1, asfNoFreeze));
451
452 // test: assets can't be bought on the market
453 env(offer(A3, G1["BTC"](1), XRP(1)), ter(tecFROZEN));
454
455 // test: assets can't be sold on the market
456 env(offer(A4, XRP(1), G1["BTC"](1)), ter(tecFROZEN));
457 }
458
459 {
460 // offers are filtered (seems to be broken?)
461 // test: account_offers always shows own offers
462 auto offers = getAccountOffers(env, G1)[jss::offers];
463 if (!BEAST_EXPECT(checkArraySize(offers, 2u)))
464 return;
465
466 // test: book_offers shows offers
467 // (should these actually be filtered?)
468 offers = env.rpc(
469 "book_offers", "XRP", std::string("USD/") + G1.human())[jss::result][jss::offers];
470 if (!BEAST_EXPECT(checkArraySize(offers, 2u)))
471 return;
472
473 offers = env.rpc(
474 "book_offers", std::string("USD/") + G1.human(), "XRP")[jss::result][jss::offers];
475 if (!BEAST_EXPECT(checkArraySize(offers, 2u)))
476 return;
477 }
478
479 {
480 // Payments
481 // test: direct issues can be sent
482 env(pay(G1, A2, G1["USD"](1)));
483
484 // test: direct redemptions can be sent
485 env(pay(A2, G1, G1["USD"](1)));
486
487 // test: via rippling cant be sent
488 env(pay(A2, A1, G1["USD"](1)), ter(tecPATH_DRY));
489 }
490 }
491
492 void
493 testNoFreeze(FeatureBitset features)
494 {
495 testcase("No Freeze");
496
497 using namespace test::jtx;
498 Env env(*this, features);
499
500 Account const G1{"G1"};
501 Account const A1{"A1"};
502 Account const frozenAcc{"A2"};
503 Account const deepFrozenAcc{"A3"};
504
505 env.fund(XRP(12000), G1);
506 env.fund(XRP(1000), A1);
507 env.fund(XRP(1000), frozenAcc);
508 env.fund(XRP(1000), deepFrozenAcc);
509 env.close();
510
511 env.trust(G1["USD"](1000), A1);
512 env.trust(G1["USD"](1000), frozenAcc);
513 env.trust(G1["USD"](1000), deepFrozenAcc);
514 env.close();
515
516 env(pay(G1, A1, G1["USD"](1000)));
517 env(pay(G1, frozenAcc, G1["USD"](1000)));
518 env(pay(G1, deepFrozenAcc, G1["USD"](1000)));
519
520 // Freezing and deep freezing some of the trust lines to check deep
521 // freeze and clearing of freeze separately
522 env(trust(G1, frozenAcc["USD"](0), tfSetFreeze));
523 {
524 auto const flags = getTrustlineFlags(env, 2u, 1u);
525 BEAST_EXPECT(flags & lsfLowFreeze);
526 BEAST_EXPECT(!(flags & lsfHighFreeze));
527 }
528 if (features[featureDeepFreeze])
529 {
530 env(trust(G1, deepFrozenAcc["USD"](0), tfSetFreeze | tfSetDeepFreeze));
531 {
532 auto const flags = getTrustlineFlags(env, 2u, 1u);
533 BEAST_EXPECT(!(flags & (lsfLowFreeze | lsfLowDeepFreeze)));
534 BEAST_EXPECT(flags & lsfHighFreeze);
535 BEAST_EXPECT(flags & lsfHighDeepFreeze);
536 }
537 }
538 env.close();
539
540 // TrustSet NoFreeze
541 // test: should set NoFreeze in Flags
542 env.require(nflags(G1, asfNoFreeze));
543 env(fset(G1, asfNoFreeze));
544 env.require(flags(G1, asfNoFreeze));
545 env.require(nflags(G1, asfGlobalFreeze));
546
547 // test: cannot be cleared
548 env(fclear(G1, asfNoFreeze));
549 env.require(flags(G1, asfNoFreeze));
550 env.require(nflags(G1, asfGlobalFreeze));
551
552 // test: can set GlobalFreeze
553 env(fset(G1, asfGlobalFreeze));
554 env.require(flags(G1, asfNoFreeze));
555 env.require(flags(G1, asfGlobalFreeze));
556
557 // test: cannot unset GlobalFreeze
558 env(fclear(G1, asfGlobalFreeze));
559 env.require(flags(G1, asfNoFreeze));
560 env.require(flags(G1, asfGlobalFreeze));
561
562 // test: trustlines can't be frozen when no freeze enacted
563 if (features[featureDeepFreeze])
564 {
565 env(trust(G1, A1["USD"](0), tfSetFreeze), ter(tecNO_PERMISSION));
566
567 // test: cannot deep freeze already frozen line when no freeze
568 // enacted
569 env(trust(G1, frozenAcc["USD"](0), tfSetDeepFreeze), ter(tecNO_PERMISSION));
570 }
571 else
572 {
573 // test: previous functionality, checking there's no changes to a
574 // trust line
575 env(trust(G1, A1["USD"](0), tfSetFreeze));
576 auto affected = env.meta()->getJson(JsonOptions::none)[sfAffectedNodes.fieldName];
577 if (!BEAST_EXPECT(checkArraySize(affected, 1u)))
578 return;
579
580 auto let = affected[0u][sfModifiedNode.fieldName][sfLedgerEntryType.fieldName];
581 BEAST_EXPECT(let == jss::AccountRoot);
582 }
583
584 // test: can clear freeze on account
585 env(trust(G1, frozenAcc["USD"](0), tfClearFreeze));
586 {
587 auto const flags = getTrustlineFlags(env, 2u, 1u);
588 BEAST_EXPECT(!(flags & lsfLowFreeze));
589 }
590
591 if (features[featureDeepFreeze])
592 {
593 // test: can clear deep freeze on account
594 env(trust(G1, deepFrozenAcc["USD"](0), tfClearDeepFreeze));
595 {
596 auto const flags = getTrustlineFlags(env, 2u, 1u);
597 BEAST_EXPECT(flags & lsfHighFreeze);
598 BEAST_EXPECT(!(flags & lsfHighDeepFreeze));
599 }
600 }
601 }
602
603 void
604 testOffersWhenFrozen(FeatureBitset features)
605 {
606 testcase("Offers for Frozen Trust Lines");
607
608 using namespace test::jtx;
609 Env env(*this, features);
610
611 Account const G1{"G1"};
612 Account const A2{"A2"};
613 Account const A3{"A3"};
614 Account const A4{"A4"};
615
616 env.fund(XRP(1000), G1, A3, A4);
617 env.fund(XRP(2000), A2);
618 env.close();
619
620 env.trust(G1["USD"](1000), A2);
621 env.trust(G1["USD"](2000), A3);
622 env.trust(G1["USD"](2000), A4);
623 env.close();
624
625 env(pay(G1, A3, G1["USD"](2000)));
626 env(pay(G1, A4, G1["USD"](2000)));
627 env.close();
628
629 env(offer(A3, XRP(1000), G1["USD"](1000)), txflags(tfPassive));
630 env.close();
631
632 // removal after successful payment
633 // test: make a payment with partially consuming offer
634 env(pay(A2, G1, G1["USD"](1)), paths(G1["USD"]), sendmax(XRP(1)));
635 env.close();
636
637 // test: offer was only partially consumed
638 auto offers = getAccountOffers(env, A3)[jss::offers];
639 if (!BEAST_EXPECT(checkArraySize(offers, 1u)))
640 return;
641 BEAST_EXPECT(
642 offers[0u][jss::taker_gets] == G1["USD"](999).value().getJson(JsonOptions::none));
643
644 // test: someone else creates an offer providing liquidity
645 env(offer(A4, XRP(999), G1["USD"](999)));
646 env.close();
647
648 // test: owner of partially consumed offers line is frozen
649 env(trust(G1, A3["USD"](0), tfSetFreeze));
650 auto affected = env.meta()->getJson(JsonOptions::none)[sfAffectedNodes.fieldName];
651 if (!BEAST_EXPECT(checkArraySize(affected, 2u)))
652 return;
653 auto ff = affected[1u][sfModifiedNode.fieldName][sfFinalFields.fieldName];
654 BEAST_EXPECT(ff[sfHighLimit.fieldName] == G1["USD"](0).value().getJson(JsonOptions::none));
655 BEAST_EXPECT(!(ff[jss::Flags].asUInt() & lsfLowFreeze));
656 BEAST_EXPECT(ff[jss::Flags].asUInt() & lsfHighFreeze);
657 env.close();
658
659 // verify offer on the books
660 offers = getAccountOffers(env, A3)[jss::offers];
661 if (!BEAST_EXPECT(checkArraySize(offers, 1u)))
662 return;
663
664 // test: Can make a payment via the new offer
665 env(pay(A2, G1, G1["USD"](1)), paths(G1["USD"]), sendmax(XRP(1)));
666 env.close();
667
668 // test: Partially consumed offer was removed by tes* payment
669 offers = getAccountOffers(env, A3)[jss::offers];
670 if (!BEAST_EXPECT(checkArraySize(offers, 0u)))
671 return;
672
673 // removal buy successful OfferCreate
674 // test: freeze the new offer
675 env(trust(G1, A4["USD"](0), tfSetFreeze));
676 affected = env.meta()->getJson(JsonOptions::none)[sfAffectedNodes.fieldName];
677 if (!BEAST_EXPECT(checkArraySize(affected, 2u)))
678 return;
679 ff = affected[0u][sfModifiedNode.fieldName][sfFinalFields.fieldName];
680 BEAST_EXPECT(ff[sfLowLimit.fieldName] == G1["USD"](0).value().getJson(JsonOptions::none));
681 BEAST_EXPECT(ff[jss::Flags].asUInt() & lsfLowFreeze);
682 BEAST_EXPECT(!(ff[jss::Flags].asUInt() & lsfHighFreeze));
683 env.close();
684
685 // test: can no longer create a crossing offer
686 env(offer(A2, G1["USD"](999), XRP(999)));
687 affected = env.meta()->getJson(JsonOptions::none)[sfAffectedNodes.fieldName];
688 if (!BEAST_EXPECT(checkArraySize(affected, 8u)))
689 return;
690 auto created = affected[0u][sfCreatedNode.fieldName];
691 BEAST_EXPECT(created[sfNewFields.fieldName][jss::Account] == A2.human());
692 env.close();
693
694 // test: offer was removed by offer_create
695 offers = getAccountOffers(env, A4)[jss::offers];
696 if (!BEAST_EXPECT(checkArraySize(offers, 0u)))
697 return;
698 }
699
700 void
701 testOffersWhenDeepFrozen(FeatureBitset features)
702 {
703 testcase("Offers on frozen trust lines");
704
705 using namespace test::jtx;
706 Env env(*this, features);
707
708 Account const G1{"G1"};
709 Account const A1{"A1"};
710 Account const A2{"A2"};
711 Account const A3{"A3"};
712 auto const USD{G1["USD"]};
713
714 env.fund(XRP(10000), G1, A1, A2, A3);
715 env.close();
716
717 auto const limit = USD(10000);
718 env.trust(limit, A1, A2, A3);
719 env.close();
720
721 env(pay(G1, A1, USD(1000)));
722 env(pay(G1, A2, USD(1000)));
723 env.close();
724
725 // Making large passive sell offer
726 // Wants to sell 50 USD for 100 XRP
727 env(offer(A2, XRP(100), USD(50)), txflags(tfPassive));
728 env.close();
729 // Making large passive buy offer
730 // Wants to buy 100 USD for 100 XRP
731 env(offer(A3, USD(100), XRP(100)), txflags(tfPassive));
732 env.close();
733 env.require(offers(A2, 1), offers(A3, 1));
734
735 // Checking A1 can buy from A2 by crossing it's offer
736 env(offer(A1, USD(1), XRP(2)), txflags(tfFillOrKill));
737 env.close();
738 env.require(balance(A1, USD(1001)), balance(A2, USD(999)));
739
740 // Checking A1 can sell to A3 by crossing it's offer
741 env(offer(A1, XRP(1), USD(1)), txflags(tfFillOrKill));
742 env.close();
743 env.require(balance(A1, USD(1000)), balance(A3, USD(1)));
744
745 // Testing aggressive and passive offer placing, trustline frozen by
746 // the issuer
747 {
748 env(trust(G1, A1["USD"](0), tfSetFreeze));
749 env.close();
750
751 // test: can still make passive buy offer
752 env(offer(A1, USD(1), XRP(0.5)), txflags(tfPassive));
753 env.close();
754 env.require(balance(A1, USD(1000)), offers(A1, 1));
755 // Cleanup
756 env(offer_cancel(A1, env.seq(A1) - 1));
757 env.require(offers(A1, 0));
758 env.close();
759
760 // test: can still buy from A2
761 env(offer(A1, USD(1), XRP(2)), txflags(tfFillOrKill));
762 env.close();
763 env.require(balance(A1, USD(1001)), balance(A2, USD(998)), offers(A1, 0));
764
765 // test: cannot create passive sell offer
766 env(offer(A1, XRP(2), USD(1)), txflags(tfPassive), ter(tecUNFUNDED_OFFER));
767 env.close();
768 env.require(balance(A1, USD(1001)), offers(A1, 0));
769
770 // test: cannot sell to A3
771 env(offer(A1, XRP(1), USD(1)), txflags(tfFillOrKill), ter(tecUNFUNDED_OFFER));
772 env.close();
773 env.require(balance(A1, USD(1001)), offers(A1, 0));
774
775 env(trust(G1, A1["USD"](0), tfClearFreeze));
776 env.close();
777 }
778
779 // Testing aggressive and passive offer placing, trustline deep frozen
780 // by the issuer
781 if (features[featureDeepFreeze])
782 {
783 env(trust(G1, A1["USD"](0), tfSetFreeze | tfSetDeepFreeze));
784 env.close();
785
786 // test: cannot create passive buy offer
787 env(offer(A1, USD(1), XRP(0.5)), txflags(tfPassive), ter(tecFROZEN));
788 env.close();
789
790 // test: cannot buy from A2
791 env(offer(A1, USD(1), XRP(2)), txflags(tfFillOrKill), ter(tecFROZEN));
792 env.close();
793
794 // test: cannot create passive sell offer
795 env(offer(A1, XRP(2), USD(1)), txflags(tfPassive), ter(tecUNFUNDED_OFFER));
796 env.close();
797
798 // test: cannot sell to A3
799 env(offer(A1, XRP(1), USD(1)), txflags(tfFillOrKill), ter(tecUNFUNDED_OFFER));
800 env.close();
801
802 env(trust(G1, A1["USD"](0), tfClearFreeze | tfClearDeepFreeze));
803 env.close();
804 env.require(balance(A1, USD(1001)), offers(A1, 0));
805 }
806
807 // Testing already existing offers behavior after trustline is frozen by
808 // the issuer
809 {
810 env.require(balance(A1, USD(1001)));
811 env(offer(A1, XRP(1.9), USD(1)));
812 env(offer(A1, USD(1), XRP(1.1)));
813 env.close();
814 env.require(balance(A1, USD(1001)), offers(A1, 2));
815
816 env(trust(G1, A1["USD"](0), tfSetFreeze));
817 env.close();
818
819 // test: A2 wants to sell to A1, must succeed
820 env.require(balance(A1, USD(1001)), balance(A2, USD(998)));
821 env(offer(A2, XRP(1.1), USD(1)), txflags(tfFillOrKill));
822 env.close();
823 env.require(balance(A1, USD(1002)), balance(A2, USD(997)), offers(A1, 1));
824
825 // test: A3 wants to buy from A1, must fail
826 env.require(balance(A1, USD(1002)), balance(A3, USD(1)), offers(A1, 1));
827 env(offer(A3, USD(1), XRP(1.9)), txflags(tfFillOrKill), ter(tecKILLED));
828 env.close();
829 env.require(balance(A1, USD(1002)), balance(A3, USD(1)), offers(A1, 0));
830
831 env(trust(G1, A1["USD"](0), tfClearFreeze));
832 env.close();
833 }
834
835 // Testing existing offers behavior after trustline is deep frozen by
836 // the issuer
837 if (features[featureDeepFreeze])
838 {
839 env.require(balance(A1, USD(1002)));
840 env(offer(A1, XRP(1.9), USD(1)));
841 env(offer(A1, USD(1), XRP(1.1)));
842 env.close();
843 env.require(balance(A1, USD(1002)), offers(A1, 2));
844
845 env(trust(G1, A1["USD"](0), tfSetFreeze | tfSetDeepFreeze));
846 env.close();
847
848 // test: A2 wants to sell to A1, must fail
849 env.require(balance(A1, USD(1002)), balance(A2, USD(997)));
850 env(offer(A2, XRP(1.1), USD(1)), txflags(tfFillOrKill), ter(tecKILLED));
851 env.close();
852 env.require(balance(A1, USD(1002)), balance(A2, USD(997)), offers(A1, 1));
853
854 // test: A3 wants to buy from A1, must fail
855 env.require(balance(A1, USD(1002)), balance(A3, USD(1)), offers(A1, 1));
856 env(offer(A3, USD(1), XRP(1.9)), txflags(tfFillOrKill), ter(tecKILLED));
857 env.close();
858 env.require(balance(A1, USD(1002)), balance(A3, USD(1)), offers(A1, 0));
859
860 env(trust(G1, A1["USD"](0), tfClearFreeze | tfClearDeepFreeze));
861 env.close();
862 }
863
864 // Testing aggressive and passive offer placing, trustline frozen by
865 // the holder
866 {
867 env(trust(A1, limit, tfSetFreeze));
868 env.close();
869
870 // test: A1 can make passive buy offer
871 env(offer(A1, USD(1), XRP(0.5)), txflags(tfPassive));
872 env.close();
873 env.require(balance(A1, USD(1002)), offers(A1, 1));
874 // Cleanup
875 env(offer_cancel(A1, env.seq(A1) - 1));
876 env.require(offers(A1, 0));
877 env.close();
878
879 // test: A1 wants to buy, must fail
880 env(offer(A1, USD(1), XRP(2)), txflags(tfFillOrKill), ter(tecKILLED));
881 env.close();
882 env.require(balance(A1, USD(1002)), balance(A2, USD(997)), offers(A1, 0));
883
884 // test: A1 can create passive sell offer
885 env(offer(A1, XRP(2), USD(1)), txflags(tfPassive));
886 env.close();
887 env.require(balance(A1, USD(1002)), offers(A1, 1));
888 // Cleanup
889 env(offer_cancel(A1, env.seq(A1) - 1));
890 env.require(offers(A1, 0));
891 env.close();
892
893 // test: A1 can sell to A3
894 env(offer(A1, XRP(1), USD(1)), txflags(tfFillOrKill));
895 env.close();
896 env.require(balance(A1, USD(1001)), offers(A1, 0));
897
898 env(trust(A1, limit, tfClearFreeze));
899 env.close();
900 }
901
902 // Testing aggressive and passive offer placing, trustline deep frozen
903 // by the holder
904 if (features[featureDeepFreeze])
905 {
906 env(trust(A1, limit, tfSetFreeze | tfSetDeepFreeze));
907 env.close();
908
909 // test: A1 cannot create passive buy offer
910 env(offer(A1, USD(1), XRP(0.5)), txflags(tfPassive), ter(tecFROZEN));
911 env.close();
912
913 // test: A1 cannot buy, must fail
914 env(offer(A1, USD(1), XRP(2)), txflags(tfFillOrKill), ter(tecFROZEN));
915 env.close();
916
917 // test: A1 cannot create passive sell offer
918 env(offer(A1, XRP(2), USD(1)), txflags(tfPassive), ter(tecUNFUNDED_OFFER));
919 env.close();
920
921 // test: A1 cannot sell to A3
922 env(offer(A1, XRP(1), USD(1)), txflags(tfFillOrKill), ter(tecUNFUNDED_OFFER));
923 env.close();
924
925 env(trust(A1, limit, tfClearFreeze | tfClearDeepFreeze));
926 env.close();
927 }
928 }
929
930 void
931 testPathsWhenFrozen(FeatureBitset features)
932 {
933 testcase("Longer paths payment on frozen trust lines");
934 using namespace test::jtx;
935 using path = test::jtx::path;
936
937 Env env(*this, features);
938 Account const G1{"G1"};
939 Account const A1{"A1"};
940 Account const A2{"A2"};
941 auto const USD{G1["USD"]};
942
943 env.fund(XRP(10000), G1, A1, A2);
944 env.close();
945
946 auto const limit = USD(10000);
947 env.trust(limit, A1, A2);
948 env.close();
949
950 env(pay(G1, A1, USD(1000)));
951 env(pay(G1, A2, USD(1000)));
952 env.close();
953
954 env(offer(A2, XRP(100), USD(100)), txflags(tfPassive));
955 env.close();
956
957 // Testing payments A1 <-> G1 using offer from A2 frozen by issuer.
958 {
959 env(trust(G1, A2["USD"](0), tfSetFreeze));
960 env.close();
961
962 // test: A1 cannot send USD using XRP through A2 offer
963 env(pay(A1, G1, USD(10)),
964 path(~USD),
965 sendmax(XRP(11)),
966 txflags(tfNoRippleDirect),
967 ter(tecPATH_PARTIAL));
968 env.close();
969
970 // test: G1 cannot send USD using XRP through A2 offer
971 env(pay(G1, A1, USD(10)),
972 path(~USD),
973 sendmax(XRP(11)),
974 txflags(tfNoRippleDirect),
975 ter(tecPATH_PARTIAL));
976 env.close();
977
978 env(trust(G1, A2["USD"](0), tfClearFreeze));
979 env.close();
980 }
981
982 // Testing payments A1 <-> G1 using offer from A2 deep frozen by issuer.
983 if (features[featureDeepFreeze])
984 {
985 env(trust(G1, A2["USD"](0), tfSetFreeze | tfSetDeepFreeze));
986 env.close();
987
988 // test: A1 cannot send USD using XRP through A2 offer
989 env(pay(A1, G1, USD(10)),
990 path(~USD),
991 sendmax(XRP(11)),
992 txflags(tfNoRippleDirect),
993 ter(tecPATH_PARTIAL));
994 env.close();
995
996 // test: G1 cannot send USD using XRP through A2 offer
997 env(pay(G1, A1, USD(10)),
998 path(~USD),
999 sendmax(XRP(11)),
1000 txflags(tfNoRippleDirect),
1001 ter(tecPATH_PARTIAL));
1002 env.close();
1003
1004 env(trust(G1, A2["USD"](0), tfClearFreeze | tfClearDeepFreeze));
1005 env.close();
1006 }
1007
1008 // Testing payments A1 <-> G1 using offer from A2 frozen by currency
1009 // holder.
1010 {
1011 env(trust(A2, limit, tfSetFreeze));
1012 env.close();
1013
1014 // test: A1 can send USD using XRP through A2 offer
1015 env(pay(A1, G1, USD(10)), path(~USD), sendmax(XRP(11)), txflags(tfNoRippleDirect));
1016 env.close();
1017
1018 // test: G1 can send USD using XRP through A2 offer
1019 env(pay(G1, A1, USD(10)), path(~USD), sendmax(XRP(11)), txflags(tfNoRippleDirect));
1020 env.close();
1021
1022 env(trust(A2, limit, tfClearFreeze));
1023 env.close();
1024 }
1025
1026 // Testing payments A1 <-> G1 using offer from A2 deep frozen by
1027 // currency holder.
1028 if (features[featureDeepFreeze])
1029 {
1030 env(trust(A2, limit, tfSetFreeze | tfSetDeepFreeze));
1031 env.close();
1032
1033 // test: A1 cannot send USD using XRP through A2 offer
1034 env(pay(A1, G1, USD(10)),
1035 path(~USD),
1036 sendmax(XRP(11)),
1037 txflags(tfNoRippleDirect),
1038 ter(tecPATH_PARTIAL));
1039 env.close();
1040
1041 // test: G1 cannot send USD using XRP through A2 offer
1042 env(pay(G1, A1, USD(10)),
1043 path(~USD),
1044 sendmax(XRP(11)),
1045 txflags(tfNoRippleDirect),
1046 ter(tecPATH_PARTIAL));
1047 env.close();
1048
1049 env(trust(A2, limit, tfClearFreeze | tfClearDeepFreeze));
1050 env.close();
1051 }
1052
1053 // Cleanup
1054 env(offer_cancel(A1, env.seq(A1) - 1));
1055 env.require(offers(A1, 0));
1056 env.close();
1057
1058 env(offer(A2, USD(100), XRP(100)), txflags(tfPassive));
1059 env.close();
1060
1061 // Testing payments A1 <-> G1 using offer from A2 frozen by issuer.
1062 {
1063 env(trust(G1, A2["USD"](0), tfSetFreeze));
1064 env.close();
1065
1066 // test: A1 can send XRP using USD through A2 offer
1067 env(pay(A1, G1, XRP(10)), path(~XRP), sendmax(USD(11)), txflags(tfNoRippleDirect));
1068 env.close();
1069
1070 // test: G1 can send XRP using USD through A2 offer
1071 env(pay(G1, A1, XRP(10)), path(~XRP), sendmax(USD(11)), txflags(tfNoRippleDirect));
1072 env.close();
1073
1074 env(trust(G1, A2["USD"](0), tfClearFreeze));
1075 env.close();
1076 }
1077
1078 // Testing payments A1 <-> G1 using offer from A2 deep frozen by
1079 // issuer.
1080 if (features[featureDeepFreeze])
1081 {
1082 env(trust(G1, A2["USD"](0), tfSetFreeze | tfSetDeepFreeze));
1083 env.close();
1084
1085 // test: A1 cannot send XRP using USD through A2 offer
1086 env(pay(A1, G1, XRP(10)),
1087 path(~XRP),
1088 sendmax(USD(11)),
1089 txflags(tfNoRippleDirect),
1090 ter(tecPATH_PARTIAL));
1091 env.close();
1092
1093 // test: G1 cannot send XRP using USD through A2 offer
1094 env(pay(G1, A1, XRP(10)),
1095 path(~XRP),
1096 sendmax(USD(11)),
1097 txflags(tfNoRippleDirect),
1098 ter(tecPATH_PARTIAL));
1099 env.close();
1100
1101 env(trust(G1, A2["USD"](0), tfClearFreeze | tfClearDeepFreeze));
1102 env.close();
1103 }
1104
1105 // Testing payments A1 <-> G1 using offer from A2 frozen by currency
1106 // holder.
1107 {
1108 env(trust(A2, limit, tfSetFreeze));
1109 env.close();
1110
1111 // test: A1 can send XRP using USD through A2 offer
1112 env(pay(A1, G1, XRP(10)), path(~XRP), sendmax(USD(11)), txflags(tfNoRippleDirect));
1113 env.close();
1114
1115 // test: G1 can send XRP using USD through A2 offer
1116 env(pay(G1, A1, XRP(10)), path(~XRP), sendmax(USD(11)), txflags(tfNoRippleDirect));
1117 env.close();
1118
1119 env(trust(A2, limit, tfClearFreeze));
1120 env.close();
1121 }
1122
1123 // Testing payments A1 <-> G1 using offer from A2 deep frozen by
1124 // currency holder.
1125 if (features[featureDeepFreeze])
1126 {
1127 env(trust(A2, limit, tfSetFreeze | tfSetDeepFreeze));
1128 env.close();
1129
1130 // test: A1 cannot send XRP using USD through A2 offer
1131 env(pay(A1, G1, XRP(10)),
1132 path(~XRP),
1133 sendmax(USD(11)),
1134 txflags(tfNoRippleDirect),
1135 ter(tecPATH_PARTIAL));
1136 env.close();
1137
1138 // test: G1 cannot send XRP using USD through A2 offer
1139 env(pay(G1, A1, XRP(10)),
1140 path(~XRP),
1141 sendmax(USD(11)),
1142 txflags(tfNoRippleDirect),
1143 ter(tecPATH_PARTIAL));
1144 env.close();
1145
1146 env(trust(A2, limit, tfClearFreeze | tfClearDeepFreeze));
1147 env.close();
1148 }
1149
1150 // Cleanup
1151 env(offer_cancel(A1, env.seq(A1) - 1));
1152 env.require(offers(A1, 0));
1153 env.close();
1154 }
1155
1156 void
1157 testPaymentsWhenDeepFrozen(FeatureBitset features)
1158 {
1159 testcase("Direct payments on frozen trust lines");
1160
1161 using namespace test::jtx;
1162 Env env(*this, features);
1163
1164 Account const G1{"G1"};
1165 Account const A1{"A1"};
1166 Account const A2{"A2"};
1167 auto const USD{G1["USD"]};
1168
1169 env.fund(XRP(10000), G1, A1, A2);
1170 env.close();
1171
1172 auto const limit = USD(10000);
1173 env.trust(limit, A1, A2);
1174 env.close();
1175
1176 env(pay(G1, A1, USD(1000)));
1177 env(pay(G1, A2, USD(1000)));
1178 env.close();
1179
1180 // Checking payments before freeze
1181 // To issuer:
1182 env(pay(A1, G1, USD(1)));
1183 env(pay(A2, G1, USD(1)));
1184 env.close();
1185
1186 // To each other:
1187 env(pay(A1, A2, USD(1)));
1188 env(pay(A2, A1, USD(1)));
1189 env.close();
1190
1191 // Freeze A1
1192 env(trust(G1, A1["USD"](0), tfSetFreeze));
1193 env.close();
1194
1195 // Issuer and A1 can send payments to each other
1196 env(pay(A1, G1, USD(1)));
1197 env(pay(G1, A1, USD(1)));
1198 env.close();
1199
1200 // A1 cannot send tokens to A2
1201 env(pay(A1, A2, USD(1)), ter(tecPATH_DRY));
1202
1203 // A2 can still send to A1
1204 env(pay(A2, A1, USD(1)));
1205 env.close();
1206
1207 if (features[featureDeepFreeze])
1208 {
1209 // Deep freeze A1
1210 env(trust(G1, A1["USD"](0), tfSetDeepFreeze));
1211 env.close();
1212
1213 // Issuer and A1 can send payments to each other
1214 env(pay(A1, G1, USD(1)));
1215 env(pay(G1, A1, USD(1)));
1216 env.close();
1217
1218 // A1 cannot send tokens to A2
1219 env(pay(A1, A2, USD(1)), ter(tecPATH_DRY));
1220
1221 // A2 cannot send tokens to A1
1222 env(pay(A2, A1, USD(1)), ter(tecPATH_DRY));
1223
1224 // Clear deep freeze on A1
1225 env(trust(G1, A1["USD"](0), tfClearDeepFreeze));
1226 env.close();
1227 }
1228
1229 // Clear freeze on A1
1230 env(trust(G1, A1["USD"](0), tfClearFreeze));
1231 env.close();
1232
1233 // A1 freezes trust line
1234 env(trust(A1, limit, tfSetFreeze));
1235 env.close();
1236
1237 // Issuer and A2 must not be affected
1238 env(pay(A2, G1, USD(1)));
1239 env(pay(G1, A2, USD(1)));
1240 env.close();
1241
1242 // A1 can send tokens to the issuer
1243 env(pay(A1, G1, USD(1)));
1244 env.close();
1245 // A1 can send tokens to A2
1246 env(pay(A1, A2, USD(1)));
1247 env.close();
1248
1249 // Issuer can sent tokens to A1
1250 env(pay(G1, A1, USD(1)));
1251 // A2 cannot send tokens to A1
1252 env(pay(A2, A1, USD(1)), ter(tecPATH_DRY));
1253
1254 if (features[featureDeepFreeze])
1255 {
1256 // A1 deep freezes trust line
1257 env(trust(A1, limit, tfSetDeepFreeze));
1258 env.close();
1259
1260 // Issuer and A2 must not be affected
1261 env(pay(A2, G1, USD(1)));
1262 env(pay(G1, A2, USD(1)));
1263 env.close();
1264
1265 // A1 can still send token to issuer
1266 env(pay(A1, G1, USD(1)));
1267 env.close();
1268
1269 // Issuer can send tokens to A1
1270 env(pay(G1, A1, USD(1)));
1271 // A2 cannot send tokens to A1
1272 env(pay(A2, A1, USD(1)), ter(tecPATH_DRY));
1273 // A1 cannot send tokens to A2
1274 env(pay(A1, A2, USD(1)), ter(tecPATH_DRY));
1275 }
1276 }
1277
1278 void
1279 testChecksWhenFrozen(FeatureBitset features)
1280 {
1281 testcase("Checks on frozen trust lines");
1282
1283 using namespace test::jtx;
1284 Env env(*this, features);
1285
1286 Account const G1{"G1"};
1287 Account const A1{"A1"};
1288 Account const A2{"A2"};
1289 auto const USD{G1["USD"]};
1290
1291 env.fund(XRP(10000), G1, A1, A2);
1292 env.close();
1293
1294 auto const limit = USD(10000);
1295 env.trust(limit, A1, A2);
1296 env.close();
1297
1298 env(pay(G1, A1, USD(1000)));
1299 env(pay(G1, A2, USD(1000)));
1300 env.close();
1301
1302 // Confirming we can write and cash checks
1303 {
1304 uint256 const checkId{getCheckIndex(G1, env.seq(G1))};
1305 env(check::create(G1, A1, USD(10)));
1306 env.close();
1307 env(check::cash(A1, checkId, USD(10)));
1308 env.close();
1309 }
1310
1311 {
1312 uint256 const checkId{getCheckIndex(G1, env.seq(G1))};
1313 env(check::create(G1, A2, USD(10)));
1314 env.close();
1315 env(check::cash(A2, checkId, USD(10)));
1316 env.close();
1317 }
1318
1319 {
1320 uint256 const checkId{getCheckIndex(A1, env.seq(A1))};
1321 env(check::create(A1, G1, USD(10)));
1322 env.close();
1323 env(check::cash(G1, checkId, USD(10)));
1324 env.close();
1325 }
1326
1327 {
1328 uint256 const checkId{getCheckIndex(A1, env.seq(A1))};
1329 env(check::create(A1, A2, USD(10)));
1330 env.close();
1331 env(check::cash(A2, checkId, USD(10)));
1332 env.close();
1333 }
1334
1335 {
1336 uint256 const checkId{getCheckIndex(A2, env.seq(A2))};
1337 env(check::create(A2, G1, USD(10)));
1338 env.close();
1339 env(check::cash(G1, checkId, USD(10)));
1340 env.close();
1341 }
1342
1343 {
1344 uint256 const checkId{getCheckIndex(A2, env.seq(A2))};
1345 env(check::create(A2, A1, USD(10)));
1346 env.close();
1347 env(check::cash(A1, checkId, USD(10)));
1348 env.close();
1349 }
1350
1351 // Testing creation and cashing of checks on a trustline frozen by
1352 // issuer
1353 {
1354 env(trust(G1, A1["USD"](0), tfSetFreeze));
1355 env.close();
1356
1357 // test: issuer writes check to A1.
1358 {
1359 uint256 const checkId{getCheckIndex(G1, env.seq(G1))};
1360 env(check::create(G1, A1, USD(10)));
1361 env.close();
1362 env(check::cash(A1, checkId, USD(10)), ter(tecFROZEN));
1363 env.close();
1364 }
1365
1366 // test: A2 writes check to A1.
1367 {
1368 uint256 const checkId{getCheckIndex(A2, env.seq(A2))};
1369 env(check::create(A2, A1, USD(10)));
1370 env.close();
1371 // Same as previous test
1372 env(check::cash(A1, checkId, USD(10)), ter(tecFROZEN));
1373 env.close();
1374 }
1375
1376 // test: A1 writes check to issuer
1377 {
1378 env(check::create(A1, G1, USD(10)), ter(tecFROZEN));
1379 env.close();
1380 }
1381
1382 // test: A1 writes check to A2
1383 {
1384 // Same as previous test
1385 env(check::create(A1, A2, USD(10)), ter(tecFROZEN));
1386 env.close();
1387 }
1388
1389 // Unfreeze the trustline to create a couple of checks so that we
1390 // could try to cash them later when the trustline is frozen again.
1391 env(trust(G1, A1["USD"](0), tfClearFreeze));
1392 env.close();
1393
1394 uint256 const checkId1{getCheckIndex(A1, env.seq(A1))};
1395 env(check::create(A1, G1, USD(10)));
1396 env.close();
1397 uint256 const checkId2{getCheckIndex(A1, env.seq(A1))};
1398 env(check::create(A1, A2, USD(10)));
1399 env.close();
1400
1401 env(trust(G1, A1["USD"](0), tfSetFreeze));
1402 env.close();
1403
1404 // test: issuer tries to cash the check from A1
1405 {
1406 env(check::cash(G1, checkId1, USD(10)), ter(tecPATH_PARTIAL));
1407 env.close();
1408 }
1409
1410 // test: A2 tries to cash the check from A1
1411 {
1412 env(check::cash(A2, checkId2, USD(10)), ter(tecPATH_PARTIAL));
1413 env.close();
1414 }
1415
1416 env(trust(G1, A1["USD"](0), tfClearFreeze));
1417 env.close();
1418 }
1419
1420 // Testing creation and cashing of checks on a trustline deep frozen by
1421 // issuer
1422 if (features[featureDeepFreeze])
1423 {
1424 env(trust(G1, A1["USD"](0), tfSetFreeze | tfSetDeepFreeze));
1425 env.close();
1426
1427 // test: issuer writes check to A1.
1428 {
1429 uint256 const checkId{getCheckIndex(G1, env.seq(G1))};
1430 env(check::create(G1, A1, USD(10)));
1431 env.close();
1432
1433 env(check::cash(A1, checkId, USD(10)), ter(tecFROZEN));
1434 env.close();
1435 }
1436
1437 // test: A2 writes check to A1.
1438 {
1439 uint256 const checkId{getCheckIndex(A2, env.seq(A2))};
1440 env(check::create(A2, A1, USD(10)));
1441 env.close();
1442 // Same as previous test
1443 env(check::cash(A1, checkId, USD(10)), ter(tecFROZEN));
1444 env.close();
1445 }
1446
1447 // test: A1 writes check to issuer
1448 {
1449 env(check::create(A1, G1, USD(10)), ter(tecFROZEN));
1450 env.close();
1451 }
1452
1453 // test: A1 writes check to A2
1454 {
1455 // Same as previous test
1456 env(check::create(A1, A2, USD(10)), ter(tecFROZEN));
1457 env.close();
1458 }
1459
1460 // Unfreeze the trustline to create a couple of checks so that we
1461 // could try to cash them later when the trustline is frozen again.
1462 env(trust(G1, A1["USD"](0), tfClearFreeze | tfClearDeepFreeze));
1463 env.close();
1464
1465 uint256 const checkId1{getCheckIndex(A1, env.seq(A1))};
1466 env(check::create(A1, G1, USD(10)));
1467 env.close();
1468 uint256 const checkId2{getCheckIndex(A1, env.seq(A1))};
1469 env(check::create(A1, A2, USD(10)));
1470 env.close();
1471
1472 env(trust(G1, A1["USD"](0), tfSetFreeze | tfSetDeepFreeze));
1473 env.close();
1474
1475 // test: issuer tries to cash the check from A1
1476 {
1477 env(check::cash(G1, checkId1, USD(10)), ter(tecPATH_PARTIAL));
1478 env.close();
1479 }
1480
1481 // test: A2 tries to cash the check from A1
1482 {
1483 env(check::cash(A2, checkId2, USD(10)), ter(tecPATH_PARTIAL));
1484 env.close();
1485 }
1486
1487 env(trust(G1, A1["USD"](0), tfClearFreeze | tfClearDeepFreeze));
1488 env.close();
1489 }
1490
1491 // Testing creation and cashing of checks on a trustline frozen by
1492 // a currency holder
1493 {
1494 env(trust(A1, limit, tfSetFreeze));
1495 env.close();
1496
1497 // test: issuer writes check to A1.
1498 {
1499 env(check::create(G1, A1, USD(10)), ter(tecFROZEN));
1500 env.close();
1501 }
1502
1503 // test: A2 writes check to A1.
1504 {
1505 env(check::create(A2, A1, USD(10)), ter(tecFROZEN));
1506 env.close();
1507 }
1508
1509 // test: A1 writes check to issuer
1510 {
1511 uint256 const checkId{getCheckIndex(A1, env.seq(A1))};
1512 env(check::create(A1, G1, USD(10)));
1513 env.close();
1514 env(check::cash(G1, checkId, USD(10)));
1515 env.close();
1516 }
1517
1518 // test: A1 writes check to A2
1519 {
1520 uint256 const checkId{getCheckIndex(A1, env.seq(A1))};
1521 env(check::create(A1, A2, USD(10)));
1522 env.close();
1523 env(check::cash(A2, checkId, USD(10)));
1524 env.close();
1525 }
1526
1527 env(trust(A1, limit, tfClearFreeze));
1528 env.close();
1529 }
1530
1531 // Testing creation and cashing of checks on a trustline deep frozen by
1532 // a currency holder
1533 if (features[featureDeepFreeze])
1534 {
1535 env(trust(A1, limit, tfSetFreeze | tfSetDeepFreeze));
1536 env.close();
1537
1538 // test: issuer writes check to A1.
1539 {
1540 env(check::create(G1, A1, USD(10)), ter(tecFROZEN));
1541 env.close();
1542 }
1543
1544 // test: A2 writes check to A1.
1545 {
1546 env(check::create(A2, A1, USD(10)), ter(tecFROZEN));
1547 env.close();
1548 }
1549
1550 // test: A1 writes check to issuer
1551 {
1552 uint256 const checkId{getCheckIndex(A1, env.seq(A1))};
1553 env(check::create(A1, G1, USD(10)));
1554 env.close();
1555 env(check::cash(G1, checkId, USD(10)), ter(tecPATH_PARTIAL));
1556 env.close();
1557 }
1558
1559 // test: A1 writes check to A2
1560 {
1561 uint256 const checkId{getCheckIndex(A1, env.seq(A1))};
1562 env(check::create(A1, A2, USD(10)));
1563 env.close();
1564 env(check::cash(A2, checkId, USD(10)), ter(tecPATH_PARTIAL));
1565 env.close();
1566 }
1567
1568 env(trust(A1, limit, tfClearFreeze | tfClearDeepFreeze));
1569 env.close();
1570 }
1571 }
1572
1573 void
1574 testAMMWhenFreeze(FeatureBitset features)
1575 {
1576 testcase("AMM payments on frozen trust lines");
1577 using namespace test::jtx;
1578 using path = test::jtx::path;
1579
1580 Env env(*this, features);
1581 Account const G1{"G1"};
1582 Account const A1{"A1"};
1583 Account const A2{"A2"};
1584 auto const USD{G1["USD"]};
1585
1586 env.fund(XRP(10000), G1, A1, A2);
1587 env.close();
1588
1589 env.trust(G1["USD"](10000), A1, A2);
1590 env.close();
1591
1592 env(pay(G1, A1, USD(1000)));
1593 env(pay(G1, A2, USD(1000)));
1594 env.close();
1595
1596 AMM const ammG1(env, G1, XRP(1'000), USD(1'000));
1597 env.close();
1598
1599 // Testing basic payment using AMM when freezing one of the trust lines.
1600 {
1601 env(trust(G1, A1["USD"](0), tfSetFreeze));
1602 env.close();
1603
1604 // test: can still use XRP to make payment
1605 env(pay(A1, A2, USD(10)), path(~USD), sendmax(XRP(11)), txflags(tfNoRippleDirect));
1606 env.close();
1607
1608 // test: cannot use USD to make payment
1609 env(pay(A1, A2, XRP(10)),
1610 path(~XRP),
1611 sendmax(USD(11)),
1612 txflags(tfNoRippleDirect),
1613 ter(tecPATH_DRY));
1614 env.close();
1615
1616 // test: can still receive USD payments.
1617 env(pay(A2, A1, USD(10)), path(~USD), sendmax(XRP(11)), txflags(tfNoRippleDirect));
1618 env.close();
1619
1620 // test: can still receive XRP payments.
1621 env(pay(A2, A1, XRP(10)), path(~XRP), sendmax(USD(11)), txflags(tfNoRippleDirect));
1622 env.close();
1623
1624 env(trust(G1, A1["USD"](0), tfClearFreeze));
1625 env.close();
1626 }
1627
1628 // Testing basic payment using AMM when deep freezing one of the trust
1629 // lines.
1630 if (features[featureDeepFreeze])
1631 {
1632 env(trust(G1, A1["USD"](0), tfSetFreeze | tfSetDeepFreeze));
1633 env.close();
1634
1635 // test: can still use XRP to make payment
1636 env(pay(A1, A2, USD(10)), path(~USD), sendmax(XRP(11)), txflags(tfNoRippleDirect));
1637 env.close();
1638
1639 // test: cannot use USD to make payment
1640 env(pay(A1, A2, XRP(10)),
1641 path(~XRP),
1642 sendmax(USD(11)),
1643 txflags(tfNoRippleDirect),
1644 ter(tecPATH_DRY));
1645 env.close();
1646
1647 // test: cannot receive USD payments.
1648 env(pay(A2, A1, USD(10)),
1649 path(~USD),
1650 sendmax(XRP(11)),
1651 txflags(tfNoRippleDirect),
1652 ter(tecPATH_DRY));
1653 env.close();
1654
1655 // test: can still receive XRP payments.
1656 env(pay(A2, A1, XRP(10)), path(~XRP), sendmax(USD(11)), txflags(tfNoRippleDirect));
1657 env.close();
1658
1659 env(trust(G1, A1["USD"](0), tfClearFreeze | tfClearDeepFreeze));
1660 env.close();
1661 }
1662 }
1663
1664 void
1665 testNFTOffersWhenFreeze(FeatureBitset features)
1666 {
1667 testcase("NFT offers on frozen trust lines");
1668 using namespace test::jtx;
1669
1670 Env env(*this, features);
1671 Account const G1{"G1"};
1672 Account const A1{"A1"};
1673 Account const A2{"A2"};
1674 auto const USD{G1["USD"]};
1675
1676 env.fund(XRP(10000), G1, A1, A2);
1677 env.close();
1678
1679 auto const limit = USD(10000);
1680 env.trust(limit, A1, A2);
1681 env.close();
1682
1683 env(pay(G1, A1, USD(1000)));
1684 env(pay(G1, A2, USD(1000)));
1685 env.close();
1686
1687 // Testing A2 nft offer sell when A2 frozen by issuer
1688 {
1689 auto const sellOfferIndex = createNFTSellOffer(env, A2, USD(10));
1690 env(trust(G1, A2["USD"](0), tfSetFreeze));
1691 env.close();
1692
1693 // test: A2 can still receive USD for his NFT
1694 env(token::acceptSellOffer(A1, sellOfferIndex));
1695 env.close();
1696
1697 env(trust(G1, A2["USD"](0), tfClearFreeze));
1698 env.close();
1699 }
1700
1701 // Testing A2 nft offer sell when A2 deep frozen by issuer
1702 if (features[featureDeepFreeze])
1703 {
1704 auto const sellOfferIndex = createNFTSellOffer(env, A2, USD(10));
1705
1706 env(trust(G1, A2["USD"](0), tfSetFreeze | tfSetDeepFreeze));
1707 env.close();
1708
1709 // test: A2 cannot receive USD for his NFT
1710 env(token::acceptSellOffer(A1, sellOfferIndex), ter(tecFROZEN));
1711 env.close();
1712
1713 env(trust(G1, A2["USD"](0), tfClearFreeze | tfClearDeepFreeze));
1714 env.close();
1715 }
1716
1717 // Testing A1 nft offer sell when A2 frozen by issuer
1718 {
1719 auto const sellOfferIndex = createNFTSellOffer(env, A1, USD(10));
1720 env(trust(G1, A2["USD"](0), tfSetFreeze));
1721 env.close();
1722
1723 // test: A2 cannot send USD for NFT
1724 env(token::acceptSellOffer(A2, sellOfferIndex), ter(tecINSUFFICIENT_FUNDS));
1725 env.close();
1726
1727 env(trust(G1, A2["USD"](0), tfClearFreeze));
1728 env.close();
1729 }
1730
1731 // Testing A1 nft offer sell when A2 deep frozen by issuer
1732 if (features[featureDeepFreeze])
1733 {
1734 auto const sellOfferIndex = createNFTSellOffer(env, A1, USD(10));
1735 env(trust(G1, A2["USD"](0), tfSetFreeze | tfSetDeepFreeze));
1736 env.close();
1737
1738 // test: A2 cannot send USD for NFT
1739 env(token::acceptSellOffer(A2, sellOfferIndex), ter(tecINSUFFICIENT_FUNDS));
1740 env.close();
1741
1742 env(trust(G1, A2["USD"](0), tfClearFreeze | tfClearDeepFreeze));
1743 env.close();
1744 }
1745
1746 // Testing A1 nft buy offer when A2 deep frozen by issuer
1747 if (features[featureDeepFreeze] && features[fixEnforceNFTokenTrustlineV2])
1748 {
1749 env(trust(G1, A2["USD"](0), tfSetFreeze | tfSetDeepFreeze));
1750 env.close();
1751
1752 uint256 const nftID{token::getNextID(env, A2, 0u, tfTransferable)};
1753 env(token::mint(A2, 0), txflags(tfTransferable));
1754 env.close();
1755
1756 auto const buyIdx = keylet::nftoffer(A1, env.seq(A1)).key;
1757 env(token::createOffer(A1, nftID, USD(10)), token::owner(A2));
1758 env.close();
1759
1760 env(token::acceptBuyOffer(A2, buyIdx), ter(tecFROZEN));
1761 env.close();
1762
1763 env(trust(G1, A2["USD"](0), tfClearFreeze | tfClearDeepFreeze));
1764 env.close();
1765
1766 env(token::acceptBuyOffer(A2, buyIdx));
1767 env.close();
1768 }
1769
1770 // Testing A2 nft offer sell when A2 frozen by currency holder
1771 {
1772 auto const sellOfferIndex = createNFTSellOffer(env, A2, USD(10));
1773 env(trust(A2, limit, tfSetFreeze));
1774 env.close();
1775
1776 // test: offer can still be accepted.
1777 env(token::acceptSellOffer(A1, sellOfferIndex));
1778 env.close();
1779
1780 env(trust(A2, limit, tfClearFreeze));
1781 env.close();
1782 }
1783
1784 // Testing A2 nft offer sell when A2 deep frozen by currency holder
1785 if (features[featureDeepFreeze])
1786 {
1787 auto const sellOfferIndex = createNFTSellOffer(env, A2, USD(10));
1788
1789 env(trust(A2, limit, tfSetFreeze | tfSetDeepFreeze));
1790 env.close();
1791
1792 // test: A2 cannot receive USD for his NFT
1793 env(token::acceptSellOffer(A1, sellOfferIndex), ter(tecFROZEN));
1794 env.close();
1795
1796 env(trust(A2, limit, tfClearFreeze | tfClearDeepFreeze));
1797 env.close();
1798 }
1799
1800 // Testing A1 nft offer sell when A2 frozen by currency holder
1801 {
1802 auto const sellOfferIndex = createNFTSellOffer(env, A1, USD(10));
1803 env(trust(A2, limit, tfSetFreeze));
1804 env.close();
1805
1806 // test: A2 cannot send USD for NFT
1807 env(token::acceptSellOffer(A2, sellOfferIndex));
1808 env.close();
1809
1810 env(trust(A2, limit, tfClearFreeze));
1811 env.close();
1812 }
1813
1814 // Testing A1 nft offer sell when A2 deep frozen by currency holder
1815 if (features[featureDeepFreeze])
1816 {
1817 auto const sellOfferIndex = createNFTSellOffer(env, A1, USD(10));
1818 env(trust(A2, limit, tfSetFreeze | tfSetDeepFreeze));
1819 env.close();
1820
1821 // test: A2 cannot send USD for NFT
1822 env(token::acceptSellOffer(A2, sellOfferIndex), ter(tecINSUFFICIENT_FUNDS));
1823 env.close();
1824
1825 env(trust(A2, limit, tfClearFreeze | tfClearDeepFreeze));
1826 env.close();
1827 }
1828
1829 // Testing brokered offer acceptance
1830 if (features[featureDeepFreeze] && features[fixEnforceNFTokenTrustlineV2])
1831 {
1832 Account const broker{"broker"};
1833 env.fund(XRP(10000), broker);
1834 env.close();
1835 env(trust(G1, broker["USD"](1000), tfSetFreeze | tfSetDeepFreeze));
1836 env.close();
1837
1838 uint256 const nftID{token::getNextID(env, A2, 0u, tfTransferable)};
1839 env(token::mint(A2, 0), txflags(tfTransferable));
1840 env.close();
1841
1842 uint256 const sellIdx = keylet::nftoffer(A2, env.seq(A2)).key;
1843 env(token::createOffer(A2, nftID, USD(10)), txflags(tfSellNFToken));
1844 env.close();
1845 auto const buyIdx = keylet::nftoffer(A1, env.seq(A1)).key;
1846 env(token::createOffer(A1, nftID, USD(11)), token::owner(A2));
1847 env.close();
1848
1849 env(token::brokerOffers(broker, buyIdx, sellIdx),
1850 token::brokerFee(USD(1)),
1851 ter(tecFROZEN));
1852 env.close();
1853 }
1854
1855 // Testing transfer fee
1856 if (features[featureDeepFreeze] && features[fixEnforceNFTokenTrustlineV2])
1857 {
1858 Account const minter{"minter"};
1859 env.fund(XRP(10000), minter);
1860 env.close();
1861 env(trust(G1, minter["USD"](1000)));
1862 env.close();
1863
1864 uint256 const nftID{token::getNextID(env, minter, 0u, tfTransferable, 1u)};
1865 env(token::mint(minter, 0), token::xferFee(1u), txflags(tfTransferable));
1866 env.close();
1867
1868 uint256 const minterSellIdx = keylet::nftoffer(minter, env.seq(minter)).key;
1869 env(token::createOffer(minter, nftID, drops(1)), txflags(tfSellNFToken));
1870 env.close();
1871 env(token::acceptSellOffer(A2, minterSellIdx));
1872 env.close();
1873
1874 uint256 const sellIdx = keylet::nftoffer(A2, env.seq(A2)).key;
1875 env(token::createOffer(A2, nftID, USD(100)), txflags(tfSellNFToken));
1876 env.close();
1877 env(trust(G1, minter["USD"](1000), tfSetFreeze | tfSetDeepFreeze));
1878 env.close();
1879 env(token::acceptSellOffer(A1, sellIdx), ter(tecFROZEN));
1880 env.close();
1881 }
1882 }
1883
1884 // Helper function to extract trustline flags from open ledger
1885 uint32_t
1886 getTrustlineFlags(
1887 test::jtx::Env& env,
1888 size_t expectedArraySize,
1889 size_t expectedArrayIndex,
1890 bool modified = true)
1891 {
1892 using namespace test::jtx;
1893 auto const affected = env.meta()->getJson(JsonOptions::none)[sfAffectedNodes.fieldName];
1894 if (!BEAST_EXPECT(checkArraySize(affected, expectedArraySize)))
1895 return 0;
1896
1897 if (modified)
1898 {
1899 return affected[expectedArrayIndex][sfModifiedNode.fieldName][sfFinalFields.fieldName]
1900 [jss::Flags]
1901 .asUInt();
1902 }
1903
1904 return affected[expectedArrayIndex][sfCreatedNode.fieldName][sfNewFields.fieldName]
1905 [jss::Flags]
1906 .asUInt();
1907 }
1908
1909 // Helper function that returns the index of the next check on account
1910 static uint256
1911 getCheckIndex(AccountID const& account, std::uint32_t uSequence)
1912 {
1913 return keylet::check(account, uSequence).key;
1914 }
1915
1916 static uint256
1917 createNFTSellOffer(
1918 test::jtx::Env& env,
1919 test::jtx::Account const& account,
1920 test::jtx::PrettyAmount const& currency)
1921 {
1922 using namespace test::jtx;
1923 uint256 const nftID{token::getNextID(env, account, 0u, tfTransferable)};
1924 env(token::mint(account, 0), txflags(tfTransferable));
1925 env.close();
1926
1927 uint256 const sellOfferIndex = keylet::nftoffer(account, env.seq(account)).key;
1928 env(token::createOffer(account, nftID, currency), txflags(tfSellNFToken));
1929 env.close();
1930
1931 return sellOfferIndex;
1932 }
1933
1934public:
1935 void
1936 run() override
1937 {
1938 auto testAll = [this](FeatureBitset features) {
1939 testRippleState(features);
1940 testDeepFreeze(features);
1941 testCreateFrozenTrustline(features);
1942 testSetAndClear(features);
1943 testGlobalFreeze(features);
1944 testNoFreeze(features);
1945 testOffersWhenFrozen(features);
1946 testOffersWhenDeepFrozen(features);
1947 testPaymentsWhenDeepFrozen(features);
1948 testChecksWhenFrozen(features);
1949 testAMMWhenFreeze(features);
1950 testPathsWhenFrozen(features);
1951 testNFTOffersWhenFreeze(features);
1952 };
1953 using namespace test::jtx;
1954 auto const sa = testable_amendments();
1955 testAll(sa - featureDeepFreeze - featurePermissionedDEX - fixEnforceNFTokenTrustlineV2);
1956 testAll(sa - featurePermissionedDEX - fixEnforceNFTokenTrustlineV2);
1957 testAll(sa - featureDeepFreeze - featurePermissionedDEX);
1958 testAll(sa - featurePermissionedDEX);
1959 testAll(sa - fixEnforceNFTokenTrustlineV2);
1960 testAll(sa - featureDeepFreeze);
1961 testAll(sa);
1962 }
1963};
1964
1965BEAST_DEFINE_TESTSUITE(Freeze, app, xrpl);
1966} // namespace xrpl
Json::Value
Represents a JSON value.
Definition json_value.h:130
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:150
xrpl::Freeze_test
Definition Freeze_test.cpp:13
xrpl::Freeze_test::testOffersWhenDeepFrozen
void testOffersWhenDeepFrozen(FeatureBitset features)
Definition Freeze_test.cpp:701
xrpl::Freeze_test::testSetAndClear
void testSetAndClear(FeatureBitset features)
Definition Freeze_test.cpp:304
xrpl::Freeze_test::testChecksWhenFrozen
void testChecksWhenFrozen(FeatureBitset features)
Definition Freeze_test.cpp:1279
xrpl::Freeze_test::testPathsWhenFrozen
void testPathsWhenFrozen(FeatureBitset features)
Definition Freeze_test.cpp:931
xrpl::Freeze_test::getTrustlineFlags
uint32_t getTrustlineFlags(test::jtx::Env &env, size_t expectedArraySize, size_t expectedArrayIndex, bool modified=true)
Definition Freeze_test.cpp:1886
xrpl::Freeze_test::getCheckIndex
static uint256 getCheckIndex(AccountID const &account, std::uint32_t uSequence)
Definition Freeze_test.cpp:1911
xrpl::Freeze_test::testOffersWhenFrozen
void testOffersWhenFrozen(FeatureBitset features)
Definition Freeze_test.cpp:604
xrpl::Freeze_test::run
void run() override
Runs the suite.
Definition Freeze_test.cpp:1936
xrpl::Freeze_test::testNoFreeze
void testNoFreeze(FeatureBitset features)
Definition Freeze_test.cpp:493
xrpl::Freeze_test::testAMMWhenFreeze
void testAMMWhenFreeze(FeatureBitset features)
Definition Freeze_test.cpp:1574
xrpl::Freeze_test::testNFTOffersWhenFreeze
void testNFTOffersWhenFreeze(FeatureBitset features)
Definition Freeze_test.cpp:1665
xrpl::Freeze_test::testGlobalFreeze
void testGlobalFreeze(FeatureBitset features)
Definition Freeze_test.cpp:343
xrpl::Freeze_test::createNFTSellOffer
static uint256 createNFTSellOffer(test::jtx::Env &env, test::jtx::Account const &account, test::jtx::PrettyAmount const &currency)
Definition Freeze_test.cpp:1917
xrpl::Freeze_test::testRippleState
void testRippleState(FeatureBitset features)
Definition Freeze_test.cpp:15
xrpl::Freeze_test::testCreateFrozenTrustline
void testCreateFrozenTrustline(FeatureBitset features)
Definition Freeze_test.cpp:255
xrpl::Freeze_test::testPaymentsWhenDeepFrozen
void testPaymentsWhenDeepFrozen(FeatureBitset features)
Definition Freeze_test.cpp:1157
xrpl::Freeze_test::testDeepFreeze
void testDeepFreeze(FeatureBitset features)
Definition Freeze_test.cpp:164
xrpl::Issue
A currency issued by an account.
Definition Issue.h:13
xrpl::base_uint< 256 >
xrpl::test::jtx::Account
Immutable cryptographic account descriptor.
Definition Account.h:19
xrpl::test::jtx::Env
A transaction testing environment.
Definition Env.h:122
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:100
xrpl::test::jtx::Env::seq
std::uint32_t seq(Account const &account) const
Returns the next sequence number on account.
Definition Env.cpp:249
xrpl::test::jtx::Env::meta
std::shared_ptr< STObject const > meta()
Return metadata for the last JTx.
Definition Env.cpp:483
xrpl::test::jtx::path
Add a path.
Definition paths.h:38
std::set::clear
T clear(T... args)
std::end
T end(T... args)
std::set::find
T find(T... args)
std::set::insert
T insert(T... args)
xrpl::keylet::nftoffer
Keylet nftoffer(AccountID const &owner, std::uint32_t seq)
An offer from an account to buy or sell an NFT.
Definition Indexes.cpp:386
xrpl::keylet::check
Keylet check(AccountID const &id, std::uint32_t seq) noexcept
A Check.
Definition Indexes.cpp:301
xrpl
Use hash_* containers for keys that do not need a cryptographically secure hashing algorithm.
Definition algorithm.h:5
xrpl::getJson
Json::Value getJson(LedgerFill const &fill)
Return a new Json::Value representing the ledger with given options.
Definition LedgerToJson.cpp:331
xrpl::noAccount
AccountID const & noAccount()
A placeholder for empty accounts.
Definition AccountID.cpp:163
xrpl::temINVALID_FLAG
@ temINVALID_FLAG
Definition TER.h:91
xrpl::tecPATH_PARTIAL
@ tecPATH_PARTIAL
Definition TER.h:263
xrpl::tecPATH_DRY
@ tecPATH_DRY
Definition TER.h:275
xrpl::tecFROZEN
@ tecFROZEN
Definition TER.h:284
xrpl::tecINSUFFICIENT_FUNDS
@ tecINSUFFICIENT_FUNDS
Definition TER.h:306
xrpl::tecUNFUNDED_OFFER
@ tecUNFUNDED_OFFER
Definition TER.h:265
xrpl::tecKILLED
@ tecKILLED
Definition TER.h:297
xrpl::tecNO_PERMISSION
@ tecNO_PERMISSION
Definition TER.h:286
xrpl::to_currency
bool to_currency(Currency &, std::string const &)
Tries to convert a string to a Currency, returns true on success.
Definition UintTypes.cpp:64
xrpl::Keylet::key
uint256 key
Definition Keylet.h:20
xrpl::test::jtx::PrettyAmount
Represents an XRP or IOU quantity This customizes the string conversion and supports XRP conversions ...
Definition src/test/jtx/amount.h:64
Generated by doxygen 1.9.8