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>
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>
23#include <xrpl/protocol/TER.h>
24#include <xrpl/protocol/TxFlags.h>
46 testcase(
"VaultCreate writes FixedPrecision fields");
48 env.fund(XRP(1'000'000), issuer, owner);
51 Vault const vault{env};
52 auto [tx,
keylet] = vault.create({.owner = owner, .asset = asset});
56 auto const sle = env.le(
keylet);
57 if (!BEAST_EXPECT(sle))
61 BEAST_EXPECT(sle->at(sfYieldUnrealized) ==
beast::kZero);
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);
75 Vault const vault{env};
77 auto [kindTx, kindKeylet] = vault.create({
83 BEAST_EXPECT(!env.le(kindKeylet));
86 auto [tx,
keylet] = vault.create({.owner = owner, .asset = asset});
91 auto const sle = env.le(
keylet);
92 if (!BEAST_EXPECT(sle))
94 BEAST_EXPECT(!sle->isFieldPresent(sfLEVersion));
102 char const* name =
nullptr;
113 .name =
"VaultCreate accepts fixed Scale maximum",
117 .version = fixedVersion,
120 .name =
"VaultCreate rejects Scale above fixed maximum",
124 .version = fixedVersion,
127 .name =
"CashBasis Vault retains legacy Scale maximum",
128 .amendments =
features() - featureLendingProtocolV1_2,
131 .version = cashVersion,
134 .name =
"VaultCreate: V1_2 on, fixCleanup3_4_0 off falls back to the legacy Scale "
136 .amendments =
features() - fixCleanup3_4_0,
139 .version = cashVersion,
142 .name =
"VaultCreate: V1_2 on, fixCleanup3_4_0 off accepts Scale above the fixed "
144 .amendments =
features() - fixCleanup3_4_0,
147 .version = cashVersion,
150 for (
auto const& row : rows)
153 Env env(*
this, row.amendments);
154 env.fund(XRP(1'000'000), issuer, owner);
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));
163 auto const sle = env.le(
keylet);
169 if (!BEAST_EXPECT(sle))
171 BEAST_EXPECT(sle->at(sfScale) == row.scale);
172 BEAST_EXPECT(sle->at(sfLEVersion) == std::to_underlying(row.version));
173 if (row.version == cashVersion)
175 BEAST_EXPECT(!sle->isFieldPresent(sfYieldUnrealized));
176 BEAST_EXPECT(!sle->isFieldPresent(sfAssetsDeployed));
187 Number const baseUnit{1, -6};
190 auto const [issuer, owner, depositor, asset] =
195 testcase(
"VaultDeposit admits the Open boundary");
196 env(vault.deposit({.depositor = owner, .id = keylet.key, .amount = asset(open)}));
201 testcase(
"VaultDeposit rejects one base unit above Open");
202 env(vault.deposit({.depositor = owner, .id = keylet.key, .amount = asset(baseUnit)}),
214 testcase(
"V1.2 does not migrate an existing CashBasis Vault");
216 Account const issuer{
"issuer"};
219 Number const deposit{9'999'999'999'999'999LL};
221 Env env(*
this,
features() - featureLendingProtocolV1_2);
222 env.fund(XRP(1'000'000), issuer, owner);
226 env(pay(issuer, owner, asset(deposit)));
229 Vault const vault{env};
230 auto [create,
keylet] = vault.create({.owner = owner, .asset = asset});
235 auto const before = env.le(
keylet);
236 if (!BEAST_EXPECT(before))
240 env.enableFeature(featureLendingProtocolV1_2);
242 env(vault.deposit({.depositor = owner, .id = keylet.key, .amount = asset(deposit)}));
246 if (!BEAST_EXPECT(
after))
249 BEAST_EXPECT(!
after->isFieldPresent(sfYieldUnrealized));
250 BEAST_EXPECT(!
after->isFieldPresent(sfAssetsDeployed));
251 BEAST_EXPECT(
after->at(sfAssetsTotal) == deposit);
263 Number const depositRequested{32'345'678, -7};
264 Number const outflowRequested{10'000'005, -7};
267 auto const [issuer, owner, depositor, asset] =
268 setupIou(env, {.clawback =
true, .ownerOnly =
true, .ownerTrust = 4});
272 testcase(
"VaultDeposit books the truncated amount on the base grid");
274 {.depositor = owner, .id = keylet.key, .amount = asset(depositRequested)}));
281 .available =
Number{3'234'567, -6},
282 .assetsDeployed =
Number{0},
283 .total =
Number{3'234'567, -6},
285 BEAST_EXPECT(env.balance(owner, asset) == asset(
Number{765'433, -6}));
287 testcase(
"VaultWithdraw books the truncated amount on the base grid");
289 {.depositor = owner, .id = keylet.key, .amount = asset(outflowRequested)}));
296 .available =
Number{2'234'567, -6},
297 .assetsDeployed =
Number{0},
298 .total =
Number{2'234'567, -6},
300 BEAST_EXPECT(env.balance(owner, asset) == asset(
Number{1'765'433, -6}));
302 testcase(
"VaultClawback books the truncated amount on the base grid");
307 .amount = asset(outflowRequested).value(),
315 .available =
Number{1'234'567, -6},
316 .assetsDeployed =
Number{0},
317 .total =
Number{1'234'567, -6},
326 testcase(
"FixedPrecision MPT Vault enforces integral Open zone");
332 auto const [issuer, owner, depositor, asset] =
333 setupMpt(env, {.maxAmt = maximum, .holderFunds = maximum});
335 Vault const vault{env};
336 auto [create,
keylet] = vault.create({.owner = owner, .asset = asset});
340 env(vault.deposit({.depositor = owner, .id = keylet.key, .amount = asset(open)}));
342 env(vault.deposit({.depositor = owner, .id = keylet.key, .amount = asset(1)}),
345 auto const sle = env.le(
keylet);
346 if (!BEAST_EXPECT(sle))
348 BEAST_EXPECT(sle->at(sfAssetsTotal) ==
Number{open});
357 auto const [issuer, owner, depositor, asset] =
358 setupIou(env, {.clawback =
true, .depositorTrust = 2});
362 testcase(
"VaultDeposit rejects sub-base-unit dust");
363 env(vault.deposit({.depositor = depositor, .id = keylet.key, .amount = asset(dust)}),
366 env(vault.deposit({.depositor = depositor, .id = keylet.key, .amount = asset(1)}));
369 testcase(
"VaultWithdraw rejects sub-base-unit dust");
370 env(vault.withdraw({.depositor = depositor, .id = keylet.key, .amount = asset(dust)}),
373 testcase(
"VaultClawback rejects sub-base-unit dust");
378 .amount = asset(dust).value(),
403 for (
auto const& step : steps)
409 {.depositor = holder, .id = keylet.key, .amount = asset(step.amount)}));
413 {.depositor = holder, .id = keylet.key, .amount = asset(step.amount)}));
420 .amount = asset(step.amount).value(),
435 testcase(
"FixedPrecision IOU vault keeps AssetsTotal in sync across deposits/withdrawals");
438 auto const [issuer, owner, depositor, asset] =
439 setupIou(env, {.ownerOnly =
true, .ownerTrust = 10'000});
441 Vault const vault{env};
442 auto [create,
keylet] = vault.create({.owner = owner, .asset = asset});
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},
470 "FixedPrecision IOU vault keeps AssetsTotal in sync across clawback and final "
474 auto const [issuer, owner, depositor, asset] =
setupIou(env, {.clawback =
true});
476 Vault const vault{env};
477 auto [create,
keylet] = vault.create({.owner = owner, .asset = asset});
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},
502 testcase(
"FixedPrecision MPT vault keeps AssetsTotal in sync across deposits/withdrawals");
507 auto const [issuer, owner, depositor, asset] =
508 setupMpt(env, {.maxAmt = total, .holderFunds = total});
510 Vault const vault{env};
511 auto [create,
keylet] = vault.create({.owner = owner, .asset = asset});
523 {.op = Op::Deposit, .amount = total, .expectedAvailable = total},
524 {.op = Op::Withdraw, .amount = 400, .expectedAvailable = 600},
525 {.op = Op::Withdraw, .amount = 600, .expectedAvailable = 0},
535 "CashBasis vault: AssetsTotal tracks AssetsAvailable directly, AssetsDeployed absent");
537 Env env(*
this,
features() - featureLendingProtocolV1_2);
538 auto const [issuer, owner, depositor, asset] =
setupIou(env, {.ownerOnly =
true});
540 Vault const vault{env};
541 auto [create,
keylet] = vault.create({.owner = owner, .asset = asset});
546 auto const expectCashBasis = [&](
Number const& expected) {
547 auto const sle = env.le(
keylet);
548 if (!BEAST_EXPECT(sle))
550 BEAST_EXPECT(!sle->isFieldPresent(sfAssetsDeployed));
551 BEAST_EXPECT(sle->at(sfAssetsTotal) == sle->at(sfAssetsAvailable));
552 BEAST_EXPECT(sle->at(sfAssetsTotal) == expected);
558 env(vault.deposit({.depositor = owner, .id = keylet.key, .amount = asset(1'000)}));
560 expectCashBasis(
Number{1'000});
562 env(vault.withdraw({.depositor = owner, .id = keylet.key, .amount = asset(400)}));
564 expectCashBasis(
Number{600});
567 env(vault.withdraw({.depositor = owner, .id = keylet.key, .amount = asset(600)}));
569 expectCashBasis(
Number{0});
581 testcase(
"FixedPrecision VaultCreate: AssetsMaximum must be exactly representable");
583 Account const issuer{
"issuer"};
588 env.fund(XRP(1'000'000), issuer, owner);
591 Vault const vault{env};
593 auto const tryCreate =
595 auto [tx,
keylet] = vault.create({.owner = owner, .asset = asset});
597 tx[sfScale] = *
scale;
598 tx[sfAssetsMaximum] = cap;
599 env(tx, Ter(expected));
603 auto const sle = env.le(
keylet);
604 if (BEAST_EXPECT(sle))
605 BEAST_EXPECT(
Number(sle->at(sfAssetsMaximum)) == cap);
609 BEAST_EXPECT(!env.le(
keylet));
635 Env legacyEnv(*
this,
features() - featureLendingProtocolV1_1);
636 legacyEnv.fund(XRP(1'000'000), issuer, owner);
639 Vault const legacyVault{legacyEnv};
640 auto [tx,
keylet] = legacyVault.create({.owner = owner, .asset = asset});
641 tx[sfAssetsMaximum] =
Number{10000001, -7};
644 if (
auto const sle = legacyEnv.le(
keylet); BEAST_EXPECT(sle))
656 testcase(
"FixedPrecision VaultSet: AssetsMaximum must be exactly representable");
658 Account const issuer{
"issuer"};
663 env.fund(XRP(1'000'000), issuer, owner);
666 Vault const vault{env};
667 auto [create,
keylet] = vault.create({.owner = owner, .asset = asset});
672 auto const sle = env.le(
keylet);
673 if (!BEAST_EXPECT(sle))
675 if (!sle->isFieldPresent(sfAssetsMaximum))
677 return Number(sle->at(sfAssetsMaximum));
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));
688 BEAST_EXPECT(currentMax() == cap);
692 BEAST_EXPECT(currentMax() == before);
713 testcase(
"FixedPrecision VaultCreate: AssetsMaximum on integral assets (MPT, XRP)");
718 auto const [issuer, owner, depositor, asset] =
719 setupMpt(env, {.maxAmt = 1'000'000, .holderFunds = 1'000'000});
721 Vault const vault{env};
723 auto [tx,
keylet] = vault.create({.owner = owner, .asset = asset});
724 tx[sfAssetsMaximum] =
Number{5, -1};
727 BEAST_EXPECT(!env.le(
keylet));
730 auto [tx,
keylet] = vault.create({.owner = owner, .asset = asset});
731 tx[sfAssetsMaximum] =
Number{1'000};
734 auto const sle = env.le(
keylet);
735 if (BEAST_EXPECT(sle))
736 BEAST_EXPECT(
Number(sle->at(sfAssetsMaximum)) ==
Number{1'000});
744 env.fund(XRP(1'000'000), owner);
748 Vault const vault{env};
750 auto [tx,
keylet] = vault.create({.owner = owner, .asset = asset});
751 tx[sfAssetsMaximum] =
Number{5, -1};
754 BEAST_EXPECT(!env.le(
keylet));
757 auto [tx,
keylet] = vault.create({.owner = owner, .asset = asset});
758 tx[sfAssetsMaximum] =
Number{1'000};
761 auto const sle = env.le(
keylet);
762 if (BEAST_EXPECT(sle))
763 BEAST_EXPECT(
Number(sle->at(sfAssetsMaximum)) ==
Number{1'000});
777 "Pre-FixedPrecision (CashBasis) VaultCreate/Set: AssetsMaximum grid check does not "
780 Account const issuer{
"issuer"};
784 Env env(*
this,
features() - featureLendingProtocolV1_2);
785 env.fund(XRP(1'000'000), issuer, owner);
788 Vault const vault{env};
790 Number const offGrid{10000001, -7};
792 auto [create,
keylet] = vault.create({.owner = owner, .asset = asset});
794 create[sfAssetsMaximum] = offGrid;
798 auto const sle = env.le(
keylet);
799 if (BEAST_EXPECT(sle))
800 BEAST_EXPECT(
Number(sle->at(sfAssetsMaximum)) == offGrid);
803 Number const offGrid2{10000003, -7};
804 auto tx = vault.set({.owner = owner, .id =
keylet.key});
805 tx[sfAssetsMaximum] = offGrid2;
808 auto const sle2 = env.le(
keylet);
809 if (BEAST_EXPECT(sle2))
810 BEAST_EXPECT(
Number(sle2->at(sfAssetsMaximum)) == offGrid2);
823 testcase(
"Existing CashBasis vault after V1.2: VaultSet rejects an unrepresentable cap");
825 Account const issuer{
"issuer"};
829 Env env(*
this,
features() - featureLendingProtocolV1_2);
830 env.fund(XRP(1'000'000), issuer, owner);
833 Vault const vault{env};
834 auto [create,
keylet] = vault.create({.owner = owner, .asset = asset});
838 env.enableFeature(featureLendingProtocolV1_2);
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;
848 auto ok = vault.set({.owner = owner, .id =
keylet.key});
849 ok[sfAssetsMaximum] =
Number{1'000};
852 auto const sle = env.le(
keylet);
853 if (BEAST_EXPECT(sle))
854 BEAST_EXPECT(
Number(sle->at(sfAssetsMaximum)) ==
Number{1'000});
866 testcase(
"Existing vault with an off-grid cap: VaultSet replaces it after V1.2");
868 Account const issuer{
"issuer"};
872 Env env(*
this,
features() - featureLendingProtocolV1_2);
873 env.fund(XRP(1'000'000), issuer, owner);
875 env.trust(asset(1'000), owner);
877 env(pay(issuer, owner, asset(1'000)));
880 Vault const vault{env};
882 Number const offGrid{100'000'001, -7};
884 auto [create,
keylet] = vault.create({.owner = owner, .asset = asset});
886 create[sfAssetsMaximum] = offGrid;
890 env(vault.deposit({.depositor = owner, .id = keylet.key, .amount = asset(1)}));
893 env.enableFeature(featureLendingProtocolV1_2);
896 auto const before = env.le(
keylet);
897 if (!BEAST_EXPECT(before))
899 BEAST_EXPECT(
Number(before->at(sfAssetsMaximum)) == offGrid);
904 auto data = vault.set({.owner = owner, .id =
keylet.key});
909 auto onGrid = vault.set({.owner = owner, .id =
keylet.key});
910 onGrid[sfAssetsMaximum] =
Number{5};
915 if (!BEAST_EXPECT(
after))
919 env(vault.deposit({.depositor = owner, .id = keylet.key, .amount = asset(4)}));
921 env(vault.deposit({.depositor = owner, .id = keylet.key, .amount = asset(1)}),
953 "A deposit shaped like the associateAsset witness is refused by the "
954 "Open-zone guard on FixedPrecision, not silently rounded");
956 Account const issuer{
"issuer"};
958 Account const depositor{
"depositor"};
962 env.fund(XRP(1'000'000), issuer, owner, depositor);
964 env(fset(issuer, asfDefaultRipple));
966 env(trust(depositor, asset(20'000'000)));
968 env(pay(issuer, depositor, asset(15'000'000)));
971 Vault const vault{env};
972 auto [create,
keylet] = vault.create({.owner = owner, .asset = asset});
980 Number const firstDeposit{1'234'567'890'123'456LL, -10};
982 {.depositor = depositor, .id = keylet.key, .amount = asset(firstDeposit)}));
989 env(vault.deposit({.depositor = depositor, .id = keylet.key, .amount = asset(10'000'000)}),
TestcaseT testcase
Memberspace for declaring test cases.
Number is a floating point type that can represent a wide range of values.
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 FeatureBitset features()
static AssetAccounts setupIou(test::jtx::Env &env, IouParams const ¶ms)
SLE::const_pointer expectVault(test::jtx::Env const &env, Keylet const &vaultKeylet, VaultExpect const &expected)
static AssetAccounts setupMpt(test::jtx::Env &env, MptParams const ¶ms)
void checkFixedPrecisionSync(test::jtx::Env const &env, Keylet const &vaultKeylet, Number const &expectedAvailable)
void testAssetsMaximumIntegralAssets()
void testAssetsTotalStaysInSyncIou()
void testExistingCashBasisVault()
void testAssetsTotalStaysInSyncClawback()
void testAssetsMaximumRejectedOnExistingVaultAfterV12()
void testAssetsMaximumOffGridAcceptedPreV12()
void testAssetsMaximumNotRepresentableOnCreate()
void testAssetsMaximumNotRepresentableOnSet()
void testAssetsTotalStaysInSyncIntegralAsset()
void run() override
Runs the suite.
void testDepositAdmission()
void testCashBasisAssetsTotalControl()
void testIntegralAssetCapacity()
void testOffGridAssetsMaximumReplacedAfterV12()
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)
void testPartialTowardZeroRounding()
void testDepositCoarseningRefusedInsteadOfAssociateAssetRounding()
test::jtx::PrettyAsset PrettyAsset
Immutable cryptographic account descriptor.
A transaction testing environment.
bool close(NetClock::time_point closeTime, std::optional< std::chrono::milliseconds > consensusDelay=std::nullopt)
Close and advance the ledger.
Keylet computation functions.
Use hash_* containers for keys that do not need a cryptographically secure hashing algorithm.
Issue const & xrpIssue()
Returns an asset specifier that represents XRP.
int scale(Number const &number, Asset const &asset)
Get the scale of a Number for a given asset.
void open(soci::session &s, BasicConfig const &config, std::string const &dbName)
Open a soci session.
constexpr std::uint8_t kVaultDefaultIouScale
Default IOU scale factor for a Vault.
VaultVersion
Vault ledger-entry schema versions, persisted as sfLEVersion.
constexpr std::uint8_t kFixedPrecisionVaultMaximumIouScale
Maximum Scale for a Vault created under featureLendingProtocolV1_2.
bool after(NetClock::time_point now, std::uint32_t mark)
Has the specified time passed?
constexpr std::uint8_t kLegacyVaultMaximumIouScale
Maximum Scale for a Vault created before featureLendingProtocolV1_2.
TERSubset< CanCvtToTER > TER
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)
A pair of SHAMap key and LedgerEntryType.
std::int64_t expectedAvailable
Asset const & raw() const