xrpld
Loading...
Searching...
No Matches
VaultShares_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/TestHelpers.h>
5#include <test/jtx/amount.h>
6#include <test/jtx/escrow.h>
7#include <test/jtx/fee.h>
8#include <test/jtx/flags.h>
9#include <test/jtx/mpt.h>
10#include <test/jtx/noop.h>
11#include <test/jtx/pay.h>
12#include <test/jtx/seq.h>
13#include <test/jtx/sig.h>
14#include <test/jtx/tags.h>
15#include <test/jtx/ter.h>
16#include <test/jtx/trust.h>
17#include <test/jtx/vault.h>
18
19#include <xrpl/basics/Number.h>
20#include <xrpl/basics/base_uint.h>
21#include <xrpl/basics/strHex.h>
22#include <xrpl/beast/unit_test/suite.h>
23#include <xrpl/beast/utility/Journal.h>
24#include <xrpl/core/ServiceRegistry.h>
25#include <xrpl/json/json_forwards.h>
26#include <xrpl/json/json_value.h>
27#include <xrpl/ledger/ApplyView.h>
28#include <xrpl/ledger/OpenView.h>
29#include <xrpl/ledger/Sandbox.h>
30#include <xrpl/ledger/helpers/AccountRootHelpers.h>
31#include <xrpl/ledger/helpers/MPTokenHelpers.h>
32#include <xrpl/ledger/helpers/VaultHelpers.h>
33#include <xrpl/protocol/AccountID.h>
34#include <xrpl/protocol/Asset.h>
35#include <xrpl/protocol/Feature.h>
36#include <xrpl/protocol/Indexes.h>
37#include <xrpl/protocol/Issue.h>
38#include <xrpl/protocol/Keylet.h>
39#include <xrpl/protocol/MPTIssue.h>
40#include <xrpl/protocol/Protocol.h>
41#include <xrpl/protocol/SField.h>
42#include <xrpl/protocol/STAmount.h>
43#include <xrpl/protocol/SeqProxy.h>
44#include <xrpl/protocol/TER.h>
45#include <xrpl/protocol/TxFlags.h>
46#include <xrpl/protocol/XRPAmount.h>
47#include <xrpl/protocol/jss.h>
48
49#include <optional>
50#include <string>
51#include <tuple>
52#include <utility>
53
54namespace xrpl {
55
57{
58private:
59 void
61 {
62 using namespace test::jtx;
63
64 Env env{*this, testableAmendments()};
65 Account const issuer{"issuer"};
66 Account const owner{"owner"};
67 Account const depositor{"depositor"};
68 env.fund(XRP(1000), issuer, owner, depositor);
69 env.close();
70
71 Vault const vault{env};
72 PrettyAsset const asset = issuer["IOU"];
73 env.trust(asset(1000), owner);
74 env(pay(issuer, owner, asset(100)));
75 env.trust(asset(1000), depositor);
76 env(pay(issuer, depositor, asset(100)));
77 env.close();
78
79 auto [tx, keylet] = vault.create({.owner = owner, .asset = asset});
80 tx[sfFlags] = tfVaultShareNonTransferable;
81 env(tx);
82 env.close();
83
84 {
85 testcase("nontransferable deposits");
86 auto const tx1 =
87 vault.deposit({.depositor = depositor, .id = keylet.key, .amount = asset(40)});
88 env(tx1);
89
90 auto const tx2 =
91 vault.deposit({.depositor = owner, .id = keylet.key, .amount = asset(60)});
92 env(tx2);
93 env.close();
94 }
95
96 auto const vaultAccount = //
97 [&env, key = keylet.key, this] -> AccountID {
98 auto jvVault = env.rpc("vault_info", strHex(key));
99
100 BEAST_EXPECT(jvVault[jss::result][jss::vault][sfAssetsTotal] == "100");
101 BEAST_EXPECT(
102 jvVault[jss::result][jss::vault][jss::shares][sfOutstandingAmount] == "100000000");
103
104 // Vault pseudo-account
105 return parseBase58<AccountID>(jvVault[jss::result][jss::vault][jss::Account].asString())
106 .value();
107 }();
108
109 auto const mptId = makeMptID(1, vaultAccount);
110 Asset const shares = mptId;
111
112 {
113 testcase("nontransferable shares cannot be moved");
114 env(pay(owner, depositor, shares(10)), Ter{tecNO_AUTH});
115 env(pay(depositor, owner, shares(10)), Ter{tecNO_AUTH});
116 }
117
118 {
119 testcase("nontransferable shares can be used to withdraw");
120 auto const tx1 =
121 vault.withdraw({.depositor = depositor, .id = keylet.key, .amount = asset(20)});
122 env(tx1);
123
124 auto const tx2 =
125 vault.withdraw({.depositor = owner, .id = keylet.key, .amount = asset(30)});
126 env(tx2);
127 env.close();
128 }
129
130 {
131 testcase("nontransferable shares balance check");
132 auto jvVault = env.rpc("vault_info", strHex(keylet.key));
133 BEAST_EXPECT(jvVault[jss::result][jss::vault][sfAssetsTotal] == "50");
134 BEAST_EXPECT(
135 jvVault[jss::result][jss::vault][jss::shares][sfOutstandingAmount] == "50000000");
136 }
137
138 {
139 testcase("nontransferable shares withdraw rest");
140 auto const tx1 =
141 vault.withdraw({.depositor = depositor, .id = keylet.key, .amount = asset(20)});
142 env(tx1);
143
144 auto const tx2 =
145 vault.withdraw({.depositor = owner, .id = keylet.key, .amount = asset(30)});
146 env(tx2);
147 env.close();
148 }
149
150 {
151 testcase("nontransferable shares delete empty vault");
152 auto const tx = vault.del({.owner = owner, .id = keylet.key});
153 env(tx);
154 BEAST_EXPECT(!env.le(keylet));
155 }
156 }
157
158 void
160 {
161 using namespace test::jtx;
162
163 testcase("fail pseudo-account allocation");
164 Env env{*this, testableAmendments()};
165 Account const owner{"owner"};
166 Vault const vault{env};
167 env.fund(XRP(1000), owner);
168
169 auto const keylet = keylet::vault(owner.id(), SeqProxy::rawSequence(env.seq(owner)));
170 for (int i = 0; i < 256; ++i)
171 {
172 AccountID const accountId = xrpl::pseudoAccountAddress(*env.current(), keylet.key);
173
174 env(pay(env.master.id(), accountId, XRP(1000)),
175 Seq(kAutofill),
176 Fee(kAutofill),
177 Sig(kAutofill));
178 }
179
180 auto [tx, keylet1] = vault.create({.owner = owner, .asset = xrpIssue()});
181 BEAST_EXPECT(keylet.key == keylet1.key);
182 env(tx, Ter{terADDRESS_COLLISION});
183 }
184
185 void
187 {
188 testcase("removeEmptyHolding deletes MPToken with sfLockedAmount");
189 using namespace test::jtx;
190 using namespace std::literals;
191
192 auto const amendments = testableAmendments();
193 auto const runTest = [&](FeatureBitset f) {
194 Env env{*this, f};
195 auto const baseFee = env.current()->fees().base;
196
197 Account const issuer{"issuer"};
198 Account const owner{"owner"};
199 Account const depositor{"depositor"};
200 Account const bob{"bob"};
201
202 env.fund(XRP(100000), issuer, owner, depositor, bob);
203 env.close();
204
205 Vault const vault{env};
206
207 // Create an MPT asset for the vault
208 MPTTester mptt{env, issuer, kMptInitNoFund};
209 mptt.create({.flags = tfMPTCanTransfer | tfMPTCanLock});
210 PrettyAsset const asset = mptt.issuanceID();
211 mptt.authorize({.account = owner});
212 mptt.authorize({.account = depositor});
213 env(pay(issuer, depositor, asset(1000)));
214 env.close();
215
216 // Create vault
217 auto [tx, keylet] = vault.create({.owner = owner, .asset = asset});
218 env(tx);
219 env.close();
220
221 auto const vaultSle = env.le(keylet);
222 BEAST_EXPECT(vaultSle != nullptr);
223 auto const shareMptID = vaultSle->at(sfShareMPTID);
224 MPTIssue const shareIssue{shareMptID};
225
226 // Depositor deposits 1000 asset units into vault, receiving shares
227 env(vault.deposit({.depositor = depositor, .id = keylet.key, .amount = asset(1000)}));
228 env.close();
229
230 // Check depositor has shares
231 {
232 auto const sleMpt = env.le(keylet::mptoken(shareMptID, depositor));
233 BEAST_EXPECT(sleMpt != nullptr);
234 BEAST_EXPECT(sleMpt->at(sfMPTAmount) == 1000);
235 }
236
237 // Escrow 500 of those shares
238 env(escrow::create(depositor, bob, STAmount{shareIssue, 500}),
239 escrow::kCondition(escrow::kCb1),
240 escrow::kFinishTime(env.now() + 1s),
241 Fee(baseFee * 150),
242 Ter(tesSUCCESS));
243 env.close();
244
245 // Verify: sfMPTAmount=500, sfLockedAmount=500
246 {
247 auto const sleMpt = env.le(keylet::mptoken(shareMptID, depositor));
248 BEAST_EXPECT(sleMpt != nullptr);
249 BEAST_EXPECT(sleMpt->at(sfLockedAmount) == 500);
250 BEAST_EXPECT(sleMpt->at(sfMPTAmount) == 500);
251 }
252
253 // Withdraw remaining spendable shares — triggers removeEmptyHolding
254 env(vault.withdraw({.depositor = depositor, .id = keylet.key, .amount = asset(500)}),
255 Ter(tesSUCCESS));
256 env.close();
257
258 auto const sleMptAfter = env.le(keylet::mptoken(shareMptID, depositor));
259 if (!f[fixCleanup3_1_3])
260 {
261 // Without the fix, removeEmptyHolding deletes the MPToken
262 // even though sfLockedAmount > 0, leaving the escrow's locked
263 // amount untracked.
264 BEAST_EXPECT(sleMptAfter == nullptr);
265 }
266 else
267 {
268 // With the fix, MPToken must still exist with sfLockedAmount > 0
269 // and sfMPTAmount == 0 (all spendable shares withdrawn).
270 BEAST_EXPECT(sleMptAfter != nullptr);
271 if (sleMptAfter)
272 {
273 BEAST_EXPECT(sleMptAfter->at(sfLockedAmount) == 500);
274 BEAST_EXPECT(sleMptAfter->at(sfMPTAmount) == 0);
275 }
276 }
277 };
278
279 runTest(amendments - fixCleanup3_1_3);
280 runTest(amendments);
281 }
282
283 void
285 {
286 testcase("removeEmptyHolding keeps MPToken with confidential balances");
287 using namespace test::jtx;
288
289 Env env{*this, testableAmendments()};
290
291 Account const issuer{"issuer"};
292 Account const holder{"holder"};
293 MPTTester mpt{env, issuer, {.holders = {holder}}};
294 mpt.create({.authorize = MPTCreate::allHolders});
295
296 auto const tokenKeylet = keylet::mptoken(mpt.issuanceID(), holder.id());
297 auto const encryptedBalanceFields = {
298 &sfConfidentialBalanceInbox,
299 &sfConfidentialBalanceSpending,
300 &sfIssuerEncryptedBalance,
301 &sfAuditorEncryptedBalance,
302 };
303
304 env.app().getOpenLedger().modify([&](OpenView& view, beast::Journal j) {
305 for (auto const field : encryptedBalanceFields)
306 {
307 Sandbox sb(&view, TapNone);
308 auto const token = sb.peek(tokenKeylet);
309 if (!BEAST_EXPECT(token))
310 return false;
311
312 token->setFieldVL(*field, gMakeZeroBuffer(kEcGamalEncryptedTotalLength));
313 sb.update(token);
314
315 auto const dummyTx = *env.jt(noop(holder)).stx;
316 BEAST_EXPECT(
317 removeEmptyHolding({sb, dummyTx}, holder.id(), MPTIssue(mpt.issuanceID()), j) ==
319 BEAST_EXPECT(sb.peek(tokenKeylet) != nullptr);
320 }
321 return true;
322 });
323 }
324
325 void
327 {
328 using namespace test::jtx;
329
330 auto const readReferenceHolding = [&](Env const& env,
331 Keylet const& vaultKeylet) -> std::optional<UInt256> {
332 auto const sleVault = env.le(vaultKeylet);
333 if (!sleVault)
334 return std::nullopt;
335 auto const sleIssuance = env.le(keylet::mptokenIssuance(sleVault->at(sfShareMPTID)));
336 if (!sleIssuance || !sleIssuance->isFieldPresent(sfReferenceHolding))
337 return std::nullopt;
338 return sleIssuance->getFieldH256(sfReferenceHolding);
339 };
340
341 // Post-fixCleanup3_2_0: vault share carries sfReferenceHolding
342 // pointing to the vault pseudo's MPToken (for MPT-backed vaults)
343 // or RippleState (for IOU-backed vaults).
344 {
345 testcase("sfReferenceHolding: MPT-backed vault, post-amendment");
346 Env env{*this, testableAmendments()};
347 Account const issuer{"issuer"};
348 Account const owner{"owner"};
349 env.fund(XRP(10'000), issuer, owner);
350 env.close();
351
352 MPTTester mptt{env, issuer, kMptInitNoFund};
353 mptt.create({.flags = tfMPTCanTransfer | tfMPTCanLock});
354 PrettyAsset const asset = mptt.issuanceID();
355 mptt.authorize({.account = owner});
356
357 Vault const vault{env};
358 auto [tx, keylet] = vault.create({.owner = owner, .asset = asset});
359 env(tx);
360 env.close();
361
362 auto const sleVault = env.le(keylet);
363 BEAST_EXPECT(sleVault != nullptr);
364 auto const pseudoId = sleVault->at(sfAccount);
365 auto const expected = keylet::mptoken(mptt.issuanceID(), pseudoId).key;
366
367 auto const stored = readReferenceHolding(env, keylet);
368 BEAST_EXPECT(stored.has_value());
369 BEAST_EXPECT(stored && *stored == expected);
370 // The pointed-to MPToken must actually exist.
371 BEAST_EXPECT(env.le(keylet::mptoken(mptt.issuanceID(), pseudoId)) != nullptr);
372 }
373
374 {
375 testcase("sfReferenceHolding: IOU-backed vault, post-amendment");
376 Env env{*this, testableAmendments()};
377 Account const issuer{"issuer"};
378 Account const owner{"owner"};
379 env.fund(XRP(10'000), issuer, owner);
380 env(fset(issuer, asfDefaultRipple));
381 env.close();
382
383 PrettyAsset const asset = issuer["IOU"];
384 env.trust(asset(1'000'000), owner);
385 env.close();
386
387 Vault const vault{env};
388 auto [tx, keylet] = vault.create({.owner = owner, .asset = asset});
389 env(tx);
390 env.close();
391
392 auto const sleVault = env.le(keylet);
393 BEAST_EXPECT(sleVault != nullptr);
394 auto const pseudoId = sleVault->at(sfAccount);
395 auto const expected = keylet::trustLine(pseudoId, asset.raw().get<Issue>()).key;
396
397 auto const stored = readReferenceHolding(env, keylet);
398 BEAST_EXPECT(stored.has_value());
399 BEAST_EXPECT(stored && *stored == expected);
400 // The pointed-to RippleState must actually exist.
401 BEAST_EXPECT(env.le(keylet::trustLine(pseudoId, asset.raw().get<Issue>())) != nullptr);
402 }
403
404 // XRP-backed vaults leave the field absent: XRP has no separate
405 // holding ledger entry and no transferability concept to inherit.
406 {
407 testcase("sfReferenceHolding: XRP-backed vault, field absent");
408 Env env{*this, testableAmendments()};
409 Account const owner{"owner"};
410 env.fund(XRP(10'000), owner);
411 env.close();
412
413 PrettyAsset const asset{xrpIssue(), 1'000'000};
414 Vault const vault{env};
415 auto [tx, keylet] = vault.create({.owner = owner, .asset = asset});
416 env(tx);
417 env.close();
418
419 BEAST_EXPECT(!readReferenceHolding(env, keylet).has_value());
420 }
421
422 // Pre-fixCleanup3_2_0: vault share has the field absent regardless
423 // of underlying type.
424 {
425 testcase("sfReferenceHolding: vault share, pre-amendment");
426 Env env{*this, testableAmendments() - fixCleanup3_2_0};
427 Account const issuer{"issuer"};
428 Account const owner{"owner"};
429 env.fund(XRP(10'000), issuer, owner);
430 env.close();
431
432 MPTTester mptt{env, issuer, kMptInitNoFund};
433 mptt.create({.flags = tfMPTCanTransfer | tfMPTCanLock});
434 PrettyAsset const asset = mptt.issuanceID();
435 mptt.authorize({.account = owner});
436
437 Vault const vault{env};
438 auto [tx, keylet] = vault.create({.owner = owner, .asset = asset});
439 env(tx);
440 env.close();
441
442 BEAST_EXPECT(!readReferenceHolding(env, keylet).has_value());
443 }
444
445 // Plain MPTokenIssuanceCreate (not a vault share) must never
446 // populate the field. Only the post-amendment case is
447 // interesting; pre-amendment nothing writes the field at all.
448 {
449 testcase("sfReferenceHolding: plain MPT issuance never set");
450 Env env{*this, testableAmendments()};
451 Account const issuer{"issuer"};
452 env.fund(XRP(10'000), issuer);
453 env.close();
454
455 MPTTester mptt{env, issuer, kMptInitNoFund};
456 mptt.create({.flags = tfMPTCanTransfer | tfMPTCanLock});
457 env.close();
458
459 auto const sleIssuance = env.le(keylet::mptokenIssuance(mptt.issuanceID()));
460 if (BEAST_EXPECT(sleIssuance))
461 BEAST_EXPECT(!sleIssuance->isFieldPresent(sfReferenceHolding));
462 }
463 }
464
465 // Probe every transactor surface that might delete the vault pseudo-
466 // account's underlying holding (the MPToken or RippleState pointed to
467 // by sfReferenceHolding). Each scenario asserts either that the
468 // existing pseudo-account guards stop the deletion at preclaim, or
469 // that the ledger leaves the holding intact afterwards. This is a
470 // regression guard: if any of these guards regresses, the share's
471 // sfReferenceHolding pointer would dangle and the new ValidMPTIssuance
472 // invariant would catch it - but we want to fail much earlier, at
473 // the transactor's preclaim / doApply, not at invariant time.
474 void
476 {
477 using namespace test::jtx;
478
479 // Helper: read the share's referenced holding and confirm the
480 // pointed-to SLE still exists after the probe.
481 auto const referencedHoldingExists = [&](Env const& env,
482 Keylet const& vaultKeylet) -> bool {
483 auto const sleVault = env.le(vaultKeylet);
484 if (!sleVault)
485 return false;
486 auto const sleIssuance = env.le(keylet::mptokenIssuance(sleVault->at(sfShareMPTID)));
487 if (!sleIssuance || !sleIssuance->isFieldPresent(sfReferenceHolding))
488 return false;
489 auto const holdingKey = sleIssuance->getFieldH256(sfReferenceHolding);
490 return env.le(keylet::unchecked(holdingKey)) != nullptr;
491 };
492
493 // ---- MPT-backed vault ----------------------------------------
494 {
495 testcase("vault pseudo MPToken: Clawback blocked by tecPSEUDO_ACCOUNT");
496 Env env{*this, testableAmendments()};
497 Account const issuer{"issuer"};
498 Account const owner{"owner"};
499 Account const depositor{"depositor"};
500 env.fund(XRP(10'000), issuer, owner, depositor);
501 env.close();
502
503 MPTTester mptt{env, issuer, kMptInitNoFund};
504 mptt.create({.flags = tfMPTCanTransfer | tfMPTCanLock | tfMPTCanClawback});
505 PrettyAsset const asset = mptt.issuanceID();
506 mptt.authorize({.account = owner});
507 mptt.authorize({.account = depositor});
508 env(pay(issuer, depositor, asset(1'000)));
509 env.close();
510
511 Vault const vault{env};
512 auto [tx, keylet] = vault.create({.owner = owner, .asset = asset});
513 env(tx);
514 env.close();
515
516 env(vault.deposit({.depositor = depositor, .id = keylet.key, .amount = asset(500)}));
517 env.close();
518
519 BEAST_EXPECT(referencedHoldingExists(env, keylet));
520
521 Account const pseudoAccount{"vault-pseudo", env.le(keylet)->at(sfAccount)};
522 // Issuer attempts to claw back the FULL underlying balance
523 // (500) directly from the vault pseudo-account. With the
524 // full amount, the doApply path would drain the pseudo's
525 // MPToken to zero and removeEmptyHolding would erase it -
526 // if doApply ever ran. SAV's pseudo-account guard at
527 // Clawback.cpp:201 refuses at preclaim with
528 // tecPSEUDO_ACCOUNT before any state change.
529 env(claw(issuer, asset(500), pseudoAccount), Ter{tecPSEUDO_ACCOUNT});
530 env.close();
531 BEAST_EXPECT(referencedHoldingExists(env, keylet));
532 // Sanity: pseudo's full balance is intact.
533 BEAST_EXPECT(env.balance(pseudoAccount, asset).number() == 500);
534 }
535
536 {
537 testcase("vault pseudo MPToken: Issuer cannot Unauthorize pseudo");
538 Env env{*this, testableAmendments()};
539 Account const issuer{"issuer"};
540 Account const owner{"owner"};
541 env.fund(XRP(10'000), issuer, owner);
542 env.close();
543
544 MPTTester mptt{env, issuer, kMptInitNoFund};
545 mptt.create({.flags = tfMPTCanTransfer | tfMPTCanLock | tfMPTRequireAuth});
546 PrettyAsset const asset = mptt.issuanceID();
547 mptt.authorize({.account = owner});
548 mptt.authorize({.account = issuer, .holder = owner});
549 env.close();
550
551 Vault const vault{env};
552 auto [tx, keylet] = vault.create({.owner = owner, .asset = asset});
553 env(tx);
554 env.close();
555
556 BEAST_EXPECT(referencedHoldingExists(env, keylet));
557
558 auto const pseudoId = env.le(keylet)->at(sfAccount);
559 // Issuer attempts MPTokenAuthorize against the pseudo with
560 // tfMPTUnauthorize. MPTokenAuthorize.cpp blocks pseudo
561 // accounts via isPseudoAccount; the pseudo's MPToken is
562 // preserved. Construct the tx manually since the pseudo
563 // lacks a signing key, and the issuer-driven flavour is
564 // expressed via sfHolder.
565 json::Value jv;
566 jv[sfAccount] = issuer.human();
567 jv[sfHolder] = toBase58(pseudoId);
568 jv[sfMPTokenIssuanceID] = to_string(mptt.issuanceID());
569 jv[sfFlags] = tfMPTUnauthorize;
570 jv[sfTransactionType] = jss::MPTokenAuthorize;
571 env(jv, Ter{tecNO_PERMISSION});
572 env.close();
573 BEAST_EXPECT(referencedHoldingExists(env, keylet));
574 }
575
576 {
577 testcase("vault pseudo MPToken: MPTokenIssuanceDestroy blocked while vault holds");
578 Env env{*this, testableAmendments()};
579 Account const issuer{"issuer"};
580 Account const owner{"owner"};
581 Account const depositor{"depositor"};
582 env.fund(XRP(10'000), issuer, owner, depositor);
583 env.close();
584
585 MPTTester mptt{env, issuer, kMptInitNoFund};
586 mptt.create({.flags = tfMPTCanTransfer | tfMPTCanLock});
587 PrettyAsset const asset = mptt.issuanceID();
588 mptt.authorize({.account = owner});
589 mptt.authorize({.account = depositor});
590 env(pay(issuer, depositor, asset(1'000)));
591 env.close();
592
593 Vault const vault{env};
594 auto [tx, keylet] = vault.create({.owner = owner, .asset = asset});
595 env(tx);
596 env.close();
597
598 env(vault.deposit({.depositor = depositor, .id = keylet.key, .amount = asset(500)}));
599 env.close();
600
601 BEAST_EXPECT(referencedHoldingExists(env, keylet));
602
603 // While the vault holds outstanding underlying, the issuer
604 // cannot destroy the issuance. tecHAS_OBLIGATIONS confirms
605 // the protection - and as a side effect, the share's
606 // sfReferenceHolding pointer cannot be left pointing at a
607 // ghost issuance.
608 mptt.destroy({.id = mptt.issuanceID(), .err = tecHAS_OBLIGATIONS});
609 env.close();
610 BEAST_EXPECT(referencedHoldingExists(env, keylet));
611 }
612
613 // ---- IOU-backed vault ----------------------------------------
614 {
615 testcase("vault pseudo trust line: Clawback blocked by tecPSEUDO_ACCOUNT");
616 Env env{*this, testableAmendments()};
617 Account const issuer{"issuer"};
618 Account const owner{"owner"};
619 env.fund(XRP(10'000), issuer, owner);
620 env(fset(issuer, asfAllowTrustLineClawback));
621 env.close();
622
623 PrettyAsset const asset = issuer["IOU"];
624 env.trust(asset(1'000'000), owner);
625 env(pay(issuer, owner, asset(1'000)));
626 env.close();
627
628 Vault const vault{env};
629 auto [tx, keylet] = vault.create({.owner = owner, .asset = asset});
630 env(tx);
631 env.close();
632
633 env(vault.deposit({.depositor = owner, .id = keylet.key, .amount = asset(500)}));
634 env.close();
635
636 BEAST_EXPECT(referencedHoldingExists(env, keylet));
637
638 Account const pseudoAccount{"vault-pseudo", env.le(keylet)->at(sfAccount)};
639 // Issuer attempts to claw back the FULL IOU balance (500)
640 // directly from the vault pseudo. With the full amount, the
641 // doApply path would drain the trust line to zero and (if
642 // both reserve flags clear) trustDelete would erase it - if
643 // doApply ever ran. The same SAV pseudo-account guard
644 // refuses at preclaim with tecPSEUDO_ACCOUNT. The amount's
645 // STAmount issuer field is the holder, per IOU clawback
646 // convention.
647 env(claw(issuer, pseudoAccount["IOU"](500)), Ter{tecPSEUDO_ACCOUNT});
648 env.close();
649 BEAST_EXPECT(referencedHoldingExists(env, keylet));
650 // Sanity: pseudo's full balance is intact.
651 BEAST_EXPECT(env.balance(pseudoAccount, asset).number() == 500);
652 }
653
654 {
655 testcase("vault pseudo trust line: TrustSet limit=0 from issuer preserves line");
656 Env env{*this, testableAmendments()};
657 Account const issuer{"issuer"};
658 Account const owner{"owner"};
659 env.fund(XRP(10'000), issuer, owner);
660 env(fset(issuer, asfDefaultRipple));
661 env.close();
662
663 PrettyAsset const asset = issuer["IOU"];
664 env.trust(asset(1'000'000), owner);
665 env(pay(issuer, owner, asset(1'000)));
666 env.close();
667
668 Vault const vault{env};
669 auto [tx, keylet] = vault.create({.owner = owner, .asset = asset});
670 env(tx);
671 env.close();
672
673 env(vault.deposit({.depositor = owner, .id = keylet.key, .amount = asset(500)}));
674 env.close();
675
676 BEAST_EXPECT(referencedHoldingExists(env, keylet));
677
678 // Issuer submits TrustSet with limit=0 against the vault
679 // pseudo. The pseudo's side of the line still has the
680 // original (non-zero) limit and a non-zero balance, so the
681 // line is preserved - even though the issuer cleared its
682 // own side. trustDelete only fires when both limits clear
683 // and the balance is zero.
684 Account const pseudoAccount{"vault-pseudo", env.le(keylet)->at(sfAccount)};
685 env(trust(issuer, pseudoAccount["IOU"](0)));
686 env.close();
687 BEAST_EXPECT(referencedHoldingExists(env, keylet));
688 }
689
690 // ---- Positive control: VaultDelete is the only legitimate path
691 {
692 testcase("vault pseudo holding: VaultDelete is the legitimate cleanup path");
693 Env env{*this, testableAmendments()};
694 Account const issuer{"issuer"};
695 Account const owner{"owner"};
696 env.fund(XRP(10'000), issuer, owner);
697 env.close();
698
699 MPTTester mptt{env, issuer, kMptInitNoFund};
700 mptt.create({.flags = tfMPTCanTransfer | tfMPTCanLock});
701 PrettyAsset const asset = mptt.issuanceID();
702 mptt.authorize({.account = owner});
703
704 Vault const vault{env};
705 auto [tx, keylet] = vault.create({.owner = owner, .asset = asset});
706 env(tx);
707 env.close();
708
709 BEAST_EXPECT(referencedHoldingExists(env, keylet));
710 auto const pseudoId = env.le(keylet)->at(sfAccount);
711 auto const sharedMptId = env.le(keylet)->at(sfShareMPTID);
712 auto const holdingKeylet = keylet::mptoken(mptt.issuanceID(), pseudoId);
713
714 // VaultDelete tears down the vault pseudo's holding, the
715 // share issuance, and the pseudo-account itself. Invariant
716 // permits this because the tx is ttVAULT_DELETE.
717 env(vault.del({.owner = owner, .id = keylet.key}));
718 env.close();
719
720 BEAST_EXPECT(env.le(keylet) == nullptr);
721 BEAST_EXPECT(env.le(holdingKeylet) == nullptr);
722 BEAST_EXPECT(env.le(keylet::mptokenIssuance(sharedMptId)) == nullptr);
723 }
724 }
725
726public:
727 void
737};
738
739BEAST_DEFINE_TESTSUITE(VaultShares, app, xrpl);
740
741} // namespace xrpl
A generic endpoint for log messages.
Definition Journal.h:44
TestcaseT testcase
Memberspace for declaring test cases.
Definition suite.h:155
Represents a JSON value.
Definition json_value.h:121
constexpr TIss const & get() const
A currency issued by an account.
Definition Issue.h:18
Writable ledger view that accumulates state and tx changes.
Definition OpenView.h:59
Discardable, editable view to a ledger.
Definition Sandbox.h:18
static constexpr SeqProxy rawSequence(std::uint32_t v)
Factory function to return a sequence-based SeqProxy.
Definition SeqProxy.h:62
void run() override
Runs the suite.
void testRemoveEmptyHoldingConfidentialBalances()
Shared base for the Vault*_test family under src/test/app/vault/.
test::jtx::PrettyAsset PrettyAsset
SLE::pointer peek(Keylet const &k) override
Prepare to modify the SLE associated with key.
void update(SLE::Ref sle) override
Indicate changes to a peeked SLE.
Keylet computation functions.
Definition Indexes.h:39
Keylet unchecked(UInt256 const &key) noexcept
Any ledger entry.
Definition Indexes.cpp:409
Keylet vault(AccountID const &owner, SeqProxy const &seq) noexcept
Definition Indexes.cpp:565
Keylet mptoken(MPTID const &issuanceID, AccountID const &holder) noexcept
Definition Indexes.cpp:547
Keylet mptokenIssuance(MPTID const &issuanceID) noexcept
Definition Indexes.cpp:541
Keylet trustLine(AccountID const &id0, AccountID const &id1, Currency const &currency) noexcept
The index of a trust line for a given currency.
Definition Indexes.cpp:287
Use hash_* containers for keys that do not need a cryptographically secure hashing algorithm.
Definition algorithm.h:5
@ terADDRESS_COLLISION
Definition TER.h:230
Issue const & xrpIssue()
Returns an asset specifier that represents XRP.
Definition Issue.h:108
std::optional< AccountID > parseBase58(std::string const &s)
Parse AccountID from checked, base58 string.
std::string strHex(FwdIt begin, FwdIt end)
Definition strHex.h:13
TER removeEmptyHolding(ApplyViewContext ctx, AccountID const &accountID, MPTIssue const &mptIssue, beast::Journal journal)
std::string toBase58(AccountID const &v)
Convert AccountID to base58 checked string.
Definition AccountID.cpp:95
constexpr std::size_t kEcGamalEncryptedTotalLength
EC ElGamal ciphertext length: two compressed EC points concatenated.
Definition Protocol.h:507
std::string to_string(BaseUInt< Bits, Tag > const &a)
Definition base_uint.h:658
AccountID pseudoAccountAddress(ReadView const &view, UInt256 const &pseudoOwnerKey)
Generate a pseudo-account address from a pseudo owner key.
MPTID makeMptID(std::uint32_t const sequence, AccountID const &account)
Definition Indexes.cpp:219
@ TapNone
Definition ApplyView.h:28
BaseUInt< 160, detail::AccountIDTag > AccountID
A 160-bit unsigned that uniquely identifies an account.
Definition AccountID.h:34
@ tecPSEUDO_ACCOUNT
Definition TER.h:373
@ tecNO_AUTH
Definition TER.h:311
@ tecNO_PERMISSION
Definition TER.h:316
@ tecHAS_OBLIGATIONS
Definition TER.h:328
BEAST_DEFINE_TESTSUITE(AccountTxPaging, app, xrpl)
@ tesSUCCESS
Definition TER.h:253
A pair of SHAMap key and LedgerEntryType.
Definition Keylet.h:20
UInt256 key
Definition Keylet.h:21