xrpld
Loading...
Searching...
No Matches
VaultFreeze_test.cpp
1#include <test/app/vault/VaultTestBase.h>
2#include <test/jtx/Account.h>
3#include <test/jtx/Env.h>
4#include <test/jtx/amount.h>
5#include <test/jtx/flags.h>
6#include <test/jtx/mpt.h>
7#include <test/jtx/pay.h>
8#include <test/jtx/ter.h>
9#include <test/jtx/trust.h>
10#include <test/jtx/vault.h>
11
12#include <xrpl/basics/base_uint.h>
13#include <xrpl/beast/unit_test/suite.h>
14#include <xrpl/json/json_forwards.h>
15#include <xrpl/json/json_value.h>
16#include <xrpl/protocol/AccountID.h>
17#include <xrpl/protocol/Asset.h>
18#include <xrpl/protocol/Feature.h>
19#include <xrpl/protocol/SField.h>
20#include <xrpl/protocol/STAmount.h>
21#include <xrpl/protocol/TER.h>
22#include <xrpl/protocol/TxFlags.h>
23#include <xrpl/protocol/jss.h>
24
25#include <string>
26#include <tuple>
27#include <utility>
28
29namespace xrpl {
30
32{
33private:
34 void
36 {
37 using namespace test::jtx;
38 testcase("VaultDeposit IOU freeze checks");
39
40 Account const issuer{"issuer"};
41 Account const owner{"owner"};
42 Env env{*this};
43 Vault vault{env};
44
45 env.fund(XRP(100'000), issuer, owner);
46 env(fset(issuer, asfAllowTrustLineClawback));
47 env.close();
48 PrettyAsset const asset = issuer["IOU"];
49 env.trust(asset(1'000'000), owner);
50 env(pay(issuer, owner, asset(100'000)));
51 env.close();
52
53 auto [tx, keylet] = vault.create({.owner = owner, .asset = asset});
54 env(tx);
55 env.close();
56 auto const vaultAcct = Account("vault", env.le(keylet)->at(sfAccount));
57
58 // Initial deposit so the vault pseudo-account has a trustline
59 env(vault.deposit({.depositor = owner, .id = keylet.key, .amount = asset(100)}));
60 env.close();
61
62 auto const runTests = [&] {
63 auto const fix330Enabled = env.current()->rules().enabled(fixCleanup3_3_0);
64
65 // Global freeze
66 {
67 testcase("VaultDeposit IOU global freeze");
68 env(fset(issuer, asfGlobalFreeze));
69 env(vault.deposit({.depositor = owner, .id = keylet.key, .amount = asset(1)}),
70 Ter(tecFROZEN));
71 env(fclear(issuer, asfGlobalFreeze));
72 }
73
74 // Depositor freeze
75 {
76 testcase("VaultDeposit IOU depositor freeze");
77 env(trust(issuer, asset(0), owner, tfSetFreeze));
78 env(vault.deposit({.depositor = owner, .id = keylet.key, .amount = asset(1)}),
79 Ter(tecFROZEN));
80 env(trust(issuer, asset(0), owner, tfClearFreeze));
81 }
82
83 // Depositor deep freeze
84 {
85 testcase("VaultDeposit IOU depositor deep freeze");
86 env(trust(issuer, asset(0), owner, tfSetFreeze | tfSetDeepFreeze));
87 env(vault.deposit({.depositor = owner, .id = keylet.key, .amount = asset(1)}),
88 Ter(tecFROZEN));
89 env(trust(issuer, asset(0), owner, tfClearFreeze | tfClearDeepFreeze));
90 }
91
92 // Vault-account freeze
93 // Post-fix: checkDepositFreeze catches it → tecFROZEN
94 // Pre-fix: not checked directly, but the transitive share
95 // check triggers → tecLOCKED
96 {
97 testcase("VaultDeposit IOU pseudo-account freeze");
98 auto trustSet = [&] {
99 json::Value jv;
100 jv[jss::Account] = issuer.human();
101 {
102 auto& ja = jv[jss::LimitAmount] =
103 asset(0).value().getJson(JsonOptions::Values::None);
104 ja[jss::issuer] = toBase58(vaultAcct.id());
105 }
106 jv[jss::TransactionType] = jss::TrustSet;
107 return jv;
108 }();
109
110 trustSet[jss::Flags] = tfSetFreeze;
111 env(trustSet);
112 env.close();
113
114 TER const expected = fix330Enabled ? TER(tecFROZEN) : TER(tecLOCKED);
115 env(vault.deposit({.depositor = owner, .id = keylet.key, .amount = asset(1)}),
116 Ter(expected));
117
118 trustSet[jss::Flags] = tfClearFreeze;
119 env(trustSet);
120 env.close();
121 }
122
123 // Vault-account deep freeze
124 {
125 testcase("VaultDeposit IOU pseudo-account deep freeze");
126 auto trustSet = [&] {
127 json::Value jv;
128 jv[jss::Account] = issuer.human();
129 {
130 auto& ja = jv[jss::LimitAmount] =
131 asset(0).value().getJson(JsonOptions::Values::None);
132 ja[jss::issuer] = toBase58(vaultAcct.id());
133 }
134 jv[jss::TransactionType] = jss::TrustSet;
135 return jv;
136 }();
137
138 trustSet[jss::Flags] = tfSetFreeze | tfSetDeepFreeze;
139 env(trustSet);
140 env.close();
141
142 env(vault.deposit({.depositor = owner, .id = keylet.key, .amount = asset(1)}),
143 Ter(fix330Enabled ? TER(tecFROZEN) : TER(tecLOCKED)));
144
145 trustSet[jss::Flags] = tfClearFreeze | tfClearDeepFreeze;
146 env(trustSet);
147 env.close();
148 }
149
150 // Clawback works while frozen
151 {
152 testcase("VaultDeposit IOU freeze clawback unaffected");
153 env(fset(issuer, asfGlobalFreeze));
154 env(vault.clawback(
155 {.issuer = issuer, .id = keylet.key, .holder = owner, .amount = asset(1)}));
156 env(fclear(issuer, asfGlobalFreeze));
157 env(vault.deposit({.depositor = owner, .id = keylet.key, .amount = asset(1)}));
158 env.close();
159 }
160 };
161
162 runTests();
163 env.disableFeature(fixCleanup3_3_0);
164 runTests();
165 env.enableFeature(fixCleanup3_3_0);
166 }
167
168 void
170 {
171 using namespace test::jtx;
172 testcase("VaultDeposit MPT lock checks");
173
174 Account const issuer{"issuer"};
175 Account const owner{"owner"};
176 Env env{*this};
177 Vault vault{env};
178
179 env.fund(XRP(100'000), issuer, owner);
180 env.close();
181
182 MPTTester mptt{env, issuer, kMptInitNoFund};
183 mptt.create(
184 {.flags = tfMPTCanClawback | tfMPTCanTransfer | tfMPTCanLock | tfMPTRequireAuth});
185 PrettyAsset const mpt{mptt.issuanceID()};
186
187 mptt.authorize({.account = owner});
188 mptt.authorize({.account = issuer, .holder = owner});
189 env.close();
190 env(pay(issuer, owner, mpt(100'000)));
191 env.close();
192
193 auto [tx, keylet] = vault.create({.owner = owner, .asset = mpt});
194 env(tx);
195 env.close();
196 auto const vaultAcctID = env.le(keylet)->at(sfAccount);
197 Account const vaultAcct("vault", vaultAcctID);
198
199 env(vault.deposit({.depositor = owner, .id = keylet.key, .amount = mpt(100)}));
200 env.close();
201
202 // For MPT isDeepFrozen == isFrozen, so all locks block in
203 // both pre- and post-fix.
204 auto const runTests = [&] {
205 // Global lock
206 {
207 testcase("VaultDeposit MPT global lock");
208 mptt.set({.flags = tfMPTLock});
209 env.close();
210 env(vault.deposit({.depositor = owner, .id = keylet.key, .amount = mpt(1)}),
211 Ter(tecLOCKED));
212 mptt.set({.flags = tfMPTUnlock});
213 env.close();
214 }
215
216 // Depositor individual lock
217 {
218 testcase("VaultDeposit MPT depositor lock");
219 mptt.set({.holder = owner, .flags = tfMPTLock});
220 env.close();
221 env(vault.deposit({.depositor = owner, .id = keylet.key, .amount = mpt(1)}),
222 Ter(tecLOCKED));
223 mptt.set({.holder = owner, .flags = tfMPTUnlock});
224 env.close();
225 }
226
227 // Vault pseudo-account individual lock
228 {
229 testcase("VaultDeposit MPT pseudo-account lock");
230 mptt.set({.holder = vaultAcct, .flags = tfMPTLock});
231 env.close();
232 env(vault.deposit({.depositor = owner, .id = keylet.key, .amount = mpt(1)}),
233 Ter(tecLOCKED));
234 mptt.set({.holder = vaultAcct, .flags = tfMPTUnlock});
235 env.close();
236 }
237
238 // Clawback works while locked
239 {
240 testcase("VaultDeposit MPT lock clawback unaffected");
241 mptt.set({.flags = tfMPTLock});
242 env.close();
243 env(vault.clawback(
244 {.issuer = issuer, .id = keylet.key, .holder = owner, .amount = mpt(1)}));
245 mptt.set({.flags = tfMPTUnlock});
246 env.close();
247 env(vault.deposit({.depositor = owner, .id = keylet.key, .amount = mpt(1)}));
248 env.close();
249 }
250 };
251
252 runTests();
253 env.disableFeature(fixCleanup3_3_0);
254 runTests();
255 env.enableFeature(fixCleanup3_3_0);
256 }
257
258 void
260 {
261 using namespace test::jtx;
262 testcase("VaultWithdraw IOU freeze checks");
263
264 Account const issuer{"issuer"};
265 Account const owner{"owner"};
266 Env env{*this};
267 Vault const vault{env};
268
269 env.fund(XRP(100'000), issuer, owner);
270 env(fset(issuer, asfAllowTrustLineClawback));
271 env.close();
272 PrettyAsset const asset = issuer["IOU"];
273 env.trust(asset(1'000'000), owner);
274 env(pay(issuer, owner, asset(100'000)));
275 env.close();
276
277 auto [tx, keylet] = vault.create({.owner = owner, .asset = asset});
278 env(tx);
279 env.close();
280 auto const vaultAcct = Account("vault", env.le(keylet)->at(sfAccount));
281
282 env(vault.deposit({.depositor = owner, .id = keylet.key, .amount = asset(100)}));
283 env.close();
284
285 Account const charlie{"charlie"};
286 env.fund(XRP(10'000), charlie);
287 env.trust(asset(1'000'000), charlie);
288 env.close();
289
290 auto const runTests = [&] {
291 auto const fix330Enabled = env.current()->rules().enabled(fixCleanup3_3_0);
292 // Global freeze → self-withdraw
293 {
294 testcase("VaultWithdraw IOU global freeze");
295 env(fset(issuer, asfGlobalFreeze));
296 env(vault.withdraw({.depositor = owner, .id = keylet.key, .amount = asset(1)}),
297 Ter(tecFROZEN));
298 // Global freeze → withdraw to 3rd party
299
300 auto withdrawToCharlie =
301 vault.withdraw({.depositor = owner, .id = keylet.key, .amount = asset(1)});
302 withdrawToCharlie[sfDestination] = charlie.human();
303 env(withdrawToCharlie, Ter(tecFROZEN));
304
305 env(fclear(issuer, asfGlobalFreeze));
306 }
307
308 // Vault-account freeze
309 {
310 testcase("VaultWithdraw IOU pseudo-account freeze");
311 auto trustSet = [&] {
312 json::Value jv;
313 jv[jss::Account] = issuer.human();
314 {
315 auto& ja = jv[jss::LimitAmount] =
316 asset(0).value().getJson(JsonOptions::Values::None);
317 ja[jss::issuer] = toBase58(vaultAcct.id());
318 }
319 jv[jss::TransactionType] = jss::TrustSet;
320 return jv;
321 }();
322
323 trustSet[jss::Flags] = tfSetFreeze;
324 env(trustSet);
325 env.close();
326
327 TER const terExpected = fix330Enabled ? TER(tecFROZEN) : TER(tecLOCKED);
328
329 // Self-withdraw
330 env(vault.withdraw({.depositor = owner, .id = keylet.key, .amount = asset(1)}),
331 Ter(terExpected));
332 // Withdraw to 3rd party
333
334 auto withdrawToCharlie =
335 vault.withdraw({.depositor = owner, .id = keylet.key, .amount = asset(1)});
336 withdrawToCharlie[sfDestination] = charlie.human();
337 env(withdrawToCharlie, Ter(terExpected));
338
339 trustSet[jss::Flags] = tfClearFreeze;
340 env(trustSet);
341 env.close();
342 }
343
344 // Depositor freeze, self-withdraw
345 {
346 testcase("VaultWithdraw IOU self-withdraw freeze check");
347 env(trust(issuer, asset(0), owner, tfSetFreeze));
348
349 // Post-fix: self-withdraw allowed (submitter==dst skip)
350 // Pre-fix: isFrozen(depositor, iou) catches it
351 env(vault.withdraw({.depositor = owner, .id = keylet.key, .amount = asset(1)}),
352 Ter(fix330Enabled ? TER(tesSUCCESS) : TER(tecFROZEN)));
353
354 // Depositor freeze withdraw to 3rd party
355 auto withdrawTo3rd =
356 vault.withdraw({.depositor = owner, .id = keylet.key, .amount = asset(1)});
357 withdrawTo3rd[sfDestination] = charlie.human();
358
359 // Post-fix: submitter freeze blocks withdraw to 3rd party
360 // Pre-fix: submitter's IOU freeze not checked, but checkFrozen(depositor,
361 // share) triggers tecLOCKED
362 env(withdrawTo3rd, Ter(fix330Enabled ? TER(tecFROZEN) : TER(tecLOCKED)));
363
364 env(trust(issuer, asset(0), owner, tfClearFreeze));
365 // Replenish what was withdrawn
366 if (fix330Enabled)
367 {
368 env(vault.deposit({.depositor = owner, .id = keylet.key, .amount = asset(1)}));
369 }
370 env.close();
371 }
372
373 // Depositor deep freeze → self-withdraw blocked
374 {
375 testcase("VaultWithdraw IOU depositor deep freeze");
376 env(trust(issuer, asset(0), owner, tfSetFreeze | tfSetDeepFreeze));
377
378 env(vault.withdraw({.depositor = owner, .id = keylet.key, .amount = asset(1)}),
379 Ter(tecFROZEN));
380
381 env(trust(issuer, asset(0), owner, tfClearFreeze | tfClearDeepFreeze));
382 }
383
384 // Destination freeze → withdraw to 3rd party
385 {
386 testcase("VaultWithdraw IOU freeze withdraw to 3rd party");
387
388 env(trust(issuer, asset(0), charlie, tfSetFreeze));
389
390 // Self-withdraw unaffected by charlie's freeze
391 env(vault.withdraw({.depositor = owner, .id = keylet.key, .amount = asset(1)}));
392
393 auto withdrawToCharlie =
394 vault.withdraw({.depositor = owner, .id = keylet.key, .amount = asset(1)});
395 withdrawToCharlie[sfDestination] = charlie.human();
396
397 // Post-fix: freeze on dst allowed
398 // Pre-fix: checkFrozen(dst, iou) catches it
399 env(withdrawToCharlie, Ter(fix330Enabled ? TER(tesSUCCESS) : TER(tecFROZEN)));
400
401 env(trust(issuer, asset(0), charlie, tfClearFreeze));
402
403 // Replenish: 1 for self-withdraw + 1 if charlie withdraw succeeded
404 env(vault.deposit({
405 .depositor = owner,
406 .id = keylet.key,
407 .amount = asset(fix330Enabled ? 2 : 1),
408 }));
409 env.close();
410 }
411
412 // Destination deep freeze → withdraw to 3rd party blocked
413 {
414 testcase("VaultWithdraw IOU deep freeze withdraw to 3rd party");
415
416 env(trust(issuer, asset(0), charlie, tfSetFreeze | tfSetDeepFreeze));
417
418 auto withdrawToCharlie =
419 vault.withdraw({.depositor = owner, .id = keylet.key, .amount = asset(1)});
420 withdrawToCharlie[sfDestination] = charlie.human();
421 env(withdrawToCharlie, Ter(tecFROZEN));
422
423 // Destination deep freeze → self-withdraw unaffected
424 env(vault.withdraw({.depositor = owner, .id = keylet.key, .amount = asset(1)}));
425
426 env(trust(issuer, asset(0), charlie, tfClearFreeze | tfClearDeepFreeze));
427 env(vault.deposit({.depositor = owner, .id = keylet.key, .amount = asset(1)}));
428 env.close();
429 }
430
431 // Clawback works while frozen
432 {
433 testcase("VaultWithdraw IOU freeze clawback unaffected");
434 env(fset(issuer, asfGlobalFreeze));
435
436 env(vault.clawback(
437 {.issuer = issuer, .id = keylet.key, .holder = owner, .amount = asset(1)}));
438
439 env(fclear(issuer, asfGlobalFreeze));
440 env(vault.deposit({.depositor = owner, .id = keylet.key, .amount = asset(1)}));
441 env.close();
442 }
443 };
444
445 runTests();
446 env.disableFeature(fixCleanup3_3_0);
447 runTests();
448 env.enableFeature(fixCleanup3_3_0);
449 }
450
451 void
453 {
454 using namespace test::jtx;
455 testcase("VaultWithdraw MPT lock checks");
456
457 Account const issuer{"issuer"};
458 Account const owner{"owner"};
459 Env env{*this};
460 Vault vault{env};
461
462 env.fund(XRP(100'000), issuer, owner);
463 env.close();
464
465 MPTTester mptt{env, issuer, kMptInitNoFund};
466 mptt.create(
467 {.flags = tfMPTCanClawback | tfMPTCanTransfer | tfMPTCanLock | tfMPTRequireAuth});
468 PrettyAsset const mpt{mptt.issuanceID()};
469
470 mptt.authorize({.account = owner});
471 mptt.authorize({.account = issuer, .holder = owner});
472 env.close();
473 env(pay(issuer, owner, mpt(100'000)));
474 env.close();
475
476 auto [tx, keylet] = vault.create({.owner = owner, .asset = mpt});
477 env(tx);
478 env.close();
479 Account const vaultAcct("vault", env.le(keylet)->at(sfAccount));
480
481 env(vault.deposit({.depositor = owner, .id = keylet.key, .amount = mpt(100)}));
482 env.close();
483
484 Account const charlie{"charlie"};
485 env.fund(XRP(10'000), charlie);
486 env.close();
487 mptt.authorize({.account = charlie});
488 mptt.authorize({.account = issuer, .holder = charlie});
489 env.close();
490
491 auto const runTests = [&] {
492 auto const fix330Enabled = env.current()->rules().enabled(fixCleanup3_3_0);
493
494 // Global lock
495 {
496 testcase("VaultWithdraw MPT global lock");
497 mptt.set({.flags = tfMPTLock});
498 env.close();
499 env(vault.withdraw({.depositor = owner, .id = keylet.key, .amount = mpt(1)}),
500 Ter(tecLOCKED));
501
502 // Global lock → withdraw to issuer
503 // Post-fix: bypasses freeze checks, but accountHolds
504 // on the pseudo returns 0 under global lock
505 // Pre-fix: checkFrozen(dst=issuer) catches global lock
506 {
507 auto withdrawToIssuer =
508 vault.withdraw({.depositor = owner, .id = keylet.key, .amount = mpt(1)});
509 withdrawToIssuer[sfDestination] = issuer.human();
510 env(withdrawToIssuer, Ter(fix330Enabled ? TER(tesSUCCESS) : TER(tecLOCKED)));
511 }
512 mptt.set({.flags = tfMPTUnlock});
513 env.close();
514 if (fix330Enabled)
515 {
516 env(vault.deposit({.depositor = owner, .id = keylet.key, .amount = mpt(1)}));
517 }
518 env.close();
519 }
520
521 // Vault pseudo-account individual lock
522 {
523 testcase("VaultWithdraw MPT pseudo-account lock");
524 mptt.set({.holder = vaultAcct, .flags = tfMPTLock});
525 env.close();
526 env(vault.withdraw({.depositor = owner, .id = keylet.key, .amount = mpt(1)}),
527 Ter(tecLOCKED));
528 mptt.set({.holder = vaultAcct, .flags = tfMPTUnlock});
529 env.close();
530 }
531
532 // Depositor individual lock → self-withdraw blocked
533 // (isDeepFrozen == isFrozen for MPT)
534 {
535 testcase("VaultWithdraw MPT depositor lock");
536 mptt.set({.holder = owner, .flags = tfMPTLock});
537 env.close();
538 env(vault.withdraw({.depositor = owner, .id = keylet.key, .amount = mpt(1)}),
539 Ter(tecLOCKED));
540 // Depositor lock → withdraw to 3rd party also blocked
541 {
542 auto withdrawToCharlie =
543 vault.withdraw({.depositor = owner, .id = keylet.key, .amount = mpt(1)});
544 withdrawToCharlie[sfDestination] = charlie.human();
545 env(withdrawToCharlie, Ter(tecLOCKED));
546 }
547
548 // Depositor lock → withdraw to issuer
549 // Post-fix: issuer bypass in checkWithdrawFreezes
550 // Pre-fix: checkFrozen(depositor, share) blocks transitively
551 {
552 auto withdrawToIssuer =
553 vault.withdraw({.depositor = owner, .id = keylet.key, .amount = mpt(1)});
554 withdrawToIssuer[sfDestination] = issuer.human();
555 env(withdrawToIssuer, Ter(fix330Enabled ? TER(tesSUCCESS) : TER(tecLOCKED)));
556 }
557 mptt.set({.holder = owner, .flags = tfMPTUnlock});
558 env.close();
559 if (fix330Enabled)
560 {
561 env(vault.deposit({.depositor = owner, .id = keylet.key, .amount = mpt(1)}));
562 }
563 env.close();
564 }
565
566 // 3rd party destination lock → withdraw to 3rd party blocked
567 {
568 testcase("VaultWithdraw MPT 3rd party destination lock");
569 mptt.set({.holder = charlie, .flags = tfMPTLock});
570 env.close();
571 {
572 auto withdrawToCharlie =
573 vault.withdraw({.depositor = owner, .id = keylet.key, .amount = mpt(1)});
574 withdrawToCharlie[sfDestination] = charlie.human();
575 env(withdrawToCharlie, Ter{tecLOCKED});
576 }
577 // 3rd party lock → self-withdraw unaffected
578 env(vault.withdraw({.depositor = owner, .id = keylet.key, .amount = mpt(1)}));
579 mptt.set({.holder = charlie, .flags = tfMPTUnlock});
580 env.close();
581 env(vault.deposit({.depositor = owner, .id = keylet.key, .amount = mpt(1)}));
582 env.close();
583 }
584
585 // Clawback works while locked
586 {
587 testcase("VaultWithdraw MPT lock clawback unaffected");
588 mptt.set({.flags = tfMPTLock});
589 env.close();
590 env(vault.clawback(
591 {.issuer = issuer, .id = keylet.key, .holder = owner, .amount = mpt(1)}));
592 mptt.set({.flags = tfMPTUnlock});
593 env.close();
594 env(vault.deposit({.depositor = owner, .id = keylet.key, .amount = mpt(1)}));
595 env.close();
596 }
597 };
598
599 runTests();
600 env.disableFeature(fixCleanup3_3_0);
601 runTests();
602 env.enableFeature(fixCleanup3_3_0);
603 }
604
605 // Focused demonstration: a depositor under an individual IOU freeze
606 // can still withdraw to themselves (self-withdrawal), but is blocked from
607 // withdrawing to a third party.
608 //
609 // Pre-fixCleanup3_3_0: both the self-withdrawal AND the third-party
610 // withdrawal were blocked because the old code checked checkFrozen on the
611 // destination regardless of whether it was the submitter.
612 // Post-fixCleanup3_3_0: checkWithdrawFreeze skips the submitter freeze
613 // check when submitter == destination, so self-withdrawal succeeds.
614 void
616 {
617 testcase("VaultWithdraw IOU self-withdrawal while individually frozen");
618
619 using namespace test::jtx;
620
621 Account const issuer{"issuer"};
622 Account const owner{"owner"};
623 Account const charlie{"charlie"};
624 Env env{*this};
625 Vault vault{env};
626
627 env.fund(XRP(100'000), issuer, owner, charlie);
628 env(fset(issuer, asfAllowTrustLineClawback));
629 env.close();
630
631 PrettyAsset const asset = issuer["IOU"];
632 env.trust(asset(1'000'000), owner);
633 env.trust(asset(1'000'000), charlie);
634 env(pay(issuer, owner, asset(100'000)));
635 env.close();
636
637 auto [tx, keylet] = vault.create({.owner = owner, .asset = asset});
638 env(tx);
639 env.close();
640
641 env(vault.deposit({.depositor = owner, .id = keylet.key, .amount = asset(10)}));
642 env.close();
643
644 auto const runTests = [&] {
645 auto const fix330Enabled = env.current()->rules().enabled(fixCleanup3_3_0);
646
647 // Set an individual freeze on the owner's IOU trustline.
648 env(trust(issuer, asset(0), owner, tfSetFreeze));
649 env.close();
650
651 // Self-withdrawal: submitter == destination, so the submitter
652 // freeze check is skipped.
653 // Post-fix: tesSUCCESS. Pre-fix: tecFROZEN.
654 env(vault.withdraw({.depositor = owner, .id = keylet.key, .amount = asset(1)}),
655 Ter(fix330Enabled ? TER(tesSUCCESS) : TER(tecFROZEN)));
656
657 // Withdrawal to a third party is blocked: submitter != destination
658 // so the submitter freeze check applies.
659 {
660 auto withdrawToCharlie =
661 vault.withdraw({.depositor = owner, .id = keylet.key, .amount = asset(1)});
662 withdrawToCharlie[sfDestination] = charlie.human();
663 // Post-fix: tecFROZEN (checkIndividualFrozen on submitter).
664 // Pre-fix: tecLOCKED (isFrozen on the vault share).
665 env(withdrawToCharlie, Ter(fix330Enabled ? TER(tecFROZEN) : TER(tecLOCKED)));
666 }
667
668 env(trust(issuer, asset(0), owner, tfClearFreeze));
669 env.close();
670 };
671
672 runTests();
673 env.disableFeature(fixCleanup3_3_0);
674 runTests();
675 env.enableFeature(fixCleanup3_3_0);
676 }
677
678public:
679 void
688};
689
690BEAST_DEFINE_TESTSUITE(VaultFreeze, app, xrpl);
691
692} // namespace xrpl
TestcaseT testcase
Memberspace for declaring test cases.
Definition suite.h:155
Represents a JSON value.
Definition json_value.h:121
void run() override
Runs the suite.
Shared base for the Vault*_test family under src/test/app/vault/.
test::jtx::PrettyAsset PrettyAsset
Keylet computation functions.
Definition Indexes.h:39
Use hash_* containers for keys that do not need a cryptographically secure hashing algorithm.
Definition algorithm.h:5
std::string toBase58(AccountID const &v)
Convert AccountID to base58 checked string.
Definition AccountID.cpp:95
TERSubset< CanCvtToTER > TER
Definition TER.h:657
@ tecLOCKED
Definition TER.h:369
@ tecFROZEN
Definition TER.h:314
BEAST_DEFINE_TESTSUITE(AccountTxPaging, app, xrpl)
@ tesSUCCESS
Definition TER.h:253