xrpld
Loading...
Searching...
No Matches
VaultFixedPrecision_test.cpp
1#include <test/app/vault/VaultFixedPrecisionBase.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/pay.h>
7#include <test/jtx/ter.h>
8#include <test/jtx/trust.h>
9#include <test/jtx/vault.h>
10
11#include <xrpl/basics/Number.h>
12#include <xrpl/beast/unit_test/suite.h>
13#include <xrpl/beast/utility/Zero.h>
14#include <xrpl/ledger/helpers/VaultHelpers.h>
15#include <xrpl/protocol/Asset.h>
16#include <xrpl/protocol/Feature.h>
17#include <xrpl/protocol/Issue.h>
18#include <xrpl/protocol/Keylet.h>
19#include <xrpl/protocol/Protocol.h>
20#include <xrpl/protocol/SField.h>
21#include <xrpl/protocol/STAmount.h>
22#include <xrpl/protocol/STNumber.h> // IWYU pragma: keep
23#include <xrpl/protocol/TER.h>
24#include <xrpl/protocol/TxFlags.h>
25
26#include <cstdint>
27#include <optional>
28#include <string>
29#include <utility>
30#include <vector>
31
32namespace xrpl {
33
35{
36 void
38 {
39 using namespace test::jtx;
40
41 Account const issuer{"issuer"};
42 Account const owner{"owner"};
43 PrettyAsset const asset{issuer["USD"]};
44
45 {
46 testcase("VaultCreate writes FixedPrecision fields");
47 Env env(*this, features());
48 env.fund(XRP(1'000'000), issuer, owner);
49 env.close();
50
51 Vault const vault{env};
52 auto [tx, keylet] = vault.create({.owner = owner, .asset = asset});
53 env(tx);
54 env.close();
55
56 auto const sle = env.le(keylet);
57 if (!BEAST_EXPECT(sle))
58 return;
59 BEAST_EXPECT(sle->at(sfLEVersion) == std::to_underlying(VaultVersion::FixedPrecision));
60 BEAST_EXPECT(sle->at(sfScale) == kVaultDefaultIouScale);
61 BEAST_EXPECT(sle->at(sfYieldUnrealized) == beast::kZero);
62 BEAST_EXPECT(sle->at(sfAssetsDeployed) == beast::kZero);
63 BEAST_EXPECT(getAssetsTotal(sle) == beast::kZero);
64 BEAST_EXPECT(sle->at(sfAssetsTotal) == getAssetsTotal(sle));
65 }
66
67 {
69 "VaultCreate without V1.1: V1.2 alone creates neither FixedPrecision nor "
70 "closed-ended Vaults");
71 Env env(*this, features() - featureLendingProtocolV1_1);
72 env.fund(XRP(1'000'000), issuer, owner);
73 env.close();
74
75 Vault const vault{env};
76 // VaultKind and the closed-ended dates need featureLendingProtocolV1_1.
77 auto [kindTx, kindKeylet] = vault.create({
78 .owner = owner,
79 .asset = asset,
80 .vaultKind = std::to_underlying(VaultKind::OpenEnded),
81 });
82 env(kindTx, Ter(temDISABLED));
83 BEAST_EXPECT(!env.le(kindKeylet));
84
85 // A plain VaultCreate makes a Legacy Vault, with the legacy Scale maximum.
86 auto [tx, keylet] = vault.create({.owner = owner, .asset = asset});
87 tx[sfScale] = static_cast<std::uint8_t>(kFixedPrecisionVaultMaximumIouScale + 1);
88 env(tx);
89 env.close();
90
91 auto const sle = env.le(keylet);
92 if (!BEAST_EXPECT(sle))
93 return;
94 BEAST_EXPECT(!sle->isFieldPresent(sfLEVersion));
95 BEAST_EXPECT(getVaultVersion(sle) == VaultVersion::Legacy);
96 }
97
98 // Without fixCleanup3_4_0, V1_2 alone leaves a vault on the CashBasis rules,
99 // including the legacy Scale maximum.
100 struct Row
101 {
102 char const* name = nullptr;
103 FeatureBitset amendments;
105 TER ter;
106 VaultVersion version;
107 };
108 auto const aboveFixed = static_cast<std::uint8_t>(kFixedPrecisionVaultMaximumIouScale + 1);
109 auto const fixedVersion = VaultVersion::FixedPrecision;
110 auto const cashVersion = VaultVersion::CashBasis;
111 Row const rows[] = {
112 {
113 .name = "VaultCreate accepts fixed Scale maximum",
114 .amendments = features(),
116 .ter = tesSUCCESS,
117 .version = fixedVersion,
118 },
119 {
120 .name = "VaultCreate rejects Scale above fixed maximum",
121 .amendments = features(),
122 .scale = aboveFixed,
123 .ter = temMALFORMED,
124 .version = fixedVersion,
125 },
126 {
127 .name = "CashBasis Vault retains legacy Scale maximum",
128 .amendments = features() - featureLendingProtocolV1_2,
130 .ter = tesSUCCESS,
131 .version = cashVersion,
132 },
133 {
134 .name = "VaultCreate: V1_2 on, fixCleanup3_4_0 off falls back to the legacy Scale "
135 "maximum",
136 .amendments = features() - fixCleanup3_4_0,
138 .ter = tesSUCCESS,
139 .version = cashVersion,
140 },
141 {
142 .name = "VaultCreate: V1_2 on, fixCleanup3_4_0 off accepts Scale above the fixed "
143 "maximum",
144 .amendments = features() - fixCleanup3_4_0,
145 .scale = aboveFixed,
146 .ter = tesSUCCESS,
147 .version = cashVersion,
148 },
149 };
150 for (auto const& row : rows)
151 {
152 testcase(row.name);
153 Env env(*this, row.amendments);
154 env.fund(XRP(1'000'000), issuer, owner);
155 env.close();
156
157 Vault const vault{env};
158 auto [tx, keylet] = vault.create({.owner = owner, .asset = asset});
159 tx[sfScale] = row.scale;
160 env(tx, Ter(row.ter));
161 env.close();
162
163 auto const sle = env.le(keylet);
164 if (row.ter != tesSUCCESS)
165 {
166 BEAST_EXPECT(!sle);
167 continue;
168 }
169 if (!BEAST_EXPECT(sle))
170 continue;
171 BEAST_EXPECT(sle->at(sfScale) == row.scale);
172 BEAST_EXPECT(sle->at(sfLEVersion) == std::to_underlying(row.version));
173 if (row.version == cashVersion)
174 {
175 BEAST_EXPECT(!sle->isFieldPresent(sfYieldUnrealized));
176 BEAST_EXPECT(!sle->isFieldPresent(sfAssetsDeployed));
177 }
178 }
179 }
180
181 void
183 {
184 using namespace test::jtx;
185
186 Number const open{9, 9};
187 Number const baseUnit{1, -6};
188
189 Env env(*this, features());
190 auto const [issuer, owner, depositor, asset] =
191 setupIou(env, {.ownerOnly = true, .ownerTrust = open + Number{1}});
192
193 auto [vault, keylet] = createScaledVault(env, owner, asset, 6);
194
195 testcase("VaultDeposit admits the Open boundary");
196 env(vault.deposit({.depositor = owner, .id = keylet.key, .amount = asset(open)}));
197 env.close();
198
199 expectVault(env, keylet, {.available = open, .assetsDeployed = Number{0}, .total = open});
200
201 testcase("VaultDeposit rejects one base unit above Open");
202 env(vault.deposit({.depositor = owner, .id = keylet.key, .amount = asset(baseUnit)}),
203 Ter(tecLIMIT_EXCEEDED));
204 env.close();
205
206 expectVault(env, keylet, {.available = open, .assetsDeployed = Number{0}, .total = open});
207 }
208
209 void
211 {
212 using namespace test::jtx;
213
214 testcase("V1.2 does not migrate an existing CashBasis Vault");
215
216 Account const issuer{"issuer"};
217 Account const owner{"owner"};
218 PrettyAsset const asset{issuer["USD"]};
219 Number const deposit{9'999'999'999'999'999LL};
220
221 Env env(*this, features() - featureLendingProtocolV1_2);
222 env.fund(XRP(1'000'000), issuer, owner);
223 env.close();
224 env(trust(owner, STAmount{asset.raw(), 2, 16}));
225 env.close();
226 env(pay(issuer, owner, asset(deposit)));
227 env.close();
228
229 Vault const vault{env};
230 auto [create, keylet] = vault.create({.owner = owner, .asset = asset});
231 create[sfScale] = 0;
232 env(create);
233 env.close();
234
235 auto const before = env.le(keylet);
236 if (!BEAST_EXPECT(before))
237 return;
238 BEAST_EXPECT(before->at(sfLEVersion) == std::to_underlying(VaultVersion::CashBasis));
239
240 env.enableFeature(featureLendingProtocolV1_2);
241 env.close();
242 env(vault.deposit({.depositor = owner, .id = keylet.key, .amount = asset(deposit)}));
243 env.close();
244
245 auto const after = env.le(keylet);
246 if (!BEAST_EXPECT(after))
247 return;
248 BEAST_EXPECT(after->at(sfLEVersion) == std::to_underlying(VaultVersion::CashBasis));
249 BEAST_EXPECT(!after->isFieldPresent(sfYieldUnrealized));
250 BEAST_EXPECT(!after->isFieldPresent(sfAssetsDeployed));
251 BEAST_EXPECT(after->at(sfAssetsTotal) == deposit);
252 }
253
254 void
256 {
257 using namespace test::jtx;
258
259 // On a fresh vault the share price is one base unit, so the share round-trip
260 // already lands on the Scale-6 grid. These cases check that deposit, withdraw
261 // and clawback still book the truncated amount.
262
263 Number const depositRequested{32'345'678, -7}; // 3.2345678
264 Number const outflowRequested{10'000'005, -7}; // 1.0000005
265
266 Env env(*this, features());
267 auto const [issuer, owner, depositor, asset] =
268 setupIou(env, {.clawback = true, .ownerOnly = true, .ownerTrust = 4});
269
270 auto [vault, keylet] = createScaledVault(env, owner, asset, 6);
271
272 testcase("VaultDeposit books the truncated amount on the base grid");
273 env(vault.deposit(
274 {.depositor = owner, .id = keylet.key, .amount = asset(depositRequested)}));
275 env.close();
276
278 env,
279 keylet,
280 {
281 .available = Number{3'234'567, -6},
282 .assetsDeployed = Number{0},
283 .total = Number{3'234'567, -6},
284 });
285 BEAST_EXPECT(env.balance(owner, asset) == asset(Number{765'433, -6}));
286
287 testcase("VaultWithdraw books the truncated amount on the base grid");
288 env(vault.withdraw(
289 {.depositor = owner, .id = keylet.key, .amount = asset(outflowRequested)}));
290 env.close();
291
293 env,
294 keylet,
295 {
296 .available = Number{2'234'567, -6},
297 .assetsDeployed = Number{0},
298 .total = Number{2'234'567, -6},
299 });
300 BEAST_EXPECT(env.balance(owner, asset) == asset(Number{1'765'433, -6}));
301
302 testcase("VaultClawback books the truncated amount on the base grid");
303 env(vault.clawback({
304 .issuer = issuer,
305 .id = keylet.key,
306 .holder = owner,
307 .amount = asset(outflowRequested).value(),
308 }));
309 env.close();
310
312 env,
313 keylet,
314 {
315 .available = Number{1'234'567, -6},
316 .assetsDeployed = Number{0},
317 .total = Number{1'234'567, -6},
318 });
319 }
320
321 void
323 {
324 using namespace test::jtx;
325
326 testcase("FixedPrecision MPT Vault enforces integral Open zone");
327
328 constexpr std::uint64_t open = 9'000'000'000'000'000;
329 constexpr std::uint64_t maximum = open + 1;
330
331 Env env(*this, features());
332 auto const [issuer, owner, depositor, asset] =
333 setupMpt(env, {.maxAmt = maximum, .holderFunds = maximum});
334
335 Vault const vault{env};
336 auto [create, keylet] = vault.create({.owner = owner, .asset = asset});
337 env(create);
338 env.close();
339
340 env(vault.deposit({.depositor = owner, .id = keylet.key, .amount = asset(open)}));
341 env.close();
342 env(vault.deposit({.depositor = owner, .id = keylet.key, .amount = asset(1)}),
343 Ter(tecLIMIT_EXCEEDED));
344
345 auto const sle = env.le(keylet);
346 if (!BEAST_EXPECT(sle))
347 return;
348 BEAST_EXPECT(sle->at(sfAssetsTotal) == Number{open});
349 }
350
351 void
353 {
354 using namespace test::jtx;
355
356 Env env(*this, features());
357 auto const [issuer, owner, depositor, asset] =
358 setupIou(env, {.clawback = true, .depositorTrust = 2});
359 auto [vault, keylet] = createScaledVault(env, owner, asset, 6);
360 Number const dust{1, -7};
361
362 testcase("VaultDeposit rejects sub-base-unit dust");
363 env(vault.deposit({.depositor = depositor, .id = keylet.key, .amount = asset(dust)}),
364 Ter(tecPRECISION_LOSS));
365
366 env(vault.deposit({.depositor = depositor, .id = keylet.key, .amount = asset(1)}));
367 env.close();
368
369 testcase("VaultWithdraw rejects sub-base-unit dust");
370 env(vault.withdraw({.depositor = depositor, .id = keylet.key, .amount = asset(dust)}),
371 Ter(tecPRECISION_LOSS));
372
373 testcase("VaultClawback rejects sub-base-unit dust");
374 env(vault.clawback({
375 .issuer = issuer,
376 .id = keylet.key,
377 .holder = depositor,
378 .amount = asset(dust).value(),
379 }),
380 Ter(tecPRECISION_LOSS));
381 }
382
390
391 // Applies each step as holder (the issuer claws back) and checks the
392 // expected AssetsAvailable after it.
393 void
395 test::jtx::Env& env,
396 test::jtx::Vault const& vault,
397 Keylet const& keylet,
398 test::jtx::Account const& issuer,
399 test::jtx::Account const& holder,
400 PrettyAsset const& asset,
401 std::vector<SyncStep> const& steps)
402 {
403 for (auto const& step : steps)
404 {
405 switch (step.op)
406 {
408 env(vault.deposit(
409 {.depositor = holder, .id = keylet.key, .amount = asset(step.amount)}));
410 break;
412 env(vault.withdraw(
413 {.depositor = holder, .id = keylet.key, .amount = asset(step.amount)}));
414 break;
416 env(vault.clawback({
417 .issuer = issuer,
418 .id = keylet.key,
419 .holder = holder,
420 .amount = asset(step.amount).value(),
421 }));
422 break;
423 }
424 env.close();
425 checkFixedPrecisionSync(env, keylet, Number{step.expectedAvailable});
426 }
427 }
428
429 void
431 {
432 using namespace test::jtx;
433 using Op = SyncStep::Op;
434
435 testcase("FixedPrecision IOU vault keeps AssetsTotal in sync across deposits/withdrawals");
436
437 Env env(*this, features());
438 auto const [issuer, owner, depositor, asset] =
439 setupIou(env, {.ownerOnly = true, .ownerTrust = 10'000});
440
441 Vault const vault{env};
442 auto [create, keylet] = vault.create({.owner = owner, .asset = asset});
443 env(create);
444 env.close();
445
446 // Two deposits, a partial withdrawal, then a final withdrawal that empties
447 // the vault.
449 env,
450 vault,
451 keylet,
452 issuer,
453 owner,
454 asset,
455 {
456 {.op = Op::Deposit, .amount = 1'000, .expectedAvailable = 1'000},
457 {.op = Op::Deposit, .amount = 500, .expectedAvailable = 1'500},
458 {.op = Op::Withdraw, .amount = 600, .expectedAvailable = 900},
459 {.op = Op::Withdraw, .amount = 900, .expectedAvailable = 0},
460 });
461 }
462
463 void
465 {
466 using namespace test::jtx;
467 using Op = SyncStep::Op;
468
469 testcase(
470 "FixedPrecision IOU vault keeps AssetsTotal in sync across clawback and final "
471 "withdrawal");
472
473 Env env(*this, features());
474 auto const [issuer, owner, depositor, asset] = setupIou(env, {.clawback = true});
475
476 Vault const vault{env};
477 auto [create, keylet] = vault.create({.owner = owner, .asset = asset});
478 env(create);
479 env.close();
480
481 // Clawback partially recovers assets; the rest is a final withdrawal.
483 env,
484 vault,
485 keylet,
486 issuer,
487 depositor,
488 asset,
489 {
490 {.op = Op::Deposit, .amount = 1'000, .expectedAvailable = 1'000},
491 {.op = Op::Clawback, .amount = 400, .expectedAvailable = 600},
492 {.op = Op::Withdraw, .amount = 600, .expectedAvailable = 0},
493 });
494 }
495
496 void
498 {
499 using namespace test::jtx;
500 using Op = SyncStep::Op;
501
502 testcase("FixedPrecision MPT vault keeps AssetsTotal in sync across deposits/withdrawals");
503
504 constexpr std::uint64_t total = 1'000;
505
506 Env env(*this, features());
507 auto const [issuer, owner, depositor, asset] =
508 setupMpt(env, {.maxAmt = total, .holderFunds = total});
509
510 Vault const vault{env};
511 auto [create, keylet] = vault.create({.owner = owner, .asset = asset});
512 env(create);
513 env.close();
514
516 env,
517 vault,
518 keylet,
519 issuer,
520 owner,
521 asset,
522 {
523 {.op = Op::Deposit, .amount = total, .expectedAvailable = total},
524 {.op = Op::Withdraw, .amount = 400, .expectedAvailable = 600},
525 {.op = Op::Withdraw, .amount = 600, .expectedAvailable = 0},
526 });
527 }
528
529 void
531 {
532 using namespace test::jtx;
533
534 testcase(
535 "CashBasis vault: AssetsTotal tracks AssetsAvailable directly, AssetsDeployed absent");
536
537 Env env(*this, features() - featureLendingProtocolV1_2);
538 auto const [issuer, owner, depositor, asset] = setupIou(env, {.ownerOnly = true});
539
540 Vault const vault{env};
541 auto [create, keylet] = vault.create({.owner = owner, .asset = asset});
542 create[sfScale] = 0;
543 env(create);
544 env.close();
545
546 auto const expectCashBasis = [&](Number const& expected) {
547 auto const sle = env.le(keylet);
548 if (!BEAST_EXPECT(sle))
549 return;
550 BEAST_EXPECT(!sle->isFieldPresent(sfAssetsDeployed));
551 BEAST_EXPECT(sle->at(sfAssetsTotal) == sle->at(sfAssetsAvailable));
552 BEAST_EXPECT(sle->at(sfAssetsTotal) == expected);
553 BEAST_EXPECT(getAssetsTotal(sle) == expected);
554 };
555
556 // Deposit and partial withdrawal move AssetsAvailable and AssetsTotal
557 // together; there is no AssetsDeployed.
558 env(vault.deposit({.depositor = owner, .id = keylet.key, .amount = asset(1'000)}));
559 env.close();
560 expectCashBasis(Number{1'000});
561
562 env(vault.withdraw({.depositor = owner, .id = keylet.key, .amount = asset(400)}));
563 env.close();
564 expectCashBasis(Number{600});
565
566 // Final withdrawal leaves both at zero.
567 env(vault.withdraw({.depositor = owner, .id = keylet.key, .amount = asset(600)}));
568 env.close();
569 expectCashBasis(Number{0});
570 }
571
572 // FixedPrecision VaultCreate refuses an AssetsMaximum that is not
573 // exactly representable on the vault's base grid (10^-Scale), whether
574 // because it needs more than 16 significant digits or because it has a
575 // nonzero digit finer than the grid.
576 void
578 {
579 using namespace test::jtx;
580
581 testcase("FixedPrecision VaultCreate: AssetsMaximum must be exactly representable");
582
583 Account const issuer{"issuer"};
584 Account const owner{"owner"};
585 PrettyAsset const asset{issuer["USD"]};
586
587 Env env(*this, features());
588 env.fund(XRP(1'000'000), issuer, owner);
589 env.close();
590
591 Vault const vault{env};
592
593 auto const tryCreate =
594 [&](Number const& cap, std::optional<std::uint8_t> scale, TER expected) {
595 auto [tx, keylet] = vault.create({.owner = owner, .asset = asset});
596 if (scale)
597 tx[sfScale] = *scale;
598 tx[sfAssetsMaximum] = cap;
599 env(tx, Ter(expected));
600 env.close();
601 if (expected == tesSUCCESS)
602 {
603 auto const sle = env.le(keylet);
604 if (BEAST_EXPECT(sle))
605 BEAST_EXPECT(Number(sle->at(sfAssetsMaximum)) == cap);
606 }
607 else
608 {
609 BEAST_EXPECT(!env.le(keylet));
610 }
611 };
612
613 // Default Scale (6). 17 significant digits: not exactly representable
614 // in a 16-digit STAmount.
615 tryCreate(Number{12345678901234567LL, -1}, std::nullopt, tecPRECISION_LOSS);
616
617 // Within 16 digits but off the 10^-6 base grid.
618 tryCreate(Number{10000001, -7}, std::nullopt, tecPRECISION_LOSS);
619
620 // Exactly on the base grid.
621 tryCreate(Number{1000001, -6}, std::nullopt, tesSUCCESS);
622
623 // Large value, still on the grid: any integer is a multiple of 10^-6.
624 tryCreate(Number{1, 20}, std::nullopt, tesSUCCESS);
625
626 // A different Scale: on grid.
627 tryCreate(Number{1, -2}, std::uint8_t{2}, tesSUCCESS);
628
629 // Same Scale: off grid (extra digit at 10^-3).
630 tryCreate(Number{1, -3}, std::uint8_t{2}, tecPRECISION_LOSS);
631
632 // V1_2 without V1_1 creates a Legacy Vault, which keeps the existing
633 // behavior: no base-grid check on AssetsMaximum.
634 {
635 Env legacyEnv(*this, features() - featureLendingProtocolV1_1);
636 legacyEnv.fund(XRP(1'000'000), issuer, owner);
637 legacyEnv.close();
638
639 Vault const legacyVault{legacyEnv};
640 auto [tx, keylet] = legacyVault.create({.owner = owner, .asset = asset});
641 tx[sfAssetsMaximum] = Number{10000001, -7};
642 legacyEnv(tx, Ter(tesSUCCESS));
643 legacyEnv.close();
644 if (auto const sle = legacyEnv.le(keylet); BEAST_EXPECT(sle))
645 BEAST_EXPECT(getVaultVersion(sle) == VaultVersion::Legacy);
646 }
647 }
648
649 // Same conditions, enforced by VaultSet::preclaim against the vault's
650 // already-fixed Scale. A refused Set must leave AssetsMaximum unchanged.
651 void
653 {
654 using namespace test::jtx;
655
656 testcase("FixedPrecision VaultSet: AssetsMaximum must be exactly representable");
657
658 Account const issuer{"issuer"};
659 Account const owner{"owner"};
660 PrettyAsset const asset{issuer["USD"]};
661
662 Env env(*this, features());
663 env.fund(XRP(1'000'000), issuer, owner);
664 env.close();
665
666 Vault const vault{env};
667 auto [create, keylet] = vault.create({.owner = owner, .asset = asset});
668 env(create);
669 env.close();
670
671 auto currentMax = [&] -> std::optional<Number> {
672 auto const sle = env.le(keylet);
673 if (!BEAST_EXPECT(sle))
674 return std::nullopt;
675 if (!sle->isFieldPresent(sfAssetsMaximum))
676 return std::nullopt;
677 return Number(sle->at(sfAssetsMaximum));
678 };
679
680 auto const trySet = [&](Number const& cap, TER expected) {
681 auto const before = currentMax();
682 auto tx = vault.set({.owner = owner, .id = keylet.key});
683 tx[sfAssetsMaximum] = cap;
684 env(tx, Ter(expected));
685 env.close();
686 if (expected == tesSUCCESS)
687 {
688 BEAST_EXPECT(currentMax() == cap);
689 }
690 else
691 {
692 BEAST_EXPECT(currentMax() == before);
693 }
694 };
695
696 // 17 significant digits.
697 trySet(Number{12345678901234567LL, -1}, tecPRECISION_LOSS);
698 // Off the 10^-6 grid but within 16 digits.
699 trySet(Number{10000001, -7}, tecPRECISION_LOSS);
700 // Exactly on the grid: accepted and stored.
701 trySet(Number{1000001, -6}, tesSUCCESS);
702 // Large on-grid value.
703 trySet(Number{1, 20}, tesSUCCESS);
704 }
705
706 // On an integral asset (MPT, XRP) the base grid is 10^0, so any
707 // non-integral AssetsMaximum is refused regardless of digit count.
708 void
710 {
711 using namespace test::jtx;
712
713 testcase("FixedPrecision VaultCreate: AssetsMaximum on integral assets (MPT, XRP)");
714
715 // MPT.
716 {
717 Env env(*this, features());
718 auto const [issuer, owner, depositor, asset] =
719 setupMpt(env, {.maxAmt = 1'000'000, .holderFunds = 1'000'000});
720
721 Vault const vault{env};
722 {
723 auto [tx, keylet] = vault.create({.owner = owner, .asset = asset});
724 tx[sfAssetsMaximum] = Number{5, -1}; // 0.5, non-integral
725 env(tx, Ter(tecPRECISION_LOSS));
726 env.close();
727 BEAST_EXPECT(!env.le(keylet));
728 }
729 {
730 auto [tx, keylet] = vault.create({.owner = owner, .asset = asset});
731 tx[sfAssetsMaximum] = Number{1'000};
732 env(tx, Ter(tesSUCCESS));
733 env.close();
734 auto const sle = env.le(keylet);
735 if (BEAST_EXPECT(sle))
736 BEAST_EXPECT(Number(sle->at(sfAssetsMaximum)) == Number{1'000});
737 }
738 }
739
740 // XRP.
741 {
742 Env env(*this, features());
743 Account const owner{"owner"};
744 env.fund(XRP(1'000'000), owner);
745 env.close();
746 PrettyAsset const asset = xrpIssue();
747
748 Vault const vault{env};
749 {
750 auto [tx, keylet] = vault.create({.owner = owner, .asset = asset});
751 tx[sfAssetsMaximum] = Number{5, -1};
752 env(tx, Ter(tecPRECISION_LOSS));
753 env.close();
754 BEAST_EXPECT(!env.le(keylet));
755 }
756 {
757 auto [tx, keylet] = vault.create({.owner = owner, .asset = asset});
758 tx[sfAssetsMaximum] = Number{1'000};
759 env(tx, Ter(tesSUCCESS));
760 env.close();
761 auto const sle = env.le(keylet);
762 if (BEAST_EXPECT(sle))
763 BEAST_EXPECT(Number(sle->at(sfAssetsMaximum)) == Number{1'000});
764 }
765 }
766 }
767
768 // Control: pre-V1.2 (CashBasis) vaults have no FixedPrecision grid
769 // check, so an off-grid AssetsMaximum is accepted on both VaultCreate and
770 // VaultSet, as before this change.
771 void
773 {
774 using namespace test::jtx;
775
776 testcase(
777 "Pre-FixedPrecision (CashBasis) VaultCreate/Set: AssetsMaximum grid check does not "
778 "apply");
779
780 Account const issuer{"issuer"};
781 Account const owner{"owner"};
782 PrettyAsset const asset{issuer["USD"]};
783
784 Env env(*this, features() - featureLendingProtocolV1_2);
785 env.fund(XRP(1'000'000), issuer, owner);
786 env.close();
787
788 Vault const vault{env};
789 // Off the 10^-6 grid: on FixedPrecision this would be tecPRECISION_LOSS.
790 Number const offGrid{10000001, -7};
791
792 auto [create, keylet] = vault.create({.owner = owner, .asset = asset});
793 create[sfScale] = 0;
794 create[sfAssetsMaximum] = offGrid;
795 env(create, Ter(tesSUCCESS));
796 env.close();
797
798 auto const sle = env.le(keylet);
799 if (BEAST_EXPECT(sle))
800 BEAST_EXPECT(Number(sle->at(sfAssetsMaximum)) == offGrid);
801
802 // VaultSet with a different off-grid value on the same pre-V1.2 vault.
803 Number const offGrid2{10000003, -7};
804 auto tx = vault.set({.owner = owner, .id = keylet.key});
805 tx[sfAssetsMaximum] = offGrid2;
806 env(tx, Ter(tesSUCCESS));
807 env.close();
808 auto const sle2 = env.le(keylet);
809 if (BEAST_EXPECT(sle2))
810 BEAST_EXPECT(Number(sle2->at(sfAssetsMaximum)) == offGrid2);
811 }
812
813 // With featureLendingProtocolV1_2 enabled, VaultSet rejects an
814 // AssetsMaximum that is not representable at the Vault's scale on an
815 // existing pre-V1.2 (CashBasis) Vault too. A Legacy/CashBasis Vault's scale
816 // follows its AssetsTotal, so this uses a cap with more digits than an
817 // STAmount holds.
818 void
820 {
821 using namespace test::jtx;
822
823 testcase("Existing CashBasis vault after V1.2: VaultSet rejects an unrepresentable cap");
824
825 Account const issuer{"issuer"};
826 Account const owner{"owner"};
827 PrettyAsset const asset{issuer["USD"]};
828
829 Env env(*this, features() - featureLendingProtocolV1_2);
830 env.fund(XRP(1'000'000), issuer, owner);
831 env.close();
832
833 Vault const vault{env};
834 auto [create, keylet] = vault.create({.owner = owner, .asset = asset});
835 env(create, Ter(tesSUCCESS));
836 env.close();
837
838 env.enableFeature(featureLendingProtocolV1_2);
839 env.close();
840
841 // 17 significant digits.
842 Number const unrepresentable{12'345'678'901'234'567, -1};
843 auto tx = vault.set({.owner = owner, .id = keylet.key});
844 tx[sfAssetsMaximum] = unrepresentable;
845 env(tx, Ter(tecPRECISION_LOSS));
846 env.close();
847
848 auto ok = vault.set({.owner = owner, .id = keylet.key});
849 ok[sfAssetsMaximum] = Number{1'000};
850 env(ok, Ter(tesSUCCESS));
851 env.close();
852 auto const sle = env.le(keylet);
853 if (BEAST_EXPECT(sle))
854 BEAST_EXPECT(Number(sle->at(sfAssetsMaximum)) == Number{1'000});
855 }
856
857 // A Vault created before featureLendingProtocolV1_2 keeps an AssetsMaximum
858 // that is off the 10^-Scale grid. After V1.2 the stored cap does not block
859 // VaultSet, the owner can replace it with an on-grid cap, and the new cap is
860 // enforced on deposit.
861 void
863 {
864 using namespace test::jtx;
865
866 testcase("Existing vault with an off-grid cap: VaultSet replaces it after V1.2");
867
868 Account const issuer{"issuer"};
869 Account const owner{"owner"};
870 PrettyAsset const asset{issuer["USD"]};
871
872 Env env(*this, features() - featureLendingProtocolV1_2);
873 env.fund(XRP(1'000'000), issuer, owner);
874 env.close();
875 env.trust(asset(1'000), owner);
876 env.close();
877 env(pay(issuer, owner, asset(1'000)));
878 env.close();
879
880 Vault const vault{env};
881 // Off the 10^0 grid.
882 Number const offGrid{100'000'001, -7};
883
884 auto [create, keylet] = vault.create({.owner = owner, .asset = asset});
885 create[sfScale] = 0;
886 create[sfAssetsMaximum] = offGrid;
887 env(create, Ter(tesSUCCESS));
888 env.close();
889
890 env(vault.deposit({.depositor = owner, .id = keylet.key, .amount = asset(1)}));
891 env.close();
892
893 env.enableFeature(featureLendingProtocolV1_2);
894 env.close();
895
896 auto const before = env.le(keylet);
897 if (!BEAST_EXPECT(before))
898 return;
899 BEAST_EXPECT(Number(before->at(sfAssetsMaximum)) == offGrid);
900 BEAST_EXPECT(getVaultVersion(before) == VaultVersion::CashBasis);
901
902 // A VaultSet that does not touch AssetsMaximum is not affected by the
903 // stored off-grid cap.
904 auto data = vault.set({.owner = owner, .id = keylet.key});
905 data[sfData] = "AB";
906 env(data, Ter(tesSUCCESS));
907 env.close();
908
909 auto onGrid = vault.set({.owner = owner, .id = keylet.key});
910 onGrid[sfAssetsMaximum] = Number{5};
911 env(onGrid, Ter(tesSUCCESS));
912 env.close();
913
914 auto const after = env.le(keylet);
915 if (!BEAST_EXPECT(after))
916 return;
917 BEAST_EXPECT(Number(after->at(sfAssetsMaximum)) == Number{5});
918
919 env(vault.deposit({.depositor = owner, .id = keylet.key, .amount = asset(4)}));
920 env.close();
921 env(vault.deposit({.depositor = owner, .id = keylet.key, .amount = asset(1)}),
922 Ter(tecLIMIT_EXCEEDED));
923 env.close();
924 BEAST_EXPECT(getAssetsTotal(env.le(keylet)) == Number{5});
925 }
926
927 // Reproduces a reported issue: the end-of-transaction associateAsset pass is not
928 // a no-op. The original witness (VaultDepositAssociateAsset_test.cpp) grows a
929 // vault's running total by two decades so the exact sum needs 18 digits, more
930 // than an IOU STAmount holds, and shows associateAsset quantizing it afterwards.
931 // On this branch that same deposit is refused outright: the Open-zone guard
932 // in checkOptionalVaultInflow (testDepositAdmission above) caps a FixedPrecision
933 // IOU vault's total at the largest value representable in 16 digits at its
934 // Scale, so a deposit that would need 18 digits never reaches associateAsset in
935 // the first place. This test reproduces the two-decade-jump shape at Scale 10
936 // (this branch's fixed Scale ceiling) and confirms it is rejected with
937 // tecLIMIT_EXCEEDED, leaving the vault unchanged -- the deposit side of the
938 // issue does not reproduce on FixedPrecision because the Open-zone guard
939 // forecloses it structurally.
940 //
941 // The Withdraw/Clawback witnesses are not exercised here: their dust-vault
942 // precondition (sfAssetsTotal below the smallest representable IOU, 10^-81)
943 // needs a donation into an insolvent vault, which VaultDeposit::preclaim
944 // refuses outright (tecLOCKED, no donation exemption -- a known, separately
945 // tracked gap) and is otherwise unreachable by any sequence of transactions,
946 // so it cannot be ported as a transactor test.
947 void
949 {
950 using namespace test::jtx;
951
952 testcase(
953 "A deposit shaped like the associateAsset witness is refused by the "
954 "Open-zone guard on FixedPrecision, not silently rounded");
955
956 Account const issuer{"issuer"};
957 Account const owner{"owner"};
958 Account const depositor{"depositor"};
959 PrettyAsset const asset{issuer["USD"]};
960
961 Env env(*this, features());
962 env.fund(XRP(1'000'000), issuer, owner, depositor);
963 env.close();
964 env(fset(issuer, asfDefaultRipple));
965 env.close();
966 env(trust(depositor, asset(20'000'000)));
967 env.close();
968 env(pay(issuer, depositor, asset(15'000'000)));
969 env.close();
970
971 Vault const vault{env};
972 auto [create, keylet] = vault.create({.owner = owner, .asset = asset});
973 create[sfScale] =
974 kFixedPrecisionVaultMaximumIouScale; // 10: the branch's fixed Scale ceiling
975 env(create);
976 env.close();
977
978 // First deposit uses all 16 digits an IOU STAmount has, at Scale 10 (span 10^5..10^-10),
979 // well inside the Open zone (9e5 at this Scale).
980 Number const firstDeposit{1'234'567'890'123'456LL, -10};
981 env(vault.deposit(
982 {.depositor = depositor, .id = keylet.key, .amount = asset(firstDeposit)}));
983 env.close();
984 checkFixedPrecisionSync(env, keylet, firstDeposit);
985
986 // Second deposit grows the magnitude by two more decades, mirroring the reporters'
987 // witness (span would become 10^7..10^-10, 18 digits): refused before associateAsset
988 // ever sees an unrepresentable total.
989 env(vault.deposit({.depositor = depositor, .id = keylet.key, .amount = asset(10'000'000)}),
990 Ter(tecLIMIT_EXCEEDED));
991 env.close();
992
993 // The vault is untouched by the refused deposit.
994 checkFixedPrecisionSync(env, keylet, firstDeposit);
995 }
996
997public:
998 void
1019};
1020
1021BEAST_DEFINE_TESTSUITE(VaultFixedPrecision, app, xrpl);
1022
1023} // namespace xrpl
TestcaseT testcase
Memberspace for declaring test cases.
Definition suite.h:155
Number is a floating point type that can represent a wide range of values.
Definition Number.h:351
static std::pair< test::jtx::Vault, Keylet > createScaledVault(test::jtx::Env &env, test::jtx::Account const &owner, Asset const &asset, std::uint8_t scale)
static AssetAccounts setupIou(test::jtx::Env &env, IouParams const &params)
SLE::const_pointer expectVault(test::jtx::Env const &env, Keylet const &vaultKeylet, VaultExpect const &expected)
static AssetAccounts setupMpt(test::jtx::Env &env, MptParams const &params)
void checkFixedPrecisionSync(test::jtx::Env const &env, Keylet const &vaultKeylet, Number const &expectedAvailable)
void run() override
Runs the suite.
void runSyncSteps(test::jtx::Env &env, test::jtx::Vault const &vault, Keylet const &keylet, test::jtx::Account const &issuer, test::jtx::Account const &holder, PrettyAsset const &asset, std::vector< SyncStep > const &steps)
test::jtx::PrettyAsset PrettyAsset
Immutable cryptographic account descriptor.
Definition jtx/Account.h:21
A transaction testing environment.
Definition Env.h:161
bool close(NetClock::time_point closeTime, std::optional< std::chrono::milliseconds > consensusDelay=std::nullopt)
Close and advance the ledger.
Definition Env.cpp:133
constexpr Zero kZero
Definition Zero.h:30
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
Issue const & xrpIssue()
Returns an asset specifier that represents XRP.
Definition Issue.h:108
int scale(Number const &number, Asset const &asset)
Get the scale of a Number for a given asset.
Definition STAmount.h:819
void open(soci::session &s, BasicConfig const &config, std::string const &dbName)
Open a soci session.
Definition SociDB.cpp:91
constexpr std::uint8_t kVaultDefaultIouScale
Default IOU scale factor for a Vault.
Definition Protocol.h:313
VaultVersion
Vault ledger-entry schema versions, persisted as sfLEVersion.
Definition Protocol.h:342
constexpr std::uint8_t kFixedPrecisionVaultMaximumIouScale
Maximum Scale for a Vault created under featureLendingProtocolV1_2.
Definition Protocol.h:325
bool after(NetClock::time_point now, std::uint32_t mark)
Has the specified time passed?
Definition View.cpp:668
constexpr std::uint8_t kLegacyVaultMaximumIouScale
Maximum Scale for a Vault created before featureLendingProtocolV1_2.
Definition Protocol.h:320
@ temMALFORMED
Definition TER.h:75
@ temDISABLED
Definition TER.h:102
TERSubset< CanCvtToTER > TER
Definition TER.h:657
@ tecPRECISION_LOSS
Definition TER.h:374
@ tecLIMIT_EXCEEDED
Definition TER.h:372
Number getAssetsTotal(SLE::ConstRef vault)
Return the Vault's current assets total.
VaultVersion getVaultVersion(SLE::ConstRef vault)
Resolves a Vault's LEVersion.
BEAST_DEFINE_TESTSUITE(AccountTxPaging, app, xrpl)
@ tesSUCCESS
Definition TER.h:253
A pair of SHAMap key and LedgerEntryType.
Definition Keylet.h:20