xrpld
Loading...
Searching...
No Matches
VaultFixedPrecisionBase.h
1#pragma once
2
3#include <test/app/vault/VaultTestBase.h>
4#include <test/jtx/Account.h>
5#include <test/jtx/Env.h>
6#include <test/jtx/amount.h>
7#include <test/jtx/flags.h>
8#include <test/jtx/mpt.h>
9#include <test/jtx/pay.h>
10#include <test/jtx/trust.h>
11#include <test/jtx/vault.h>
12
13#include <xrpl/basics/Number.h>
14#include <xrpl/beast/unit_test/suite.h>
15#include <xrpl/ledger/helpers/VaultHelpers.h>
16#include <xrpl/protocol/Asset.h>
17#include <xrpl/protocol/Feature.h>
18#include <xrpl/protocol/Keylet.h>
19#include <xrpl/protocol/SField.h>
20#include <xrpl/protocol/STAmount.h>
21#include <xrpl/protocol/STLedgerEntry.h>
22#include <xrpl/protocol/STNumber.h> // IWYU pragma: keep
23#include <xrpl/protocol/TxFlags.h>
24
25#include <cstdint>
26#include <optional>
27#include <string>
28#include <utility>
29
30namespace xrpl {
31
32// Shared scaffolding for the vault-only FixedPrecision tests: amendment set,
33// IOU/MPT account setup, and vault assertions. Lending-specific scaffolding
34// (LoanBroker/Loan fixtures and helpers) lives in
35// src/test/app/lending/LoanFixedPrecisionBase.h, which derives from this
36// class instead of duplicating it.
38{
39protected:
40 static FeatureBitset
42 {
43 return test::jtx::testableAmendments() | featureLendingProtocolV1_1 |
44 featureLendingProtocolV1_2;
45 }
46
47 // Creates an open-ended vault at the given fixed Scale and closes the ledger.
50 test::jtx::Env& env,
51 test::jtx::Account const& owner,
52 Asset const& asset,
54 {
55 test::jtx::Vault const vault{env};
56 auto [create, keylet] = vault.create({.owner = owner, .asset = asset});
57 create[sfScale] = scale;
58 env(create);
59 env.close();
60 return {vault, keylet};
61 }
62
63 struct IouParams
64 {
65 bool clawback = false;
66 // Fund only the issuer and owner; the owner plays the depositor.
67 bool ownerOnly = false;
70 // Defaults to depositorTrust (ownerTrust when ownerOnly).
72 // Extra USD paid to the owner alongside the depositor's.
74 };
75
83
84 // Funds an issuer, owner and depositor, opens the owner and depositor USD
85 // trust lines, and pays the depositor. The caller constructs env to choose
86 // the amendments.
87 static AssetAccounts
88 setupIou(test::jtx::Env& env, IouParams const& params)
89 {
90 using namespace test::jtx;
91
93 if (params.ownerOnly)
94 {
95 env.fund(XRP(1'000'000), a.issuer, a.owner);
96 if (params.clawback)
97 env(fset(a.issuer, asfAllowTrustLineClawback));
98 env.close();
99 env(trust(a.owner, a.asset(params.ownerTrust)));
100 env.close();
101 env(pay(a.issuer, a.owner, a.asset(params.depositorFunds.value_or(params.ownerTrust))));
102 env.close();
103 return a;
104 }
105 env.fund(XRP(1'000'000), a.issuer, a.owner, a.depositor);
106 if (params.clawback)
107 env(fset(a.issuer, asfAllowTrustLineClawback));
108 env.close();
109 env(trust(a.depositor, a.asset(params.depositorTrust)));
110 env(trust(a.owner, a.asset(params.ownerTrust)));
111 env.close();
112 env(pay(
113 a.issuer, a.depositor, a.asset(params.depositorFunds.value_or(params.depositorTrust))));
114 if (params.ownerFunds)
115 env(pay(a.issuer, a.owner, a.asset(*params.ownerFunds)));
116 env.close();
117 return a;
118 }
119
120 static AssetAccounts
122 {
123 return setupIou(env, IouParams{});
124 }
125
127 {
129 // Also fund and authorize the depositor, who then holds the balance
130 // (otherwise the owner does).
131 bool withDepositor = false;
133 };
134
135 // MPT counterpart of setupIou; asset is the created issuance.
136 static AssetAccounts
137 setupMpt(test::jtx::Env& env, MptParams const& params)
138 {
139 using namespace test::jtx;
140
142 if (params.withDepositor)
143 {
144 env.fund(XRP(1'000'000), a.issuer, a.owner, a.depositor);
145 }
146 else
147 {
148 env.fund(XRP(1'000'000), a.issuer, a.owner);
149 }
150 env.close();
151
152 MPTTester mpt{env, a.issuer, kMptInitNoFund};
153 mpt.create({.maxAmt = params.maxAmt, .flags = tfMPTCanTransfer});
154 a.asset = mpt.issuanceID();
155 mpt.authorize({.account = a.owner});
156 if (params.withDepositor)
157 mpt.authorize({.account = a.depositor});
158 env(pay(
159 a.issuer, params.withDepositor ? a.depositor : a.owner, a.asset(params.holderFunds)));
160 env.close();
161 return a;
162 }
163
164 // A vault's AssetsAvailable, AssetsDeployed, stored AssetsTotal and the
165 // pseudo-account's balance of the asset at one point in time.
173
174 VaultSnapshot
175 snapshotVault(test::jtx::Env& env, Keylet const& vaultKeylet, PrettyAsset const& asset)
176 {
177 auto const sle = env.le(vaultKeylet);
178 if (!BEAST_EXPECT(sle))
179 return {};
180 test::jtx::Account const vaultAccount("vault", sle->at(sfAccount));
181 env.memoize(vaultAccount);
182 return {
183 .available = sle->at(sfAssetsAvailable),
184 .assetsDeployed = sle->at(sfAssetsDeployed),
185 .total = sle->at(sfAssetsTotal),
186 .vaultBalance = env.balance(vaultAccount, asset).value(),
187 };
188 }
189
190 static Number
192 {
193 Number p{1};
194 while (p * 10 <= x)
195 p = p * 10;
196 return p;
197 }
198
199 static Number
201 {
202 Number p{1};
203 while (p <= x)
204 p = p * 10;
205 return p;
206 }
207
208 void
209 expectCoarsened(test::jtx::Env const& env, Keylet const& vaultKeylet)
210 {
211 auto const sle = env.le(vaultKeylet);
212 if (!BEAST_EXPECT(sle))
213 return;
214 BEAST_EXPECT(getVaultScale(sle) > getVaultBaseScale(sle));
215 }
216
217 // Asserts AssetsAvailable is at most the stored AssetsTotal and exactly
218 // representable at 16 digits; returns it.
219 Number
221 test::jtx::Env const& env,
222 Keylet const& vaultKeylet,
223 PrettyAsset const& asset)
224 {
225 auto const sle = env.le(vaultKeylet);
226 if (!BEAST_EXPECT(sle))
227 return Number{0};
228 Number const available = sle->at(sfAssetsAvailable);
229 BEAST_EXPECT(available <= sle->at(sfAssetsTotal));
230 STAmount const availableAmount{asset, available};
231 BEAST_EXPECT(Number(availableAmount) == available);
232 return available;
233 }
234
236 {
239 // The stored (cached) AssetsTotal.
241 };
242
243 // Asserts the fields set in expected, plus stored AssetsTotal == derived
244 // getAssetsTotal. Returns the vault SLE (null if missing).
246 expectVault(test::jtx::Env const& env, Keylet const& vaultKeylet, VaultExpect const& expected)
247 {
248 auto const sle = env.le(vaultKeylet);
249 if (!BEAST_EXPECT(sle))
250 return sle;
251 if (expected.available)
252 BEAST_EXPECT(sle->at(sfAssetsAvailable) == *expected.available);
253 if (expected.assetsDeployed)
254 BEAST_EXPECT(sle->at(sfAssetsDeployed) == *expected.assetsDeployed);
255 if (expected.total)
256 BEAST_EXPECT(sle->at(sfAssetsTotal) == *expected.total);
257 BEAST_EXPECT(sle->at(sfAssetsTotal) == getAssetsTotal(sle));
258 return sle;
259 }
260
261 // Asserts AssetsDeployed is zero and the stored AssetsTotal, derived
262 // getAssetsTotal and AssetsAvailable all equal expectedAvailable.
263 void
265 test::jtx::Env const& env,
266 Keylet const& vaultKeylet,
267 Number const& expectedAvailable)
268 {
270 env,
271 vaultKeylet,
272 {
273 .available = expectedAvailable,
274 .assetsDeployed = Number{0},
275 .total = expectedAvailable,
276 });
277 }
278};
279
280} // namespace xrpl
Number is a floating point type that can represent a wide range of values.
Definition Number.h:351
std::shared_ptr< STLedgerEntry const > const_pointer
static Number smallestPowerOfTenAbove(Number const &x)
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)
static AssetAccounts setupIou(test::jtx::Env &env, IouParams const &params)
VaultSnapshot snapshotVault(test::jtx::Env &env, Keylet const &vaultKeylet, PrettyAsset const &asset)
SLE::const_pointer expectVault(test::jtx::Env const &env, Keylet const &vaultKeylet, VaultExpect const &expected)
void expectCoarsened(test::jtx::Env const &env, Keylet const &vaultKeylet)
static AssetAccounts setupMpt(test::jtx::Env &env, MptParams const &params)
void checkFixedPrecisionSync(test::jtx::Env const &env, Keylet const &vaultKeylet, Number const &expectedAvailable)
static Number largestPowerOfTenAtMost(Number const &x)
Number expectAvailableAtSixteenDigits(test::jtx::Env const &env, Keylet const &vaultKeylet, PrettyAsset const &asset)
Shared base for the Vault*_test family under src/test/app/vault/.
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
SLE::const_pointer le(Account const &account) const
Return an account root.
Definition Env.cpp:311
void fund(bool setDefaultRipple, STAmount const &amount, Account const &account)
Definition Env.cpp:323
PrettyAmount balance(Account const &account) const
Returns the XRP balance on an account.
Definition Env.cpp:201
void memoize(Account const &account)
Associate AccountID with account.
Definition Env.cpp:174
Keylet computation functions.
Definition Indexes.h:39
FeatureBitset testableAmendments()
Definition Env.h:92
Use hash_* containers for keys that do not need a cryptographically secure hashing algorithm.
Definition algorithm.h:5
int scale(Number const &number, Asset const &asset)
Get the scale of a Number for a given asset.
Definition STAmount.h:819
int getVaultScale(SLE::ConstRef vault)
Return the Vault's current live exponent.
int getVaultBaseScale(SLE::ConstRef vault)
Return the Vault's base exponent.
Number getAssetsTotal(SLE::ConstRef vault)
Return the Vault's current assets total.
A pair of SHAMap key and LedgerEntryType.
Definition Keylet.h:20
STAmount const & value() const