xrpld
Loading...
Searching...
No Matches
Sponsor_test.cpp
1#include <test/jtx/Account.h>
2#include <test/jtx/Env.h>
3#include <test/jtx/TestHelpers.h>
4#include <test/jtx/acctdelete.h>
5#include <test/jtx/amount.h>
6#include <test/jtx/batch.h>
7#include <test/jtx/check.h>
8#include <test/jtx/credentials.h>
9#include <test/jtx/delegate.h>
10#include <test/jtx/deposit.h>
11#include <test/jtx/did.h>
12#include <test/jtx/escrow.h>
13#include <test/jtx/fee.h>
14#include <test/jtx/flags.h>
15#include <test/jtx/ledgerStateFix.h>
16#include <test/jtx/mpt.h>
17#include <test/jtx/multisign.h>
18#include <test/jtx/noop.h>
19#include <test/jtx/offer.h>
20#include <test/jtx/paths.h>
21#include <test/jtx/pay.h>
22#include <test/jtx/paychan.h>
23#include <test/jtx/regkey.h>
24#include <test/jtx/sendmax.h>
25#include <test/jtx/seq.h>
26#include <test/jtx/sig.h>
27#include <test/jtx/sponsor.h>
28#include <test/jtx/ter.h>
29#include <test/jtx/ticket.h>
30#include <test/jtx/token.h>
31#include <test/jtx/trust.h>
32#include <test/jtx/txflags.h>
33#include <test/jtx/vault.h>
34
35#include <xrpl/basics/Number.h>
36#include <xrpl/basics/Slice.h>
37#include <xrpl/basics/base_uint.h>
38#include <xrpl/basics/chrono.h>
39#include <xrpl/basics/strHex.h>
40#include <xrpl/beast/unit_test/suite.h>
41#include <xrpl/beast/utility/instrumentation.h>
42#include <xrpl/core/ServiceRegistry.h>
43#include <xrpl/json/json_value.h>
44#include <xrpl/ledger/ApplyView.h>
45#include <xrpl/ledger/OpenView.h>
46#include <xrpl/protocol/AccountID.h>
47#include <xrpl/protocol/Asset.h>
48#include <xrpl/protocol/Feature.h>
49#include <xrpl/protocol/Indexes.h>
50#include <xrpl/protocol/Issue.h>
51#include <xrpl/protocol/LedgerFormats.h>
52#include <xrpl/protocol/SField.h>
53#include <xrpl/protocol/STAmount.h>
54#include <xrpl/protocol/SeqProxy.h>
55#include <xrpl/protocol/TER.h>
56#include <xrpl/protocol/TxFlags.h>
57#include <xrpl/protocol/UintTypes.h>
58#include <xrpl/protocol/jss.h>
59#include <xrpl/tx/apply.h>
60#include <xrpl/tx/applySteps.h>
61
62#include <cstddef>
63#include <cstdint>
64#include <functional>
65#include <limits>
66#include <memory>
67#include <optional>
68#include <set>
69#include <string>
70#include <utility>
71#include <vector>
72
73namespace xrpl::test {
74
75static STAmount
77{
78 return env.current()->fees().reserve * count;
79}
80
81static STAmount
82reserve(jtx::Env const& env, std::uint32_t count)
83{
84 return env.current()->fees().accountReserve(count, 1);
85}
86
87static void
88adjustAccountXRPBalance(jtx::Env& env, jtx::Account const& account, STAmount const& balanceTo)
89{
90 using namespace test::jtx;
91 XRPL_ASSERT(isXRP(balanceTo), "adjustAccountXRPBalance: balanceTo must be XRP");
92 auto const currentBalance = env.balance(account);
93 if (currentBalance == balanceTo)
94 return;
95
96 auto const baseFee = env.current()->fees().base;
97 if (currentBalance > balanceTo)
98 {
99 env(pay(account, env.master, currentBalance - balanceTo),
100 Fee(XRP(1)),
102 Sig(sfSponsorSignature, env.master));
103 }
104 else
105 {
106 env(pay(env.master, account, balanceTo - currentBalance), Fee(baseFee));
107 }
108
109 env.close();
110}
111
113{
114public:
115 void
117 {
118 testcase("Disabled");
119 using namespace test::jtx;
120 Env env{*this, testableAmendments() - featureSponsor};
121 Account const alice("alice");
122 Account const sponsor("sponsor");
123 env.fund(XRP(10000), alice, sponsor);
124
125 // check Sponsor fields
126 auto const jt = noop(alice);
127 auto jt1 = jt;
128 jt1[sfSponsor.jsonName] = sponsor.human();
129 env(jt1, Ter(temDISABLED));
130 env(jt, Sig(sfSponsorSignature, sponsor), Ter(temDISABLED));
131
132 auto jt2 = jt;
133 jt2[sfSponsorFlags.jsonName] = spfSponsorFee | spfSponsorReserve;
134 env(jt2, Ter(temDISABLED));
135
136 // check Sponsor transactions
137 env(sponsor::transfer(alice, 0), Ter(temDISABLED));
139 }
140
141 void
143 {
144 testcase("Invalid SponsorshipSet");
145 using namespace test::jtx;
146 Env env{*this, testableAmendments()};
147 Account const alice("alice");
148 Account const bob("bob");
149 Account const sponsor("sponsor");
150 Account const noFunded("noFunded");
151 Account const gw("gw");
152
153 auto const usd = gw["usd"];
154 env.fund(XRP(10000), alice, sponsor, gw);
155 env.close();
156
157 //
158 // preflight
159 //
160
161 // Invalid flags
162 {
163 env(sponsor::set(sponsor, ~tfSponsorshipSetMask - tfInnerBatchTxn),
164 sponsor::SponseeAcc(alice),
166
167 env(sponsor::set(
168 sponsor,
169 tfSponsorshipSetRequireSignForFee | tfSponsorshipClearRequireSignForFee),
170 sponsor::SponseeAcc(alice),
172
173 env(sponsor::set(
174 sponsor,
175 tfSponsorshipSetRequireSignForReserve |
176 tfSponsorshipClearRequireSignForReserve),
177 sponsor::SponseeAcc(alice),
179
180 for (auto const flag : {
181 tfSponsorshipSetRequireSignForFee,
182 tfSponsorshipClearRequireSignForFee,
183 tfSponsorshipSetRequireSignForReserve,
184 tfSponsorshipClearRequireSignForReserve,
185 })
186 {
187 env(sponsor::set(sponsor, tfDeleteObject | flag),
188 sponsor::SponseeAcc(alice),
190 }
191 }
192
193 // invalid SponsorAccount / Sponsee
194 // Account = Sponsor
195 env(sponsor::set(alice, tfDeleteObject),
198 // Account = Sponsee
199 env(sponsor::set(alice, tfDeleteObject), sponsor::SponseeAcc(alice), Ter(temMALFORMED));
200 // Both Sponsor and Sponsee are specified
201 env(sponsor::set(alice, 0),
203 sponsor::SponseeAcc(alice),
205
206 // Invalid FeeAmountDelta
207 for (auto const& amt : {XRP(0), usd(1)})
208 {
209 env(sponsor::set_fee(sponsor, 0, amt, XRP(1)),
210 sponsor::SponseeAcc(alice),
212 }
213 // Invalid MaxFee
214 for (auto const& amt : {XRP(-1), usd(1)})
215 {
216 env(sponsor::set_fee(sponsor, 0, XRP(1), amt),
217 sponsor::SponseeAcc(alice),
219 }
220 // Invalid RemainingOwnerCountDelta
221 env(sponsor::set(sponsor, 0, 0, XRP(2), XRP(1)),
222 sponsor::SponseeAcc(alice),
223 Ter(temINVALID));
224
225 // Invalid Delete operation
226 env(sponsor::set_reserve(sponsor, tfDeleteObject, 1),
227 sponsor::SponseeAcc(alice),
229 env(sponsor::set_fee(sponsor, tfDeleteObject, XRP(1)),
230 sponsor::SponseeAcc(alice),
232 env(sponsor::set_max_fee(sponsor, tfDeleteObject, XRP(1)),
233 sponsor::SponseeAcc(alice),
235
236 // Invalid SponsorAccount with non-Delete operation
237 env(sponsor::set_reserve(sponsor, 0, 100),
240 env(sponsor::set_fee(sponsor, 0, XRP(1), XRP(1)),
243
244 // Redundant tx
246
247 //
248 // preclaim
249 //
250
251 // Invalid Sponsee
252 env(sponsor::set(sponsor, 0, 1), sponsor::SponseeAcc(noFunded), Ter(tecNO_DST));
253 env.close();
254
255 // Invalid Sponsor
256 env(sponsor::set(sponsor, tfDeleteObject),
258 Ter(tecNO_DST));
259 env.close();
260
261 // Invalid Delete operation (sponsorship not found)
262 env(sponsor::set(sponsor, tfDeleteObject), sponsor::SponseeAcc(alice), Ter(tecNO_ENTRY));
263 env.close();
264
265 // insufficient balance to sponsor Fee
266 adjustAccountXRPBalance(env, sponsor, env.current()->fees().reserve);
268 env.close();
269
270 // insufficient reserve to create sponsorship
271 adjustAccountXRPBalance(env, sponsor, XRP(100) + XRP(1) + reserve(env, 1) - drops(1));
272 env(sponsor::set(sponsor, 0, 100, XRP(100)),
273 sponsor::SponseeAcc(alice),
274 Fee(XRP(1)),
276 env.close();
277
278 // FeeAmount + Fee > Balance
279 // Balance = 1000XRP, FeeAmount = 1001XRP
281 env(sponsor::set_fee(sponsor, 0, XRP(1001)),
282 sponsor::SponseeAcc(alice),
283 Fee(XRP(1)),
285 env.close();
286 // Balance = 1000XRP, FeeAmount = 999XRP, Fee=2XRP
288 env(sponsor::set_fee(sponsor, 0, XRP(999)),
289 sponsor::SponseeAcc(alice),
290 Fee(XRP(2)),
292 env.close();
293
294 // create sponsor to use above tests
295 // need feeAmount(1000) + Fee(1) + reserve(~250) = ~1251
296 adjustAccountXRPBalance(env, sponsor, XRP(1000) + XRP(1) + reserve(env, 1));
297 env(sponsor::set(sponsor, 0, 100, XRP(1000)),
298 sponsor::SponseeAcc(alice),
299 Fee(XRP(1)),
300 Ter(tesSUCCESS));
301 env.close();
302
303 // delta-based balance check
304 // After create: sponsor balance ~ 0, feeAmount = XRP(1000)
305
306 // Decreasing feeAmount should succeed (refund, negative delta)
308 env(sponsor::set_fee(sponsor, 0, XRP(-200)),
309 sponsor::SponseeAcc(alice),
310 Fee(XRP(1)),
311 Ter(tesSUCCESS));
312 env.close();
313 // balance was 500, delta = 800-1000 = -200 (refund), balance = 500+200-1 = 699
314
315 // Increasing feeAmount within delta budget should succeed
317 env(sponsor::set_fee(sponsor, 0, XRP(50)),
318 sponsor::SponseeAcc(alice),
319 Fee(XRP(1)),
320 Ter(tesSUCCESS));
321 env.close();
322 // balance was 500, delta = 850-800 = 50, balance = 500-50-1 = 449
323
324 // Increasing feeAmount where delta exceeds balance should fail
326 env(sponsor::set_fee(sponsor, 0, XRP(350)),
327 sponsor::SponseeAcc(alice),
328 Fee(XRP(1)),
330 env.close();
331
332 // Increasing feeAmount to reach insufficient reserve
334 env(sponsor::set_fee(sponsor, 0, XRP(309)),
335 sponsor::SponseeAcc(alice),
336 Fee(XRP(1)),
338 env.close();
339 }
340
341 void
343 {
344 testcase("Pseudo account sponsorship");
345 using namespace test::jtx;
346 Env env{*this, testableAmendments()};
347 Account const alice("alice");
348 Account const bob("bob");
349 Account const gw("gw");
350 Account const sp("sponsor");
351
352 Asset const asset = gw["IOU"].asset();
353
354 env.fund(XRP(1000000), alice, bob, gw, sp);
355 env.close();
356
357 // Create a vault to get a pseudo account
358 Vault const vault{env};
359 auto [tx, keylet] = vault.create({.owner = alice, .asset = asset});
360 env(tx);
361 env.close();
362
363 auto const vaultSle = env.le(keylet);
364 BEAST_EXPECT(vaultSle);
365 Account const pseudoAcc("vault", vaultSle->getAccountID(sfAccount));
366 env.memoize(pseudoAcc);
367
368 // Sponsee is a pseudo account -> tecPSEUDO_ACCOUNT
369 env(sponsor::set(sp, 0, 100, XRP(100)),
370 sponsor::SponseeAcc(pseudoAcc),
372 env.close();
373
374 // Sponsor is a pseudo account -> tecPSEUDO_ACCOUNT
375 // (submitted by bob with counterpartySponsor pointing to pseudo account)
376 env(sponsor::set(bob, tfDeleteObject),
379 env.close();
380 }
381
382 void
384 {
385 testcase("Single signing");
386 using namespace test::jtx;
387 Env env{*this, features};
388 Account const alice("alice");
389 Account const sponsor("sponsor");
390 Account const invalid("invalid");
391
392 env.fund(XRP(10000), alice, sponsor);
393 env.close();
394
395 // Signature doesn't exist
396 auto tx = noop(alice);
397 tx[sfSponsor.jsonName] = sponsor.human();
398 tx[sfSponsorSignature.jsonName][sfSigningPubKey.jsonName] = strHex(sponsor.pk().slice());
399
401
402 // Invalid signature
403 tx[sfSponsorSignature.jsonName][sfTxnSignature.jsonName] = "DEADBEEF";
405
406 // Signer account doesn't exist
407 env(noop(alice),
408 Fee(XRP(1)),
410 Sig(sfSponsorSignature, invalid),
412
413 // Success
414 env(noop(alice),
415 Fee(XRP(1)),
417 Sig(sfSponsorSignature, sponsor),
418 Ter(tesSUCCESS));
419
420 // Sponsor authorizes with its regular key -> tesSUCCESS
421 Account const regKey("regKey");
422 Account const other("other");
423 env.fund(XRP(10000), regKey, other);
424 env.close();
425 env(regkey(sponsor, regKey));
426 env.close();
427 env(noop(alice),
428 Fee(XRP(1)),
430 Sig(sfSponsorSignature, regKey),
431 Ter(tesSUCCESS));
432
433 // Sponsor slot signed by an unrelated funded account's key -> tefBAD_AUTH
434 env(noop(alice),
435 Fee(XRP(1)),
437 Sig(sfSponsorSignature, other),
439
440 // Sponsor with master key disabled signing with its master key
441 // -> tefMASTER_DISABLED
442 Account const sponsorDM("sponsorDM");
443 env.fund(XRP(10000), sponsorDM);
444 env.close();
445 env(regkey(sponsorDM, regKey));
446 env(fset(sponsorDM, asfDisableMaster), Sig(sponsorDM));
447 env.close();
448 env(noop(alice),
449 Fee(XRP(1)),
450 sponsor::As(sponsorDM, spfSponsorReserve),
451 Sig(sfSponsorSignature, sponsorDM),
453
454 // Sponsor keyed by a pseudo-account that carries a SponsorSignature
455 // -> tefBAD_AUTH (pseudo-accounts can't authorize signatures)
456 Account const gw("gw");
457 env.fund(XRP(1000000), gw);
458 env.close();
459 Vault const vault{env};
460 auto [vtx, vkey] = vault.create({.owner = alice, .asset = gw["IOU"].asset()});
461 env(vtx);
462 env.close();
463 auto const vaultSle = env.le(vkey);
464 BEAST_EXPECT(vaultSle);
465 Account const pseudoAcc("vault", vaultSle->getAccountID(sfAccount));
466 env.memoize(pseudoAcc);
467 env(noop(alice),
468 Fee(XRP(1)),
469 sponsor::As(pseudoAcc, spfSponsorReserve),
470 Sig(sfSponsorSignature, other),
472 }
473
474 void
476 {
477 testcase("Multi signing");
478 using namespace test::jtx;
479 Env env{*this, features};
480 Account const alice("alice");
481 Account const bob("bob");
482 Account const sponsor("sponsor");
483 Account const signer1("signer1");
484 Account const signer2("signer2");
485
486 env.fund(XRP(10000), alice, bob, sponsor);
487 env.close();
488
489 env(signers(sponsor, 1, {{signer1, 1}, {signer2, 1}}));
490 env.close();
491
492 // Invalid signature
493 auto tx = noop(alice);
494 auto& signers1 = tx[sfSponsorSignature.jsonName][sfSigners.jsonName][0U][sfSigner.jsonName];
495 signers1[sfAccount.jsonName] = signer1.human();
496 signers1[sfSigningPubKey.jsonName] = strHex(signer1.pk().slice());
497 signers1[sfTxnSignature.jsonName] = "DEADBEEF";
499
500 // bob is not a multi-signing account.
501 env(noop(alice),
502 Fee(XRP(1)),
504 Msig(sfSponsorSignature, {signer1}),
506
507 env(noop(alice),
508 Fee(XRP(1)),
510 Msig(sfSponsorSignature, {signer1}),
511 Ter(tesSUCCESS));
512 env.close();
513
514 env(signers(sponsor, 2, {{signer1, 1}, {signer2, 1}}));
515 env.close();
516
517 // test calculateBaseFee for multisigned sponsor
518 auto const baseFee = env.current()->fees().base;
519 env(noop(alice),
520 Fee(baseFee + 2 * baseFee - 1),
522 Msig(sfSponsorSignature, {signer1, signer2}),
524
525 env(noop(alice),
526 Fee(baseFee + 2 * baseFee),
528 Msig(sfSponsorSignature, {signer1, signer2}),
529 Ter(tesSUCCESS));
530 env.close();
531
532 // Quorum is 2 but only one signer signs -> tefBAD_QUORUM
533 env(noop(alice),
534 Fee(XRP(1)),
536 Msig(sfSponsorSignature, {signer1}),
538
539 // Signer that is not on the sponsor's signer list -> tefBAD_SIGNATURE
540 Account const stranger("stranger");
541 env.fund(XRP(10000), stranger);
542 env.close();
543 env(noop(alice),
544 Fee(XRP(1)),
546 Msig(sfSponsorSignature, {stranger}),
548 }
549
550 void
552 {
553 testcase("Invalid Sponsor Field");
554 using namespace test::jtx;
555 Env env{*this, testableAmendments()};
556 Account const alice("alice");
557 Account const sponsor("sponsor");
558 Account const noFunded("noFunded");
559 env.fund(XRP(10000), alice, sponsor);
560 env.close();
561
562 // Invalid Sponsor Account (Account = Sponsor.Account)
563 env(noop(alice), sponsor::As(alice, spfSponsorFee), Ter(temMALFORMED));
564
565 // Invalid Sponsor Account
566 // (SponsorSignature is specified but Sponsor.Account is not specified)
567 env(noop(alice), Sig(sfSponsorSignature, sponsor), Ter(temMALFORMED));
568
569 // Invalid Sponsor Account (Sponsor.Account doesn't exist)
570 env(noop(alice), sponsor::As(noFunded, spfSponsorReserve), Ter(terNO_ACCOUNT));
571 env(noop(alice),
573 Sig(sfSponsorSignature, noFunded),
575
576 // Invalid Flags
577 env(noop(alice),
580
581 // SponsorFlags=0 with valid sponsor (no sponsorship purpose)
582 env(noop(alice), sponsor::As(sponsor, 0), Ter(temINVALID_FLAG));
583
584 // no SponsorFlag with valid sponsor
585 auto tx = noop(alice);
586 tx[sfSponsor.jsonName] = sponsor.human();
587 env(tx, Ter(temINVALID_FLAG));
588
589 // Invalid Flags without sponsor
590 tx = noop(alice);
591 tx[sfSponsorFlags.jsonName] = spfSponsorFee | spfSponsorReserve;
592 env(tx, Ter(temINVALID_FLAG));
593 }
594
595 void
597 {
598 testcase("Simple SponsorshipSet");
599 using namespace test::jtx;
600 Env env{*this, testableAmendments()};
601 Account const alice("alice");
602 Account const sponsor("sponsor");
603 env.fund(XRP(10000), alice, sponsor);
604 env.close();
605
606 {
607 // create sponsorship
608 env(sponsor::set(
609 sponsor,
610 tfSponsorshipSetRequireSignForFee | tfSponsorshipSetRequireSignForReserve,
611 100,
612 XRP(100),
613 XRP(1)),
614 Fee(XRP(1)),
615 sponsor::SponseeAcc(alice),
616 Ter(tesSUCCESS));
617 env.close();
618
619 auto sle = env.le(keylet::sponsorship(sponsor, alice));
620 BEAST_EXPECT(sle);
621 BEAST_EXPECT(sle->at(sfRemainingOwnerCount) == 100);
622 BEAST_EXPECT(sle->at(sfFeeAmount) == XRP(100));
623 BEAST_EXPECT(sle->at(sfMaxFee) == XRP(1));
624 BEAST_EXPECT(sle->isFlag(lsfSponsorshipRequireSignForFee));
625 BEAST_EXPECT(sle->isFlag(lsfSponsorshipRequireSignForReserve));
626 BEAST_EXPECT(env.balance(sponsor) == XRP(10000) - sle->at(sfFeeAmount) - XRP(1));
627
628 // update sponsorship (decrement)
629 env(sponsor::set(sponsor, 0, -50, XRP(-50), XRP(0.5)),
630 sponsor::SponseeAcc(alice),
631 Fee(XRP(1)),
632 Ter(tesSUCCESS));
633 env.close();
634
635 sle = env.le(keylet::sponsorship(sponsor, alice));
636 BEAST_EXPECT(sle);
637 BEAST_EXPECT(sle->at(sfRemainingOwnerCount) == 50);
638 BEAST_EXPECT(sle->at(sfFeeAmount) == XRP(50));
639 BEAST_EXPECT(sle->at(sfMaxFee) == XRP(0.5));
640 BEAST_EXPECT(env.balance(sponsor) == XRP(10000) - sle->at(sfFeeAmount) - XRP(2));
641
642 // update sponsorship (increment)
643 env(sponsor::set(sponsor, 0, 150, XRP(150), XRP(2)),
644 sponsor::SponseeAcc(alice),
645 Fee(XRP(1)),
646 Ter(tesSUCCESS));
647 env.close();
648
649 sle = env.le(keylet::sponsorship(sponsor, alice));
650 BEAST_EXPECT(sle);
651 BEAST_EXPECT(sle->at(sfRemainingOwnerCount) == 200);
652 BEAST_EXPECT(sle->at(sfFeeAmount) == XRP(200));
653 BEAST_EXPECT(sle->at(sfMaxFee) == XRP(2));
654 BEAST_EXPECT(env.balance(sponsor) == XRP(10000) - sle->at(sfFeeAmount) - XRP(3));
655
656 // delete from sponsor
658 env.close();
659
660 BEAST_EXPECT(env.balance(sponsor) == XRP(10000) - XRP(4));
661
662 env(sponsor::set(
663 sponsor,
664 tfSponsorshipSetRequireSignForFee | tfSponsorshipSetRequireSignForReserve,
665 100,
666 XRP(100),
667 XRP(1)),
668 sponsor::SponseeAcc(alice),
669 Ter(tesSUCCESS));
670 env.close();
671
672 // delete from sponsee
674 env.close();
675 BEAST_EXPECT(!env.le(keylet::sponsorship(sponsor, alice)));
676
677 env(sponsor::set_max_fee(sponsor, 0, XRP(1)),
678 sponsor::SponseeAcc(alice),
680 env.close();
681 BEAST_EXPECT(!env.le(keylet::sponsorship(sponsor, alice)));
682
683 env(sponsor::set(sponsor, 0, std::nullopt, std::nullopt, XRP(0)),
684 sponsor::SponseeAcc(alice),
686 env.close();
687 BEAST_EXPECT(!env.le(keylet::sponsorship(sponsor, alice)));
688
689 // create sponsorship with negative values
690 env(sponsor::set_reserve(sponsor, 0, -100),
691 sponsor::SponseeAcc(alice),
693 env.close();
694 BEAST_EXPECT(!env.le(keylet::sponsorship(sponsor, alice)));
695 env(sponsor::set_fee(sponsor, 0, XRP(-100)),
696 sponsor::SponseeAcc(alice),
698 env.close();
699 BEAST_EXPECT(!env.le(keylet::sponsorship(sponsor, alice)));
700
701 // create sponsorship with non-zero value
702 env(sponsor::set(sponsor, 0, 100, XRP(101), XRP(1)),
703 sponsor::SponseeAcc(alice),
704 Fee(XRP(1)));
705 env.close();
706
707 sle = env.le(keylet::sponsorship(sponsor, alice));
708 BEAST_EXPECT(sle);
709 BEAST_EXPECT(sle->at(sfRemainingOwnerCount) == 100);
710 BEAST_EXPECT(sle->at(sfFeeAmount) == XRP(101));
711 BEAST_EXPECT(sle->at(sfMaxFee) == XRP(1));
712
713 // update sponsorship flags
714 auto const testFlagUpdate = [&](auto setFlag, auto clearFlag, auto ledgerFlag) {
715 env(sponsor::set(sponsor, setFlag), sponsor::SponseeAcc(alice), Fee(XRP(1)));
716 env.close();
717
718 sle = env.le(keylet::sponsorship(sponsor, alice));
719 BEAST_EXPECT(sle);
720 BEAST_EXPECT(sle->isFlag(ledgerFlag));
721
722 env(sponsor::set(sponsor, clearFlag), sponsor::SponseeAcc(alice), Fee(XRP(1)));
723 env.close();
724
725 sle = env.le(keylet::sponsorship(sponsor, alice));
726 BEAST_EXPECT(sle);
727 BEAST_EXPECT(!sle->isFlag(ledgerFlag));
728 };
729
730 testFlagUpdate(
731 tfSponsorshipSetRequireSignForFee,
732 tfSponsorshipClearRequireSignForFee,
733 lsfSponsorshipRequireSignForFee);
734 testFlagUpdate(
735 tfSponsorshipSetRequireSignForReserve,
736 tfSponsorshipClearRequireSignForReserve,
737 lsfSponsorshipRequireSignForReserve);
738
739 // Cannot update sponsorship so both fee and reserve budgets are absent.
740 env(sponsor::set(sponsor, 0, -100, XRP(-101), std::nullopt),
741 sponsor::SponseeAcc(alice),
742 Fee(XRP(1)),
744 env.close();
745
746 sle = env.le(keylet::sponsorship(sponsor, alice));
747 BEAST_EXPECT(sle);
748 BEAST_EXPECT(sle->at(sfRemainingOwnerCount) == 100);
749 BEAST_EXPECT(sle->at(sfFeeAmount) == XRP(101));
750 BEAST_EXPECT(sle->at(sfMaxFee) == XRP(1));
751 }
752
753 {
754 // Removing one budget field while the other remains keeps the
755 // Sponsorship valid. Starting state (from above):
756 // RemainingOwnerCount = 100, FeeAmount = XRP(101).
757
758 // Remove only FeeAmount (set to 0); RemainingOwnerCount remains.
759 env(sponsor::set_fee(sponsor, 0, XRP(-101)),
760 sponsor::SponseeAcc(alice),
761 Fee(XRP(1)),
762 Ter(tesSUCCESS));
763 env.close();
764
765 auto sle = env.le(keylet::sponsorship(sponsor, alice));
766 BEAST_EXPECT(sle);
767 BEAST_EXPECT(!sle->isFieldPresent(sfFeeAmount));
768 BEAST_EXPECT(sle->at(sfRemainingOwnerCount) == 100);
769
770 // Re-add FeeAmount, then remove only RemainingOwnerCount;
771 // FeeAmount remains.
772 env(sponsor::set_fee(sponsor, 0, XRP(100)),
773 sponsor::SponseeAcc(alice),
774 Fee(XRP(1)),
775 Ter(tesSUCCESS));
776 env.close();
777
778 // A negative FeeAmountDelta larger than the current FeeAmount is
779 // clamped, so only the current FeeAmount is refunded and the field
780 // is removed. RemainingOwnerCount keeps the Sponsorship valid.
781 auto const balanceBefore = env.balance(sponsor);
782 env(sponsor::set_fee(sponsor, 0, XRP(-500)),
783 sponsor::SponseeAcc(alice),
784 Fee(XRP(1)),
785 Ter(tesSUCCESS));
786 env.close();
787
788 sle = env.le(keylet::sponsorship(sponsor, alice));
789 BEAST_EXPECT(sle);
790 BEAST_EXPECT(!sle->isFieldPresent(sfFeeAmount));
791 BEAST_EXPECT(sle->at(sfRemainingOwnerCount) == 100);
792 BEAST_EXPECT(env.balance(sponsor) == balanceBefore + XRP(100) - XRP(1));
793
794 // Restore FeeAmount for the checks below.
795 env(sponsor::set_fee(sponsor, 0, XRP(100)),
796 sponsor::SponseeAcc(alice),
797 Fee(XRP(1)),
798 Ter(tesSUCCESS));
799 env.close();
800
801 env(sponsor::set_reserve(sponsor, 0, -100),
802 sponsor::SponseeAcc(alice),
803 Fee(XRP(1)),
804 Ter(tesSUCCESS));
805 env.close();
806
807 sle = env.le(keylet::sponsorship(sponsor, alice));
808 BEAST_EXPECT(sle);
809 BEAST_EXPECT(!sle->isFieldPresent(sfRemainingOwnerCount));
810 BEAST_EXPECT(sle->at(sfFeeAmount) == XRP(100));
811
812 // Decreasing FeeAmount below zero must fail with tecNO_PERMISSION
813 // when there is no RemainingOwnerCount (the budget would become
814 // entirely empty). Current state: FeeAmount = XRP(100), no
815 // RemainingOwnerCount.
816 env(sponsor::set_fee(sponsor, 0, XRP(-101)),
817 sponsor::SponseeAcc(alice),
818 Fee(XRP(1)),
820 env.close();
821
822 // Confirm that the sponsorship is unchanged.
823 sle = env.le(keylet::sponsorship(sponsor, alice));
824 BEAST_EXPECT(sle);
825 BEAST_EXPECT(!sle->isFieldPresent(sfRemainingOwnerCount));
826 BEAST_EXPECT(sle->at(sfFeeAmount) == XRP(100));
827 }
828
829 {
830 // Update Sponsorship (FeeAmount)
831 // set empty FeeAmount
833 env.close();
834
835 // add FeeAmount
836 env(sponsor::set_fee(sponsor, 0, XRP(100)),
837 sponsor::SponseeAcc(alice),
838 Ter(tesSUCCESS));
839 env.close();
840
842 env.close();
843 }
844 {
845 // Update Sponsorship (ReserveCount)
846 // set empty ReserveCount
847 env(sponsor::set_fee(sponsor, 0, XRP(100)),
848 sponsor::SponseeAcc(alice),
849 Ter(tesSUCCESS));
850 env.close();
851
852 // add ReserveCount
854 env.close();
855
857 env.close();
858 }
859 {
860 // delete Sponsorship (only with FeeAmount)
861 env(sponsor::set_fee(sponsor, 0, XRP(100)),
862 sponsor::SponseeAcc(alice),
863 Ter(tesSUCCESS));
864 env.close();
865
867 env.close();
868 }
869 {
870 // delete Sponsorship (only with ReserveCount)
872 env.close();
873
875 env.close();
876 }
877 }
878
879 void
881 {
882 testcase("RemainingOwnerCount overflow and underflow clamping");
883 using namespace test::jtx;
884 Env env{*this, testableAmendments()};
885 Account const alice("alice");
886 Account const sponsor("sponsor");
887 env.fund(XRP(10000), alice, sponsor);
888 env.close();
889
891
892 // --- Positive overflow: delta causes count to exceed UINT32_MAX ---
893 {
894 // Create with count = INT32_MAX.
895 env(sponsor::set_reserve(sponsor, 0, kInt32Max),
896 sponsor::SponseeAcc(alice),
897 Ter(tesSUCCESS));
898 env.close();
899 BEAST_EXPECT(
900 env.le(keylet::sponsorship(sponsor, alice))->at(sfRemainingOwnerCount) ==
901 static_cast<std::uint32_t>(kInt32Max));
902
903 // Add INT32_MAX again: count = 2 * INT32_MAX = 4294967294 (<= UINT32_MAX, still ok).
904 env(sponsor::set_reserve(sponsor, 0, kInt32Max),
905 sponsor::SponseeAcc(alice),
906 Ter(tesSUCCESS));
907 env.close();
908 BEAST_EXPECT(
909 env.le(keylet::sponsorship(sponsor, alice))->at(sfRemainingOwnerCount) ==
910 2u * static_cast<std::uint32_t>(kInt32Max));
911
912 // Adding 2 more pushes count to 4294967296, exceeding UINT32_MAX: reject.
913 env(sponsor::set_reserve(sponsor, 0, 2),
914 sponsor::SponseeAcc(alice),
916 env.close();
917
918 // SLE is unchanged.
919 BEAST_EXPECT(
920 env.le(keylet::sponsorship(sponsor, alice))->at(sfRemainingOwnerCount) ==
921 2u * static_cast<std::uint32_t>(kInt32Max));
922
924 env.close();
925 }
926
927 // --- Negative underflow: clamps to 0; fee budget survives ---
928 {
929 // Create with count=10 and a fee budget.
930 env(sponsor::set(sponsor, 0, 10, XRP(100)),
931 sponsor::SponseeAcc(alice),
932 Ter(tesSUCCESS));
933 env.close();
934 BEAST_EXPECT(
935 env.le(keylet::sponsorship(sponsor, alice))->at(sfRemainingOwnerCount) == 10u);
936
937 // Delta of -20 produces count = -10; clamps to 0 (field absent).
939 env.close();
940
941 auto const sle = env.le(keylet::sponsorship(sponsor, alice));
942 BEAST_EXPECT(sle);
943 BEAST_EXPECT(!sle->isFieldPresent(sfRemainingOwnerCount));
944 BEAST_EXPECT(sle->at(sfFeeAmount) == XRP(100));
945
947 env.close();
948 }
949
950 // --- Negative underflow: clamped count=0 with no fee budget → no budget ---
951 {
952 // Create with count=10, no fee.
954 env.close();
955 BEAST_EXPECT(
956 env.le(keylet::sponsorship(sponsor, alice))->at(sfRemainingOwnerCount) == 10u);
957
958 // Delta of -20 would clamp count to 0 with no fee → empty budget → tecNO_PERMISSION.
959 env(sponsor::set_reserve(sponsor, 0, -20),
960 sponsor::SponseeAcc(alice),
962 env.close();
963
964 // SLE is unchanged.
965 BEAST_EXPECT(
966 env.le(keylet::sponsorship(sponsor, alice))->at(sfRemainingOwnerCount) == 10u);
967
969 env.close();
970 }
971 }
972
973 void
975 {
976 testcase("Consequences");
977 using namespace test::jtx;
978 Env env{*this, testableAmendments()};
979 auto const baseFee = env.current()->fees().base;
980
981 Account const alice("alice");
982 Account const sponsor("sponsor");
983 env.memoize(alice);
984 env.memoize(sponsor);
985
986 {
987 // A positive FeeAmountDelta is the maximum XRP the tx can spend.
988 auto const jt = env.jt(
989 sponsor::set_fee(sponsor, 0, XRP(100)),
990 sponsor::SponseeAcc(alice),
991 Seq(1),
992 Fee(baseFee));
993 auto const pf =
994 preflight(env.app(), env.current()->rules(), *jt.stx, TapNone, env.journal);
995 BEAST_EXPECT(isTesSuccess(pf.ter));
996 BEAST_EXPECT(!pf.consequences.isBlocker());
997 BEAST_EXPECT(pf.consequences.fee() == drops(baseFee));
998 BEAST_EXPECT(pf.consequences.potentialSpend() == XRP(100));
999 }
1000
1001 {
1002 // A negative FeeAmountDelta withdraws from the sponsorship, so the
1003 // transaction cannot spend anything.
1004 auto const jt = env.jt(
1005 sponsor::set_fee(sponsor, 0, XRP(-100)),
1006 sponsor::SponseeAcc(alice),
1007 Seq(1),
1008 Fee(baseFee));
1009 auto const pf =
1010 preflight(env.app(), env.current()->rules(), *jt.stx, TapNone, env.journal);
1011 BEAST_EXPECT(isTesSuccess(pf.ter));
1012 BEAST_EXPECT(!pf.consequences.isBlocker());
1013 BEAST_EXPECT(pf.consequences.fee() == drops(baseFee));
1014 BEAST_EXPECT(pf.consequences.potentialSpend() == XRP(0));
1015 }
1016
1017 {
1018 // No FeeAmountDelta at all.
1019 auto const jt = env.jt(
1021 sponsor::SponseeAcc(alice),
1022 Seq(1),
1023 Fee(baseFee));
1024 auto const pf =
1025 preflight(env.app(), env.current()->rules(), *jt.stx, TapNone, env.journal);
1026 BEAST_EXPECT(isTesSuccess(pf.ter));
1027 BEAST_EXPECT(!pf.consequences.isBlocker());
1028 BEAST_EXPECT(pf.consequences.fee() == drops(baseFee));
1029 BEAST_EXPECT(pf.consequences.potentialSpend() == XRP(0));
1030 }
1031 }
1032
1033 void
1035 {
1036 testcase("PreFund and Cosign");
1037 using namespace test::jtx;
1038 Account const alice("alice");
1039 Account const bob("bob");
1040 Account const charlie("charlie");
1041 Account const sponsor("sponsor");
1042
1043 {
1044 // Both pre-funded and co-signed; the pre-funded value is used.
1045 Env env{*this, testableAmendments()};
1046 env.fund(XRP(10000), alice, bob, sponsor);
1047 env.close();
1048
1049 env(sponsor::set(sponsor, 0, 100, XRP(100), XRP(1)),
1050 sponsor::SponseeAcc(alice),
1051 Ter(tesSUCCESS));
1052 env.close();
1053
1054 auto const checkSeq = env.seq(alice);
1055 env(check::create(alice, bob, XRP(1)),
1057 Sig(sfSponsorSignature, sponsor),
1058 Fee(XRP(1)),
1059 Ter(tesSUCCESS));
1060 env.close();
1061
1062 auto sle = env.le(keylet::sponsorship(sponsor, alice));
1063 BEAST_EXPECT(sle);
1064 BEAST_EXPECT(sle->at(sfRemainingOwnerCount) == 99);
1065 BEAST_EXPECT(sle->at(sfFeeAmount) == XRP(99));
1066
1067 env(check::cancel(alice, keylet::check(alice, SeqProxy::rawSequence(checkSeq)).key),
1068 Ter(tesSUCCESS));
1069 env.close();
1070
1071 sle = env.le(keylet::sponsorship(sponsor, alice));
1072 BEAST_EXPECT(sle);
1073 BEAST_EXPECT(sle->at(sfRemainingOwnerCount) == 99); // not restored
1074 BEAST_EXPECT(sle->at(sfFeeAmount) == XRP(99));
1075 }
1076
1077 {
1078 // if pre-funded value is not enough, error
1079 Env env{*this, testableAmendments()};
1080 env.fund(XRP(10000), alice, bob, charlie, sponsor);
1081 env.close();
1082
1083 env(sponsor::set(sponsor, 0, 1, XRP(10), XRP(100)),
1084 sponsor::SponseeAcc(alice),
1085 Ter(tesSUCCESS));
1086 env.close();
1087
1088 // Fee insufficient
1089 env(check::create(alice, bob, XRP(1)),
1091 Sig(sfSponsorSignature, sponsor),
1092 Fee(XRP(11)),
1094 env.close();
1095
1097 env.close();
1098
1099 // reserve insufficient
1100 env(check::create(alice, bob, XRP(1)),
1102 Sig(sfSponsorSignature, sponsor),
1103 Fee(XRP(1)),
1105 env.close();
1106 }
1107 }
1108
1109 void
1111 {
1112 testcase("Sponsored Free-Tier Reserve");
1113 using namespace test::jtx;
1114 Account const alice("alice");
1115 Account const issuer("issuer");
1116 Account const sponsor("sponsor");
1117
1118 // Trust lines and MPTokens normally skip the reserve check when the
1119 // holder's ownerCount < 2 (the "free-tier" / first-two-items shortcut). When the
1120 // tx is sponsored, that shortcut must not apply — the sponsor must
1121 // still cover the reserve.
1122 Env env{*this, testableAmendments()};
1123 env.fund(XRP(10000), alice, issuer);
1124 // Sponsor is funded just below the reserve required to cover a single
1125 // sponsored item.
1126 env.fund(reserve(env, 1) - drops(1), sponsor);
1127 env.close();
1128 BEAST_EXPECT(ownerCount(env, alice) == 0);
1129
1130 MPTTester mptt(env, issuer, {.fund = false});
1131 mptt.create();
1132
1133 // Free-tier trust line cosigned by an undercapitalized sponsor must
1134 // fail — the holder's free-first-two-items shortcut does not let the
1135 // sponsor skip the reserve check.
1136 env(trust(alice, issuer["USD"](100)),
1138 Sig(sfSponsorSignature, sponsor),
1140 env.close();
1141
1142 // Free-tier MPTokenAuthorize must also fail for the same reason.
1143 env(MPTTester::authorizeJV({.account = alice, .id = mptt.issuanceID()}),
1145 Sig(sfSponsorSignature, sponsor),
1147 env.close();
1148 }
1149
1150 void
1152 {
1153 testcase(
1154 std::string("Transfer Sponsor ") +
1155 (features[fixCleanup3_4_0] ? "(fixCleanup3_4_0 enabled)"
1156 : "(fixCleanup3_4_0 disabled)"));
1157 using namespace test::jtx;
1158
1159 // Verify preflight checks
1160 {
1161 Env env{*this, features};
1162 Account const alice("alice");
1163 Account const bob("bob");
1164 Account const sponsor("sponsor");
1165 env.fund(XRP(10000), alice, bob, sponsor);
1166 env.close();
1167
1168 // Test invalid flags for SponsorshipTransfer
1169 {
1170 // Invalid flag is provided
1172 alice,
1173 (tfSponsorshipCreate | tfSponsorshipReassign | tfSponsorshipEnd) + 1),
1175
1176 // No SponsorshipTransfer flag is provided
1177 env(sponsor::transfer(alice, 0), Ter(temINVALID_FLAG));
1178
1179 // Only one of the three valid flags can be set.
1180 // Setting more than one flag is invalid
1181 for (auto const flag : {
1182 tfSponsorshipCreate | tfSponsorshipReassign,
1183 tfSponsorshipCreate | tfSponsorshipEnd,
1184 tfSponsorshipReassign | tfSponsorshipEnd,
1185 tfSponsorshipCreate | tfSponsorshipReassign | tfSponsorshipEnd,
1186 })
1187 env(sponsor::transfer(alice, flag), Ter(temINVALID_FLAG));
1188 }
1189
1190 // Malformed tests for tfSponsorshipCreate
1191 {
1192 // No sponsor field present
1193 env(sponsor::transfer(alice, tfSponsorshipCreate), Ter(temMALFORMED));
1194
1195 // Sponsor field present without spfSponsorReserve
1196 env(sponsor::transfer(alice, tfSponsorshipCreate),
1199
1200 // Sponsee field present
1201 env(sponsor::transfer(alice, tfSponsorshipCreate),
1204 Ter(temMALFORMED));
1205 }
1206
1207 // Malformed tests for tfSponsorshipReassign
1208 {
1209 // No sponsor field present
1210 env(sponsor::transfer(alice, tfSponsorshipReassign), Ter(temMALFORMED));
1211
1212 // Sponsor field present without spfSponsorReserve
1213 env(sponsor::transfer(alice, tfSponsorshipReassign),
1216
1217 // Sponsee field present
1218 env(sponsor::transfer(alice, tfSponsorshipReassign),
1221 Ter(temMALFORMED));
1222 }
1223
1224 // Malformed tests for tfSponsorshipEnd
1225 {
1226 // Sponsor field present
1227 env(sponsor::transfer(alice, tfSponsorshipEnd),
1229 Ter(temMALFORMED));
1230
1231 // SponsorFlags field present
1232 auto tx = sponsor::transfer(alice, tfSponsorshipEnd);
1233 tx[sfSponsorFlags.jsonName] = spfSponsorFee;
1234 env(tx, Ter(temINVALID_FLAG));
1235
1236 // Account = Sponsee
1237 env(sponsor::transfer(alice, tfSponsorshipEnd),
1238 sponsor::SponseeAcc(alice),
1239 Ter(temMALFORMED));
1240 }
1241
1242 // Post-fixCleanup3_5_0, a zero ObjectID is malformed.
1243 // Pre-fixCleanup3_5_0 path is unreachable so it is not testable.
1244 if (features[fixCleanup3_5_0])
1245 {
1246 UInt256 const zeroObjectID{};
1247
1248 env(sponsor::transfer(alice, tfSponsorshipEnd, zeroObjectID), Ter(temMALFORMED));
1249
1250 env(sponsor::transfer(alice, tfSponsorshipCreate, zeroObjectID),
1252 Sig(sfSponsorSignature, sponsor),
1253 Ter(temMALFORMED));
1254
1255 env(sponsor::transfer(alice, tfSponsorshipReassign, zeroObjectID),
1257 Sig(sfSponsorSignature, sponsor),
1258 Ter(temMALFORMED));
1259 }
1260 }
1261
1262 {
1263 // Invalid SponsorshipEnd permission (sponsor object/sponsor account)
1264 Env env{*this, features};
1265 Account const alice("alice");
1266 Account const bob("bob");
1267 Account const charlie("charlie");
1268 Account const sponsor("sponsor");
1269 env.fund(XRP(10000), alice, bob, sponsor);
1270 env.close();
1271
1272 {
1273 // sponsor object
1274 env.fund(XRP(1000), charlie);
1275 env.close();
1276 env(deposit::auth(alice, charlie),
1278 Sig(sfSponsorSignature, sponsor));
1279 env.close();
1280
1281 auto const keylet = keylet::depositPreauth(alice, charlie);
1282 env(sponsor::transfer(bob, tfSponsorshipEnd, keylet.key),
1283 sponsor::SponseeAcc(alice),
1285 }
1286 {
1287 // sponsor object
1288 env(sponsor::transfer(alice, tfSponsorshipCreate),
1290 Sig(sfSponsorSignature, sponsor));
1291 env.close();
1292
1293 env(sponsor::transfer(bob, tfSponsorshipEnd),
1294 sponsor::SponseeAcc(alice),
1296 }
1297 {
1298 // The provided sfSponsee account does not exist
1299 // when ending sponsorship.
1300 Account const ghost("ghost"); // never funded, absent from ledger
1301 env(sponsor::transfer(sponsor, tfSponsorshipEnd),
1302 sponsor::SponseeAcc(ghost),
1304 }
1305 }
1306
1307 {
1308 // sponsor account
1309 Env env{*this, features};
1310 Account const alice("alice");
1311 Account const bob("bob");
1312 Account const sponsor1("sponsor1");
1313 Account const sponsor2("sponsor2");
1314 env.fund(XRP(10000), alice, bob, sponsor1, sponsor2);
1315
1316 // sfSponsor provided but sfSponsorSignature not provided
1317 env(sponsor::transfer(alice, tfSponsorshipCreate),
1318 sponsor::As(sponsor1, spfSponsorReserve),
1319 Ter(temMALFORMED));
1320 env.close();
1321
1322 adjustAccountXRPBalance(env, sponsor1, accountReserve(env, 2) - drops(1));
1323
1324 env(sponsor::transfer(alice, tfSponsorshipCreate),
1325 sponsor::As(sponsor1, spfSponsorReserve),
1326 Sig(sfSponsorSignature, sponsor1),
1328 env.close();
1329
1330 adjustAccountXRPBalance(env, sponsor1, accountReserve(env, 2));
1331
1332 env(sponsor::transfer(alice, tfSponsorshipCreate),
1333 sponsor::As(sponsor1, spfSponsorReserve),
1334 Sig(sfSponsorSignature, sponsor1));
1335 env.close();
1336
1337 BEAST_EXPECT(sponsoredOwnerCount(env, alice) == 0);
1338 BEAST_EXPECT(sponsoredOwnerCount(env, sponsor1) == 0);
1339 BEAST_EXPECT(sponsoringOwnerCount(env, alice) == 0);
1340 BEAST_EXPECT(sponsoringOwnerCount(env, sponsor1) == 0);
1341 BEAST_EXPECT(sponsoringAccountCount(env, alice) == 0);
1342 BEAST_EXPECT(sponsoringAccountCount(env, sponsor1) == 1);
1343 auto const sle1 = env.le(keylet::account(alice));
1344 BEAST_EXPECT(sle1->isFieldPresent(sfSponsor));
1345 BEAST_EXPECT(sle1->getAccountID(sfSponsor) == sponsor1.id());
1346
1347 // transfer sponsor
1348 adjustAccountXRPBalance(env, sponsor2, accountReserve(env, 2) - drops(1));
1349
1350 env(sponsor::transfer(alice, tfSponsorshipReassign),
1351 sponsor::As(sponsor2, spfSponsorReserve),
1352 Sig(sfSponsorSignature, sponsor2),
1354 env.close();
1355
1356 adjustAccountXRPBalance(env, sponsor2, accountReserve(env, 2));
1357
1358 env(sponsor::transfer(alice, tfSponsorshipReassign),
1359 sponsor::As(sponsor2, spfSponsorReserve),
1360 Sig(sfSponsorSignature, sponsor2));
1361 env.close();
1362
1363 BEAST_EXPECT(sponsoredOwnerCount(env, alice) == 0);
1364 BEAST_EXPECT(sponsoredOwnerCount(env, sponsor1) == 0);
1365 BEAST_EXPECT(sponsoredOwnerCount(env, sponsor2) == 0);
1366 BEAST_EXPECT(sponsoringOwnerCount(env, alice) == 0);
1367 BEAST_EXPECT(sponsoringOwnerCount(env, sponsor1) == 0);
1368 BEAST_EXPECT(sponsoringOwnerCount(env, sponsor2) == 0);
1369 BEAST_EXPECT(sponsoringAccountCount(env, alice) == 0);
1370 BEAST_EXPECT(sponsoringAccountCount(env, sponsor1) == 0);
1371 BEAST_EXPECT(sponsoringAccountCount(env, sponsor2) == 1);
1372 BEAST_EXPECT(
1373 !env.le(keylet::account(sponsor1))->isFieldPresent(sfSponsoringAccountCount));
1374 auto const sle2 = env.le(keylet::account(alice));
1375 BEAST_EXPECT(sle2->isFieldPresent(sfSponsor));
1376 BEAST_EXPECT(sle2->getAccountID(sfSponsor) == sponsor2.id());
1377
1378 // Reassign to the current sponsor is a no-op and is rejected
1379 env(sponsor::transfer(alice, tfSponsorshipReassign),
1380 sponsor::As(sponsor2, spfSponsorReserve),
1381 Sig(sfSponsorSignature, sponsor2),
1383 env.close();
1384
1385 BEAST_EXPECT(sponsoringAccountCount(env, sponsor2) == 1);
1386
1387 // sponsor 2 accounts
1388 adjustAccountXRPBalance(env, sponsor2, accountReserve(env, 3));
1389 env(sponsor::transfer(bob, tfSponsorshipCreate),
1390 sponsor::As(sponsor2, spfSponsorReserve),
1391 Sig(sfSponsorSignature, sponsor2));
1392 env.close();
1393
1394 // dissolve sponsors
1395 adjustAccountXRPBalance(env, alice, accountReserve(env, 1) - drops(1));
1396
1397 env(sponsor::transfer(alice, tfSponsorshipEnd), Ter(tecINSUFFICIENT_RESERVE));
1398 env.close();
1399
1400 adjustAccountXRPBalance(env, alice, accountReserve(env, 1));
1401
1402 env(sponsor::transfer(alice, tfSponsorshipEnd));
1403 env.close();
1404
1405 BEAST_EXPECT(sponsoredOwnerCount(env, alice) == 0);
1406 BEAST_EXPECT(sponsoredOwnerCount(env, sponsor1) == 0);
1407 BEAST_EXPECT(sponsoredOwnerCount(env, sponsor2) == 0);
1408 BEAST_EXPECT(sponsoringOwnerCount(env, alice) == 0);
1409 BEAST_EXPECT(sponsoringOwnerCount(env, sponsor1) == 0);
1410 BEAST_EXPECT(sponsoringOwnerCount(env, sponsor2) == 0);
1411 BEAST_EXPECT(sponsoringAccountCount(env, alice) == 0);
1412 BEAST_EXPECT(sponsoringAccountCount(env, sponsor1) == 0);
1413 BEAST_EXPECT(sponsoringAccountCount(env, sponsor2) == 1);
1414 auto const sle3 = env.le(keylet::account(alice));
1415 BEAST_EXPECT(!sle3->isFieldPresent(sfSponsor));
1416
1417 env(sponsor::transfer(bob, tfSponsorshipEnd));
1418 env.close();
1419
1420 BEAST_EXPECT(sponsoredOwnerCount(env, bob) == 0);
1421 BEAST_EXPECT(sponsoredOwnerCount(env, sponsor1) == 0);
1422 BEAST_EXPECT(sponsoredOwnerCount(env, sponsor2) == 0);
1423 BEAST_EXPECT(sponsoringOwnerCount(env, bob) == 0);
1424 BEAST_EXPECT(sponsoringOwnerCount(env, sponsor1) == 0);
1425 BEAST_EXPECT(sponsoringOwnerCount(env, sponsor2) == 0);
1426 BEAST_EXPECT(sponsoringAccountCount(env, bob) == 0);
1427 BEAST_EXPECT(sponsoringAccountCount(env, sponsor1) == 0);
1428 BEAST_EXPECT(sponsoringAccountCount(env, sponsor2) == 0);
1429 BEAST_EXPECT(
1430 !env.le(keylet::account(sponsor2))->isFieldPresent(sfSponsoringAccountCount));
1431 auto const sle4 = env.le(keylet::account(bob));
1432 BEAST_EXPECT(!sle4->isFieldPresent(sfSponsor));
1433
1434 // not sponsored
1435 env(sponsor::transfer(bob, tfSponsorshipEnd), Ter(tecNO_PERMISSION));
1436 env.close();
1437 }
1438 {
1439 // dissolve account sponsorship from sponsor
1440 Env env{*this, features};
1441 Account const alice("alice");
1442 Account const bob("bob");
1443 Account const sponsor("sponsor");
1444 env.fund(XRP(10000), alice, bob, sponsor);
1445 env.close();
1446
1447 env(sponsor::transfer(alice, tfSponsorshipCreate),
1449 Sig(sfSponsorSignature, sponsor));
1450 env.close();
1451
1452 BEAST_EXPECT(env.le(alice)->getAccountID(sfSponsor) == sponsor.id());
1453 BEAST_EXPECT(sponsoringAccountCount(env, sponsor) == 1);
1454
1455 env(sponsor::transfer(sponsor, tfSponsorshipEnd), sponsor::SponseeAcc(alice));
1456 env.close();
1457
1458 BEAST_EXPECT(!env.le(alice)->isFieldPresent(sfSponsor));
1459 BEAST_EXPECT(sponsoringAccountCount(env, sponsor) == 0);
1460 }
1461
1462 {
1463 // sponsor object (co-signing)
1464 Env env{*this, features};
1465 Account const alice("alice");
1466 Account const bob("bob");
1467 Account const sponsor1("sponsor1");
1468 Account const sponsor2("sponsor2");
1469 env.fund(XRP(10000), alice, bob, sponsor1, sponsor2);
1470 env.close();
1471
1472 adjustAccountXRPBalance(env, sponsor1, reserve(env, 1) - drops(1));
1473 adjustAccountXRPBalance(env, sponsor2, reserve(env, 1) - drops(1));
1474
1475 auto const seq = env.seq(alice);
1476 env(check::create(alice, bob, XRP(1)));
1477 env.close();
1478
1479 auto const checkId = keylet::check(alice, SeqProxy::rawSequence(seq)).key;
1480 BEAST_EXPECT(env.le(keylet::unchecked(checkId)) != nullptr);
1481
1482 env(sponsor::transfer(alice, tfSponsorshipCreate, checkId),
1483 sponsor::As(sponsor1, spfSponsorReserve),
1484 Sig(sfSponsorSignature, sponsor1),
1486 env.close();
1487
1488 env(pay(alice, sponsor1, drops(1)));
1489 env.close();
1490
1491 // Invalid ObjectID (not found)
1493 alice, tfSponsorshipCreate, keylet::check(alice, SeqProxy::rawSequence(0)).key),
1494 sponsor::As(sponsor1, spfSponsorReserve),
1495 Sig(sfSponsorSignature, sponsor1),
1496 Ter(tecNO_ENTRY));
1497 env.close();
1498
1499 // Invalid Owner
1500 env(sponsor::transfer(bob, tfSponsorshipCreate, checkId),
1501 sponsor::As(sponsor1, spfSponsorReserve),
1502 Sig(sfSponsorSignature, sponsor1),
1504 env.close();
1505
1506 // Reassign an object that is not sponsored yet
1507 env(sponsor::transfer(alice, tfSponsorshipReassign, checkId),
1508 sponsor::As(sponsor1, spfSponsorReserve),
1509 Sig(sfSponsorSignature, sponsor1),
1511 env.close();
1512
1513 // Valid Owner
1514 env(sponsor::transfer(alice, tfSponsorshipCreate, checkId),
1515 sponsor::As(sponsor1, spfSponsorReserve),
1516 Sig(sfSponsorSignature, sponsor1));
1517 env.close();
1518
1519 BEAST_EXPECT(ownerCount(env, alice) == 1);
1520 BEAST_EXPECT(sponsoredOwnerCount(env, alice) == 1);
1521 BEAST_EXPECT(sponsoredOwnerCount(env, sponsor1) == 0);
1522 BEAST_EXPECT(sponsoringOwnerCount(env, alice) == 0);
1523 BEAST_EXPECT(sponsoringOwnerCount(env, sponsor1) == 1);
1524 BEAST_EXPECT(sponsoringAccountCount(env, alice) == 0);
1525 BEAST_EXPECT(sponsoringAccountCount(env, sponsor1) == 0);
1526 auto const sle1 = env.le(keylet::unchecked(checkId));
1527 BEAST_EXPECT(sle1->isFieldPresent(sfSponsor));
1528 BEAST_EXPECT(sle1->getAccountID(sfSponsor) == sponsor1.id());
1529
1530 // Create on an object that is already sponsored
1531 env(sponsor::transfer(alice, tfSponsorshipCreate, checkId),
1532 sponsor::As(sponsor2, spfSponsorReserve),
1533 Sig(sfSponsorSignature, sponsor2),
1535 env.close();
1536
1537 // Reassign to the current sponsor is a no-op and is rejected
1538 env(sponsor::transfer(alice, tfSponsorshipReassign, checkId),
1539 sponsor::As(sponsor1, spfSponsorReserve),
1540 Sig(sfSponsorSignature, sponsor1),
1542 env.close();
1543
1544 BEAST_EXPECT(sponsoringOwnerCount(env, sponsor1) == 1);
1545
1546 // transfer sponsor
1547 env(sponsor::transfer(alice, tfSponsorshipReassign, checkId),
1548 sponsor::As(sponsor2, spfSponsorReserve),
1549 Sig(sfSponsorSignature, sponsor2),
1551
1552 env(pay(alice, sponsor2, drops(1)));
1553 env.close();
1554
1555 env(sponsor::transfer(alice, tfSponsorshipReassign, checkId),
1556 sponsor::As(sponsor2, spfSponsorReserve),
1557 Sig(sfSponsorSignature, sponsor2));
1558 env.close();
1559
1560 BEAST_EXPECT(sponsoredOwnerCount(env, alice) == 1);
1561 BEAST_EXPECT(sponsoredOwnerCount(env, sponsor1) == 0);
1562 BEAST_EXPECT(sponsoredOwnerCount(env, sponsor2) == 0);
1563 BEAST_EXPECT(sponsoringOwnerCount(env, alice) == 0);
1564 BEAST_EXPECT(sponsoringOwnerCount(env, sponsor1) == 0);
1565 BEAST_EXPECT(sponsoringOwnerCount(env, sponsor2) == 1);
1566 BEAST_EXPECT(sponsoringAccountCount(env, alice) == 0);
1567 BEAST_EXPECT(sponsoringAccountCount(env, sponsor1) == 0);
1568 BEAST_EXPECT(sponsoringAccountCount(env, sponsor2) == 0);
1569 auto const sle2 = env.le(keylet::unchecked(checkId));
1570 BEAST_EXPECT(sle2->isFieldPresent(sfSponsor));
1571 BEAST_EXPECT(sle2->getAccountID(sfSponsor) == sponsor2.id());
1572
1573 // dissolve sponsor: ending an object sponsorship now (fixCleanup3_4_0) requires the
1574 // sponsee to be able to self-fund the object's reserve.
1575 adjustAccountXRPBalance(env, alice, reserve(env, 1) - drops(1));
1576
1577 if (features[fixCleanup3_4_0])
1578 {
1579 // Under-funded: End is rejected until alice can self-fund.
1580 env(sponsor::transfer(alice, tfSponsorshipEnd, checkId),
1582 env.close();
1583
1584 adjustAccountXRPBalance(env, alice, reserve(env, 1));
1585 }
1586
1587 env(sponsor::transfer(alice, tfSponsorshipEnd, checkId));
1588 env.close();
1589
1590 BEAST_EXPECT(sponsoredOwnerCount(env, alice) == 0);
1591 BEAST_EXPECT(sponsoredOwnerCount(env, sponsor1) == 0);
1592 BEAST_EXPECT(sponsoredOwnerCount(env, sponsor2) == 0);
1593 BEAST_EXPECT(sponsoringOwnerCount(env, alice) == 0);
1594 BEAST_EXPECT(sponsoringOwnerCount(env, sponsor1) == 0);
1595 BEAST_EXPECT(sponsoringOwnerCount(env, sponsor2) == 0);
1596 BEAST_EXPECT(sponsoringAccountCount(env, alice) == 0);
1597 BEAST_EXPECT(sponsoringAccountCount(env, sponsor1) == 0);
1598 BEAST_EXPECT(sponsoringAccountCount(env, sponsor2) == 0);
1599 BEAST_EXPECT(
1600 !env.le(keylet::account(sponsor2))->isFieldPresent(sfSponsoringOwnerCount));
1601 auto const sle3 = env.le(keylet::unchecked(checkId));
1602 BEAST_EXPECT(!sle3->isFieldPresent(sfSponsor));
1603
1604 // Ending sponsorship on an object that is not sponsored (a ticket,
1605 // which cannot be sponsored) is rejected.
1606 adjustAccountXRPBalance(env, alice, reserve(env, 2));
1607 auto const ticketSeq = env.seq(alice);
1608 env(ticket::create(alice, 1));
1609 env.close();
1610 auto ticketId = keylet::ticket(alice, SeqProxy::rawTicket(ticketSeq + 1)).key;
1611 BEAST_EXPECT(env.le(keylet::unchecked(ticketId)));
1612 env(sponsor::transfer(alice, tfSponsorshipEnd, ticketId), Ter(tecNO_PERMISSION));
1613 env.close();
1614 env(noop(alice), ticket::Use(ticketSeq + 1));
1615 env.close();
1616 }
1617 {
1618 // sponsor object (pre-funded + no ltSponsorship entry)
1619 Env env{*this, features};
1620 Account const alice("alice");
1621 Account const bob("bob");
1622 Account const sponsor1("sponsor1");
1623 Account const sponsor2("sponsor2");
1624 env.fund(XRP(10000), alice, bob, sponsor1, sponsor2);
1625 env.close();
1626
1627 auto const seq = env.seq(alice);
1628 env(check::create(alice, bob, XRP(1)));
1629 env.close();
1630
1631 auto const checkId = keylet::check(alice, SeqProxy::rawSequence(seq)).key;
1632 BEAST_EXPECT(env.le(keylet::unchecked(checkId)) != nullptr);
1633
1634 env(sponsor::transfer(alice, tfSponsorshipCreate, checkId),
1635 sponsor::As(sponsor1, spfSponsorReserve),
1637 env.close();
1638
1639 env(sponsor::set_reserve(sponsor2, 0, 1), sponsor::SponseeAcc(alice));
1640 env.close();
1641
1642 env(sponsor::transfer(alice, tfSponsorshipCreate, checkId),
1643 sponsor::As(sponsor2, spfSponsorReserve));
1644 env.close();
1645
1646 env(sponsor::transfer(alice, tfSponsorshipReassign, checkId),
1647 sponsor::As(sponsor1, spfSponsorReserve),
1649 env.close();
1650 }
1651 {
1652 // sponsor object (pre-funded)
1653 Env env{*this, features};
1654 Account const alice("alice");
1655 Account const bob("bob");
1656 Account const sponsor1("sponsor1");
1657 Account const sponsor2("sponsor2");
1658 env.fund(XRP(10000), alice, bob, sponsor1, sponsor2);
1659 env.close();
1660
1661 auto const seq = env.seq(alice);
1662 env(check::create(alice, bob, XRP(1)));
1663 env.close();
1664
1665 auto const checkId = keylet::check(alice, SeqProxy::rawSequence(seq)).key;
1666 BEAST_EXPECT(env.le(keylet::unchecked(checkId)) != nullptr);
1667
1668 // insufficient reserve count
1669 env(sponsor::set_fee(sponsor1, 0, XRP(100)), sponsor::SponseeAcc(alice));
1670 env.close();
1671 env(sponsor::transfer(alice, tfSponsorshipCreate, checkId),
1672 sponsor::As(sponsor1, spfSponsorReserve),
1674 env.close();
1675
1676 env(sponsor::set_reserve(sponsor1, 0, 100), sponsor::SponseeAcc(alice));
1677 env.close();
1678
1679 env(sponsor::transfer(alice, tfSponsorshipCreate, checkId),
1680 sponsor::As(sponsor1, spfSponsorReserve));
1681 env.close();
1682
1683 BEAST_EXPECT(ownerCount(env, alice) == 1);
1684 BEAST_EXPECT(sponsoredOwnerCount(env, alice) == 1);
1685 BEAST_EXPECT(sponsoredOwnerCount(env, sponsor1) == 0);
1686 BEAST_EXPECT(sponsoringOwnerCount(env, alice) == 0);
1687 BEAST_EXPECT(sponsoringOwnerCount(env, sponsor1) == 1);
1688 BEAST_EXPECT(sponsoringAccountCount(env, alice) == 0);
1689 BEAST_EXPECT(sponsoringAccountCount(env, sponsor1) == 0);
1690 auto checkSle = env.le(keylet::unchecked(checkId));
1691 BEAST_EXPECT(checkSle->isFieldPresent(sfSponsor));
1692 BEAST_EXPECT(checkSle->getAccountID(sfSponsor) == sponsor1.id());
1693 auto sponsor1Sle = env.le(keylet::sponsorship(sponsor1, alice));
1694 BEAST_EXPECT(sponsor1Sle->getFieldU32(sfRemainingOwnerCount) == 99);
1695
1696 // Reassign to the current sponsor is rejected and must not draw
1697 // down the pre-funded reserve budget
1698 env(sponsor::transfer(alice, tfSponsorshipReassign, checkId),
1699 sponsor::As(sponsor1, spfSponsorReserve),
1701 env.close();
1702
1703 sponsor1Sle = env.le(keylet::sponsorship(sponsor1, alice));
1704 BEAST_EXPECT(sponsor1Sle->getFieldU32(sfRemainingOwnerCount) == 99);
1705 BEAST_EXPECT(sponsoringOwnerCount(env, sponsor1) == 1);
1706
1707 // transfer sponsor
1708 env(sponsor::set_reserve(sponsor2, 0, 100), sponsor::SponseeAcc(alice));
1709 env.close();
1710
1711 env(sponsor::transfer(alice, tfSponsorshipReassign, checkId),
1712 sponsor::As(sponsor2, spfSponsorReserve));
1713 env.close();
1714
1715 BEAST_EXPECT(sponsoredOwnerCount(env, alice) == 1);
1716 BEAST_EXPECT(sponsoredOwnerCount(env, sponsor1) == 0);
1717 BEAST_EXPECT(sponsoredOwnerCount(env, sponsor2) == 0);
1718 BEAST_EXPECT(sponsoringOwnerCount(env, alice) == 0);
1719 BEAST_EXPECT(sponsoringOwnerCount(env, sponsor1) == 0);
1720 BEAST_EXPECT(sponsoringOwnerCount(env, sponsor2) == 1);
1721 BEAST_EXPECT(sponsoringAccountCount(env, alice) == 0);
1722 BEAST_EXPECT(sponsoringAccountCount(env, sponsor1) == 0);
1723 BEAST_EXPECT(sponsoringAccountCount(env, sponsor2) == 0);
1724 checkSle = env.le(keylet::unchecked(checkId));
1725 BEAST_EXPECT(checkSle->isFieldPresent(sfSponsor));
1726 BEAST_EXPECT(checkSle->getAccountID(sfSponsor) == sponsor2.id());
1727 sponsor1Sle = env.le(keylet::sponsorship(sponsor1, alice));
1728 BEAST_EXPECT(sponsor1Sle->getFieldU32(sfRemainingOwnerCount) == 99);
1729 auto sponsor2Sle = env.le(keylet::sponsorship(sponsor2, alice));
1730 BEAST_EXPECT(sponsor2Sle->getFieldU32(sfRemainingOwnerCount) == 99);
1731
1732 // dissolve sponsor
1733 adjustAccountXRPBalance(env, alice, reserve(env, 1));
1734 env(sponsor::transfer(alice, tfSponsorshipEnd, checkId));
1735 env.close();
1736
1737 BEAST_EXPECT(sponsoredOwnerCount(env, alice) == 0);
1738 BEAST_EXPECT(sponsoredOwnerCount(env, sponsor1) == 0);
1739 BEAST_EXPECT(sponsoredOwnerCount(env, sponsor2) == 0);
1740 BEAST_EXPECT(sponsoringOwnerCount(env, alice) == 0);
1741 BEAST_EXPECT(sponsoringOwnerCount(env, sponsor1) == 0);
1742 BEAST_EXPECT(sponsoringOwnerCount(env, sponsor2) == 0);
1743 BEAST_EXPECT(sponsoringAccountCount(env, alice) == 0);
1744 BEAST_EXPECT(sponsoringAccountCount(env, sponsor1) == 0);
1745 BEAST_EXPECT(sponsoringAccountCount(env, sponsor2) == 0);
1746 BEAST_EXPECT(
1747 !env.le(keylet::account(sponsor2))->isFieldPresent(sfSponsoringOwnerCount));
1748 checkSle = env.le(keylet::unchecked(checkId));
1749 BEAST_EXPECT(!checkSle->isFieldPresent(sfSponsor));
1750 sponsor2Sle = env.le(keylet::sponsorship(sponsor2, alice));
1751 BEAST_EXPECT(sponsor2Sle->getFieldU32(sfRemainingOwnerCount) == 99);
1752 }
1753
1754 {
1755 // Dissolve object sponsorship from sponsor(no-ltSponsorship)
1756 Env env{*this, features};
1757 Account const alice("alice");
1758 Account const bob("bob");
1759 Account const sponsor("sponsor");
1760 env.fund(XRP(10000), alice, bob, sponsor);
1761 env.close();
1762
1763 auto const seq = env.seq(alice);
1764 env(check::create(alice, bob, XRP(1)));
1765 env.close();
1766
1767 auto const checkId = keylet::check(alice, SeqProxy::rawSequence(seq)).key;
1768 BEAST_EXPECT(env.le(keylet::unchecked(checkId)) != nullptr);
1769
1770 env(sponsor::transfer(alice, tfSponsorshipCreate, checkId),
1772 Sig(sfSponsorSignature, sponsor));
1773 env.close();
1774
1775 BEAST_EXPECT(
1776 env.le(keylet::unchecked(checkId))->getAccountID(sfSponsor) == sponsor.id());
1777 BEAST_EXPECT(ownerCount(env, alice) == 1);
1778 BEAST_EXPECT(sponsoredOwnerCount(env, alice) == 1);
1779 BEAST_EXPECT(sponsoringOwnerCount(env, sponsor) == 1);
1780
1781 // not the owner of the object
1782 env(sponsor::transfer(sponsor, tfSponsorshipEnd, checkId), Ter(tecNO_PERMISSION));
1783 env.close();
1784
1785 env(sponsor::transfer(sponsor, tfSponsorshipEnd, checkId), sponsor::SponseeAcc(alice));
1786 env.close();
1787
1788 BEAST_EXPECT(!env.le(keylet::unchecked(checkId))->isFieldPresent(sfSponsor));
1789 BEAST_EXPECT(ownerCount(env, alice) == 1);
1790 BEAST_EXPECT(sponsoredOwnerCount(env, alice) == 0);
1791 BEAST_EXPECT(sponsoringOwnerCount(env, sponsor) == 0);
1792 }
1793
1794 {
1795 // Dissolve object sponsorship from sponsor (with ltSponsorship)
1796 Env env{*this, features};
1797 Account const alice("alice");
1798 Account const bob("bob");
1799 Account const sponsor("sponsor");
1800 env.fund(XRP(10000), alice, bob, sponsor);
1801 env.close();
1802
1803 auto const seq = env.seq(alice);
1804 env(check::create(alice, bob, XRP(1)));
1805 env.close();
1806
1807 auto const checkId = keylet::check(alice, SeqProxy::rawSequence(seq)).key;
1808 BEAST_EXPECT(env.le(keylet::unchecked(checkId)) != nullptr);
1809
1810 env(sponsor::transfer(alice, tfSponsorshipCreate, checkId),
1812 Sig(sfSponsorSignature, sponsor));
1813 env.close();
1814
1815 env(sponsor::set_reserve(sponsor, 0, 100), sponsor::SponseeAcc(alice));
1816 env.close();
1817
1818 BEAST_EXPECT(
1819 env.le(keylet::unchecked(checkId))->getAccountID(sfSponsor) == sponsor.id());
1820 BEAST_EXPECT(ownerCount(env, alice) == 1);
1821 BEAST_EXPECT(sponsoredOwnerCount(env, alice) == 1);
1822 BEAST_EXPECT(sponsoringOwnerCount(env, sponsor) == 1);
1823 BEAST_EXPECT(
1824 env.le(keylet::sponsorship(sponsor, alice))->getFieldU32(sfRemainingOwnerCount) ==
1825 100);
1826
1827 // not the owner of the object
1828 env(sponsor::transfer(sponsor, tfSponsorshipEnd, checkId), Ter(tecNO_PERMISSION));
1829 env.close();
1830
1831 env(sponsor::transfer(sponsor, tfSponsorshipEnd, checkId), sponsor::SponseeAcc(alice));
1832 env.close();
1833
1834 BEAST_EXPECT(!env.le(keylet::unchecked(checkId))->isFieldPresent(sfSponsor));
1835 BEAST_EXPECT(ownerCount(env, alice) == 1);
1836 BEAST_EXPECT(sponsoredOwnerCount(env, alice) == 0);
1837 BEAST_EXPECT(sponsoringOwnerCount(env, sponsor) == 0);
1838 BEAST_EXPECT(
1839 env.le(keylet::sponsorship(sponsor, alice))->getFieldU32(sfRemainingOwnerCount) ==
1840 100);
1841 }
1842
1843 {
1844 // sponsor trustline
1845 Account const alice("alice");
1846 Account const bob("bob");
1847 Account const sponsor("sponsor");
1848
1849 auto const& highAcc = alice > bob ? alice : bob;
1850 auto const& lowAcc = alice > bob ? bob : alice;
1851
1852 for (bool const isIssuerHigh : {false, true})
1853 {
1854 Env env{*this, features};
1855 env.fund(XRP(10000), alice, bob, sponsor);
1856 env.close();
1857
1858 auto const& issuer = isIssuerHigh ? highAcc : lowAcc;
1859 auto const& user = isIssuerHigh ? lowAcc : highAcc;
1860
1861 auto const usd = issuer["usd"];
1862 auto const currency = usd.currency;
1863
1864 env(trust(user, issuer["usd"](100)));
1865 env.close();
1866
1867 auto const trustId = keylet::trustLine(user, issuer, currency);
1868 BEAST_EXPECT(env.le(trustId));
1869
1870 // transfer sponsor
1871 env(sponsor::transfer(user, tfSponsorshipCreate, trustId.key),
1873 Sig(sfSponsorSignature, sponsor));
1874 env.close();
1875
1876 BEAST_EXPECT(env.le(trustId));
1877
1878 BEAST_EXPECT(
1879 env.le(trustId)->getAccountID(isIssuerHigh ? sfLowSponsor : sfHighSponsor) ==
1880 sponsor.id());
1881 BEAST_EXPECT(
1882 !env.le(trustId)->isFieldPresent(isIssuerHigh ? sfHighSponsor : sfLowSponsor));
1883
1884 // dissolve sponsor
1885 env(sponsor::transfer(user, tfSponsorshipEnd, trustId.key));
1886 env.close();
1887
1888 BEAST_EXPECT(env.le(trustId));
1889 BEAST_EXPECT(
1890 !env.le(trustId)->isFieldPresent(isIssuerHigh ? sfLowSponsor : sfHighSponsor));
1891 BEAST_EXPECT(
1892 !env.le(trustId)->isFieldPresent(isIssuerHigh ? sfHighSponsor : sfLowSponsor));
1893 }
1894 }
1895
1896 {
1897 // invalid transfer
1898 Env env{*this, features};
1899 Account const alice("alice");
1900 Account const bob("bob");
1901 Account const sponsor("sponsor");
1902 env.fund(XRP(10000), alice, bob, sponsor);
1903 env.close();
1904
1905 // create owner dir
1906 env(ticket::create(alice, 1));
1907 env.close();
1908
1909 // AccountRoot
1910 // Amendments
1911 // LedgerHashes
1912 // FeeSettings
1913 // NegativeUNL
1914 // DirNode
1915 auto const keylets = {
1916 keylet::account(alice),
1917 // keylet::amendments(),
1918 keylet::skip(),
1920 // keylet::negativeUNL(),
1921 keylet::ownerDir(alice),
1922 };
1923 for (auto const& keylet : keylets)
1924 {
1925 env(sponsor::transfer(alice, tfSponsorshipCreate, keylet.key),
1927 Sig(sfSponsorSignature, sponsor),
1929 }
1930 }
1931
1932 {
1933 // existing owner objects that are outside the v1 SponsorshipTransfer
1934 // object allow-list
1935 Env env{*this, features};
1936 Account const alice("alice");
1937 Account const sponsor("sponsor");
1938 env.fund(XRP(10000), alice, sponsor);
1939 env.close();
1940
1941 auto const checkBlocked = [&](Account const& account, UInt256 const& objectID) {
1942 env(sponsor::transfer(account, tfSponsorshipCreate, objectID),
1944 Sig(sfSponsorSignature, sponsor),
1946 env.close();
1947 };
1948
1949 auto const ticketSeq = env.seq(alice);
1950 env(ticket::create(alice, 1));
1951 env.close();
1952 auto const ticketID = keylet::ticket(alice, SeqProxy::rawTicket(ticketSeq + 1)).key;
1953 BEAST_EXPECT(env.le(keylet::unchecked(ticketID)));
1954 checkBlocked(alice, ticketID);
1955
1956 env(did::setValid(alice));
1957 env.close();
1958 auto const didKeylet = keylet::did(alice.id());
1959 BEAST_EXPECT(env.le(didKeylet));
1960 checkBlocked(alice, didKeylet.key);
1961
1962 env(token::mint(alice, 0u));
1963 env.close();
1964 auto const nftPageKeylet = keylet::nftokenPageMax(alice);
1965 BEAST_EXPECT(env.le(nftPageKeylet));
1966 checkBlocked(alice, nftPageKeylet.key);
1967
1968 Account const borrower("borrower");
1969 env.fund(XRP(1000000), borrower);
1970 env.close();
1971
1972 PrettyAsset const xrpAsset{xrpIssue(), 1'000'000};
1973 Vault const vault{env};
1974 // Under featureLendingProtocolV1_1 LoanBrokerSet::preclaim only
1975 // accepts closed-ended vaults; build one and advance past
1976 // SubscriptionDate before creating a loan.
1977 auto [vaultTx, vaultKeylet, subscriptionDate] =
1978 vault.createClosedEnded({.owner = alice, .asset = xrpAsset});
1979 env(vaultTx);
1980 env.close();
1981
1982 env(vault.deposit(
1983 {.depositor = alice, .id = vaultKeylet.key, .amount = xrpAsset(1000)}));
1984 env.close();
1985
1986 vault.closePastSubscription(subscriptionDate);
1987
1988 auto const brokerKeylet =
1989 keylet::loanBroker(alice.id(), SeqProxy::rawSequence(env.seq(alice)));
1990 env(loan_broker::set(alice, vaultKeylet.key),
1991 loan_broker::kDebtMaximum(xrpAsset(1000).value()),
1995 env.close();
1996
1997 auto const loanKeylet = keylet::loan(brokerKeylet.key, SeqProxy::rawSequence(1));
1998 env(loan::set(borrower, brokerKeylet.key, xrpAsset(100).value()),
1999 Sig(sfCounterpartySignature, alice),
2000 Fee(env.current()->fees().base * 2));
2001 env.close();
2002 BEAST_EXPECT(env.le(loanKeylet));
2003 checkBlocked(borrower, loanKeylet.key);
2004 }
2005 }
2006
2007 void
2009 {
2010 using namespace test::jtx;
2011
2012 testcase("Sponsor Fee");
2013
2014 {
2015 // co-signing
2016 Env env{*this, testableAmendments()};
2017 Account const alice("alice");
2018 Account const bob("bob");
2019 Account const sponsor("sponsor");
2020 env.fund(XRP(10000), alice, bob);
2021 env.close();
2022
2023 {
2024 // Fee should be checked before sponsor permission, otherwise a tec
2025 // result from a later check could cause context reset to pay Fee.
2026 auto const aliceBalance = env.balance(alice);
2027 auto const bobBalance = env.balance(bob);
2028 auto const sponsorBalance = env.balance(sponsor);
2029
2030 env(pay(alice, bob, XRP(100)),
2031 Fee(XRP(2000)),
2033 Sig(sfSponsorSignature, sponsor),
2035 env.close();
2036 BEAST_EXPECT(env.balance(alice) == aliceBalance);
2037 BEAST_EXPECT(env.balance(bob) == bobBalance);
2038 BEAST_EXPECT(env.balance(sponsor) == sponsorBalance);
2039 }
2040
2041 env.fund(XRP(1000), sponsor);
2042 env.close();
2043
2044 {
2045 // Sponsor pays the Fee
2046 auto const aliceBalance = env.balance(alice);
2047 auto const bobBalance = env.balance(bob);
2048 auto const sponsorBalance = env.balance(sponsor);
2049
2050 auto const sendAmt = XRP(100);
2051 auto const feeAmt = XRP(10);
2052 env(pay(alice, bob, sendAmt),
2053 Fee(feeAmt),
2055 Sig(sfSponsorSignature, sponsor));
2056 env.close();
2057 BEAST_EXPECT(env.balance(alice) == aliceBalance - sendAmt);
2058 BEAST_EXPECT(env.balance(bob) == bobBalance + sendAmt);
2059 BEAST_EXPECT(env.balance(sponsor) == sponsorBalance - feeAmt);
2060 }
2061
2062 {
2063 // insufficient balance to pay Fee
2064 auto const aliceBalance = env.balance(alice);
2065 auto const bobBalance = env.balance(bob);
2066 auto const sponsorBalance = env.balance(sponsor);
2067
2068 env(pay(alice, bob, XRP(100)),
2069 Fee(XRP(2000)),
2071 Sig(sfSponsorSignature, sponsor),
2073 env.close();
2074 BEAST_EXPECT(env.balance(alice) == aliceBalance);
2075 BEAST_EXPECT(env.balance(bob) == bobBalance);
2076 BEAST_EXPECT(env.balance(sponsor) == sponsorBalance);
2077 }
2078
2079 {
2080 // Fee is paid by Sponsor
2081 // on context reset (tec error)
2082 auto const aliceBalance = env.balance(alice);
2083 auto const bobBalance = env.balance(bob);
2084 auto const sponsorBalance = env.balance(sponsor);
2085 auto const feeAmt = XRP(10);
2086
2087 env(pay(alice, bob, XRP(20000)),
2088 Fee(feeAmt),
2090 Sig(sfSponsorSignature, sponsor),
2092 env.close();
2093
2094 BEAST_EXPECT(env.balance(alice) == aliceBalance);
2095 BEAST_EXPECT(env.balance(bob) == bobBalance);
2096 BEAST_EXPECT(env.balance(sponsor) == sponsorBalance - feeAmt);
2097 }
2098
2099 {
2100 // A co-signed sponsor pays the fee from its own balance, but
2101 // must never be charged into its own account reserve. With a
2102 // balance of exactly reserve + fee the fee is still payable,
2103 // charging the sponsor down to precisely its reserve.
2104 auto const feeAmt = XRP(10);
2105 adjustAccountXRPBalance(env, sponsor, reserve(env, 0) + feeAmt);
2106 auto const sponsorBalance = env.balance(sponsor);
2107
2108 env(noop(alice),
2109 Fee(feeAmt),
2111 Sig(sfSponsorSignature, sponsor),
2112 Ter(tesSUCCESS));
2113 env.close();
2114
2115 BEAST_EXPECT(env.balance(sponsor) == sponsorBalance - feeAmt);
2116 BEAST_EXPECT(env.balance(sponsor) == reserve(env, 0));
2117 }
2118
2119 {
2120 // below reserve
2121 adjustAccountXRPBalance(env, sponsor, env.current()->fees().reserve);
2122
2123 env(noop(alice),
2124 Fee(env.current()->fees().base),
2126 Sig(sfSponsorSignature, sponsor),
2128 env.close();
2129
2130 env(noop(alice),
2131 Fee(XRP(10)),
2133 Sig(sfSponsorSignature, sponsor),
2135 env.close();
2136 }
2137 }
2138
2139 {
2140 // pre funded
2141 Env env{*this, testableAmendments()};
2142 Account const alice("alice");
2143 Account const bob("bob");
2144 Account const sponsor("sponsor");
2145 env.fund(XRP(10000), alice, bob, sponsor);
2146 env.close();
2147
2148 {
2149 // Fee should be checked before sponsor permission, otherwise a tec
2150 // result from a later check could cause context reset to pay Fee.
2151 auto const aliceBalance = env.balance(alice);
2152 auto const bobBalance = env.balance(bob);
2153 auto const sponsorBalance = env.balance(sponsor);
2154
2155 env(pay(alice, bob, XRP(100)),
2156 Fee(XRP(2000)),
2159 env.close();
2160 BEAST_EXPECT(env.balance(alice) == aliceBalance);
2161 BEAST_EXPECT(env.balance(bob) == bobBalance);
2162 BEAST_EXPECT(env.balance(sponsor) == sponsorBalance);
2163 }
2164
2165 env(sponsor::set_fee(sponsor, 0, XRP(100)), sponsor::SponseeAcc(alice));
2166 env.close();
2167
2168 {
2169 // Sponsor pays the Fee
2170 auto const aliceBalance = env.balance(alice);
2171 auto const bobBalance = env.balance(bob);
2172 auto const sponsorBalance = env.balance(sponsor);
2173 auto const sponsorFee = sponsor::sponsorshipFeeBalance(env, sponsor, alice);
2174
2175 auto const sendAmt = XRP(100);
2176 auto const feeAmt = XRP(10);
2177 env(pay(alice, bob, sendAmt), Fee(feeAmt), sponsor::As(sponsor, spfSponsorFee));
2178 env.close();
2179
2180 BEAST_EXPECT(env.balance(alice) == aliceBalance - sendAmt);
2181 BEAST_EXPECT(env.balance(bob) == bobBalance + sendAmt);
2182 BEAST_EXPECT(env.balance(sponsor) == sponsorBalance);
2183 BEAST_EXPECT(
2184 sponsor::sponsorshipFeeBalance(env, sponsor, alice) == sponsorFee - feeAmt);
2185 }
2186
2187 {
2188 // insufficient balance to pay Fee
2189 {
2190 // > FeeAmount
2191 auto const aliceBalance = env.balance(alice);
2192 auto const bobBalance = env.balance(bob);
2193 auto const sponsorBalance = env.balance(sponsor);
2194 auto const sponsorFee = sponsor::sponsorshipFeeBalance(env, sponsor, alice);
2195
2196 env(pay(alice, bob, XRP(100)),
2197 Fee(XRP(90) + drops(1)),
2200 env.close();
2201
2202 BEAST_EXPECT(env.balance(alice) == aliceBalance);
2203 BEAST_EXPECT(env.balance(bob) == bobBalance);
2204 BEAST_EXPECT(env.balance(sponsor) == sponsorBalance);
2205 BEAST_EXPECT(sponsor::sponsorshipFeeBalance(env, sponsor, alice) == sponsorFee);
2206 }
2207 // use all FeeAmount
2208 {
2209 // = FeeAmount
2210 auto const aliceBalance = env.balance(alice);
2211 auto const bobBalance = env.balance(bob);
2212 auto const sponsorBalance = env.balance(sponsor);
2213
2214 env(pay(alice, bob, XRP(100)),
2215 Fee(XRP(90)),
2217 Ter(tesSUCCESS));
2218 env.close();
2219
2220 BEAST_EXPECT(env.balance(alice) == aliceBalance - XRP(100));
2221 BEAST_EXPECT(env.balance(bob) == bobBalance + XRP(100));
2222 BEAST_EXPECT(env.balance(sponsor) == sponsorBalance);
2223 BEAST_EXPECT(
2224 !env.le(keylet::sponsorship(sponsor, alice))->isFieldPresent(sfFeeAmount));
2225 }
2226
2227 // reset FeeAmount and MaxFee
2229 env.close();
2230 env(sponsor::set_fee(sponsor, 0, XRP(10), XRP(1)), sponsor::SponseeAcc(alice));
2231 env.close();
2232
2233 {
2234 // > MaxFee
2235 auto const aliceBalance = env.balance(alice);
2236 auto const bobBalance = env.balance(bob);
2237 auto const sponsorBalance = env.balance(sponsor);
2238 auto const sponsorFee = sponsor::sponsorshipFeeBalance(env, sponsor, alice);
2239
2240 env(pay(alice, bob, XRP(100)),
2241 Fee(XRP(1) + drops(1)),
2244 env.close();
2245
2246 BEAST_EXPECT(env.balance(alice) == aliceBalance);
2247 BEAST_EXPECT(env.balance(bob) == bobBalance);
2248 BEAST_EXPECT(env.balance(sponsor) == sponsorBalance);
2249 BEAST_EXPECT(sponsor::sponsorshipFeeBalance(env, sponsor, alice) == sponsorFee);
2250 }
2251 }
2252
2253 {
2254 // Fee is paid by Sponsor
2255 // on context reset (tec error)
2256 auto const aliceBalance = env.balance(alice);
2257 auto const bobBalance = env.balance(bob);
2258 auto const sponsorBalance = env.balance(sponsor);
2259 auto const sponsorFee = sponsor::sponsorshipFeeBalance(env, sponsor, alice);
2260 auto const feeAmt = XRP(1);
2261
2262 env(pay(alice, bob, XRP(20000)),
2263 Fee(feeAmt),
2266 env.close();
2267
2268 BEAST_EXPECT(env.balance(alice) == aliceBalance);
2269 BEAST_EXPECT(env.balance(bob) == bobBalance);
2270 BEAST_EXPECT(env.balance(sponsor) == sponsorBalance);
2271 BEAST_EXPECT(
2272 sponsor::sponsorshipFeeBalance(env, sponsor, alice) == sponsorFee - feeAmt);
2273 }
2274
2275 // make sfFeeAmount absent if tec error and all Fee is paid
2276 {
2277 // reset FeeAmount and MaxFee
2279 env(sponsor::set_fee(sponsor, 0, XRP(10)), sponsor::SponseeAcc(alice));
2280 env.close();
2281
2282 BEAST_EXPECT(
2283 env.le(keylet::sponsorship(sponsor, alice))->isFieldPresent(sfFeeAmount));
2284 auto const sponsorAvailableFee =
2286 env(check::cancel(alice, UInt256(1)),
2287 Fee(sponsorAvailableFee),
2289 Ter(tecNO_ENTRY));
2290 env.close();
2291 BEAST_EXPECT(
2292 !env.le(keylet::sponsorship(sponsor, alice))->isFieldPresent(sfFeeAmount));
2293 }
2294 }
2295
2296 // MaxFee cap is enforced in reset() for tec-failing transactions.
2297 // On a closed ledger view (!view.open()), checkFee returns tecINSUFF_FEE when
2298 // Fee > MaxFee (not terINSUF_FEE_B), triggering reset()
2299 {
2300 Env env{*this, testableAmendments()};
2301 Account const alice("alice");
2302 Account const carol("sponsor");
2303
2304 env.fund(XRP(10000), alice, carol);
2305 env.close();
2306
2307 // FeeAmount=1000 drops, MaxFee=10 drops
2308 env(sponsor::set_fee(carol, 0, drops(1000), drops(10)), sponsor::SponseeAcc(alice));
2309 env.close();
2310
2311 // Apply directly against the closed ledger view (open_ = false) so that
2312 // checkFee returns tecINSUFF_FEE and reset() is invoked.
2313 OpenView overlay(&*env.closed());
2314
2315 auto const jt = env.jt(
2316 noop(alice),
2317 Fee(drops(1000)),
2318 Seq(env.seq(alice)),
2319 sponsor::As(carol, spfSponsorFee));
2320
2321 auto const result = xrpl::apply(env.app(), overlay, *jt.stx, TapNone, env.journal);
2322 BEAST_EXPECT(result.ter == tecINSUFF_FEE);
2323 BEAST_EXPECT(result.applied);
2324
2325 // Only MaxFee (10 drops) must be deducted, not the full 1000 drops.
2326 auto const sle = overlay.read(keylet::sponsorship(carol.id(), alice.id()));
2327 BEAST_EXPECT(sle);
2328 BEAST_EXPECT(sle->isFieldPresent(sfFeeAmount));
2329 BEAST_EXPECT(sle->getFieldAmount(sfFeeAmount) == drops(990)); // 1000 - MaxFee(10)
2330 }
2331
2332 // LedgerStateFix charges an owner-reserve fee and can claim that fee
2333 // while returning tecFAILED_PROCESSING. That path must be safe when the
2334 // fee is pre-funded by a sponsorship object.
2335 {
2336 Env env{*this, testableAmendments()};
2337 Account const alice("alice");
2338 Account const sponsor("sponsor");
2339 env.fund(XRP(1000), alice, sponsor);
2340 env.close();
2341
2342 auto const fixFee = drops(env.current()->fees().increment);
2343 env(sponsor::set_fee(sponsor, 0, fixFee), sponsor::SponseeAcc(alice));
2344 env.close();
2345
2346 env(ledger_state_fix::nftPageLinks(alice, alice),
2347 Fee(fixFee),
2350
2351 if (auto const sle = env.le(keylet::sponsorship(sponsor, alice)); BEAST_EXPECT(sle))
2352 BEAST_EXPECT(!sle->isFieldPresent(sfFeeAmount));
2353 }
2354
2355 // If preclaim saw spendable sponsored FeeAmount but the apply view no
2356 // longer has it, the fee path should fail cleanly instead of throwing.
2357 {
2358 Env env{*this, testableAmendments()};
2359 Account const alice("alice");
2360 Account const sponsor("sponsor");
2361 env.fund(XRP(1000), alice, sponsor);
2362 env.close();
2363
2364 auto const fixFee = drops(env.current()->fees().increment);
2365 env(sponsor::set_fee(sponsor, 0, fixFee), sponsor::SponseeAcc(alice));
2366 env.close();
2367
2368 OpenView overlay(&*env.closed());
2369 auto const jt = env.jt(
2370 ledger_state_fix::nftPageLinks(alice, alice),
2371 Fee(fixFee),
2373
2374 auto const pf = preflight(env.app(), overlay.rules(), *jt.stx, TapNone, env.journal);
2375 BEAST_EXPECT(isTesSuccess(pf.ter));
2376 auto const pc = preclaim(pf, env.app(), overlay);
2377 BEAST_EXPECT(isTesSuccess(pc.ter));
2378
2379 auto const original = overlay.read(keylet::sponsorship(sponsor, alice));
2380 if (BEAST_EXPECT(original))
2381 {
2382 auto const sle = std::make_shared<SLE>(*original);
2383 sle->makeFieldAbsent(sfFeeAmount);
2384 overlay.rawReplace(sle);
2385 }
2386
2387 auto const result = doApply(pc, env.app(), overlay);
2388 BEAST_EXPECT(result.ter == terINSUF_FEE_B);
2389 BEAST_EXPECT(!result.applied);
2390 }
2391
2392 // test lsfSponsorshipRequireSignForFee
2393 {
2394 Env env{*this, testableAmendments()};
2395 Account const alice("alice");
2396 Account const bob("bob");
2397 Account const sponsor("sponsor");
2398 env.fund(XRP(10000), alice, bob, sponsor);
2399 env.close();
2400
2401 // set flag
2402 env(sponsor::set_fee(sponsor, tfSponsorshipSetRequireSignForFee, XRP(10)),
2403 sponsor::SponseeAcc(alice));
2404 env.close();
2405
2406 env(pay(alice, bob, XRP(100)),
2407 Fee(XRP(10)),
2410 env.close();
2411
2412 BEAST_EXPECT(
2413 env.le(keylet::sponsorship(sponsor, alice))->getFieldAmount(sfFeeAmount) ==
2414 XRP(10));
2415
2416 // clear flag
2417 env(sponsor::set(sponsor, tfSponsorshipClearRequireSignForFee),
2418 sponsor::SponseeAcc(alice));
2419 env.close();
2420
2421 // Payment is re-applied
2422 BEAST_EXPECT(!env.le(keylet::sponsorship(sponsor, alice))->isFieldPresent(sfFeeAmount));
2423 }
2424
2425 // RequireSignForFee: co-signing should succeed
2426 {
2427 Env env{*this, testableAmendments()};
2428 Account const alice("alice");
2429 Account const bob("bob");
2430 Account const sponsor("sponsor");
2431 env.fund(XRP(10000), alice, bob, sponsor);
2432 env.close();
2433
2434 // set flag
2435 env(sponsor::set_fee(sponsor, tfSponsorshipSetRequireSignForFee, XRP(10)),
2436 sponsor::SponseeAcc(alice));
2437 env.close();
2438
2439 // pre-funded (no sig) should fail
2440 env(pay(alice, bob, XRP(100)),
2441 Fee(XRP(1)),
2444 env.close();
2445
2446 // co-signing (with sig) should succeed
2447 env(pay(alice, bob, XRP(100)),
2448 Fee(XRP(1)),
2450 Sig(sfSponsorSignature, sponsor),
2451 Ter(tesSUCCESS));
2452 env.close();
2453
2454 BEAST_EXPECT(
2455 env.le(keylet::sponsorship(sponsor, alice))->getFieldAmount(sfFeeAmount) == XRP(9));
2456 }
2457 }
2458
2459 void
2461 {
2462 testcase("Sponsor Account");
2463 using namespace test::jtx;
2464
2465 Account const alice("alice");
2466 Account const sponsor("sponsor");
2467 Account const sponsor2("sponsor2");
2468 Account const sponsor3("sponsor3");
2469 Account const bob("bob");
2470 Account const charlie("charlie");
2471 Account const dave("dave");
2472 Account const gw("gw");
2473 auto const usd = gw["usd"];
2474
2475 {
2476 // Disabled
2477 Env env{*this, testableAmendments() - featureSponsor};
2478 env.fund(XRP(10000), alice, sponsor);
2479 env.close();
2480 env(pay(alice, bob, XRP(100)), Txflags(tfSponsorCreatedAccount), Ter(temDISABLED));
2481 env.close();
2482 }
2483
2484 Env env{*this, testableAmendments()};
2485 env.fund(XRP(10000), alice, sponsor, sponsor2, sponsor3);
2486 env.close();
2487
2488 // Invalid flags
2489 for (auto const flag : {
2490 tfNoRippleDirect,
2491 tfPartialPayment,
2492 tfLimitQuality,
2493 })
2494 {
2495 env(pay(alice, bob, XRP(100)),
2496 Txflags(tfSponsorCreatedAccount | flag),
2498 env.close();
2499 }
2500
2501 // Invalid amount(iou)
2502 env(pay(alice, bob, usd(100)), Txflags(tfSponsorCreatedAccount), Ter(temBAD_AMOUNT));
2503 env.close();
2504
2505 // Sponsored account creation is reserve sponsorship and is only supported for direct XRP
2506 // payments.
2507 env(pay(alice, bob, drops(1)),
2508 Txflags(tfSponsorCreatedAccount),
2509 Sendmax(usd(2)),
2510 Ter(temINVALID));
2511 env.close();
2512
2513 env(pay(alice, bob, drops(1)),
2514 Txflags(tfSponsorCreatedAccount),
2515 Path(~XRP),
2516 Ter(temINVALID));
2517 env.close();
2518
2519 // Account is not sponsored by normal Sponsor specification
2520 {
2521 env(pay(alice, bob, drops(env.current()->fees().accountReserve(0, 1))),
2523 Sig(sfSponsorSignature, sponsor));
2524 env.close();
2525
2526 auto const bobSle = env.le(keylet::account(bob));
2527 BEAST_EXPECT(!bobSle->isFieldPresent(sfSponsor));
2528 BEAST_EXPECT(sponsoredOwnerCount(env, alice) == 0);
2529 BEAST_EXPECT(sponsoringAccountCount(env, sponsor) == 0);
2530 }
2531
2532 // Use tfSponsorCreatedAccount to sponsor an account
2533 {
2534 // to funded account
2535 env(pay(sponsor2, bob, drops(1)),
2536 Txflags(tfSponsorCreatedAccount),
2537 Fee(XRP(1)),
2539 env.close();
2540
2541 BEAST_EXPECT(env.balance(sponsor2) == XRP(9999));
2542
2543 // to non-funded account / insufficient balance for reserve
2544 env(pay(sponsor2, charlie, XRP(9999) - env.current()->fees().reserve + drops(1)),
2545 Txflags(tfSponsorCreatedAccount),
2547 env.close();
2548
2549 // to non-funded account
2550 auto const sponsor2BalanceBefore = env.balance(sponsor2);
2551 env(pay(sponsor2, charlie, drops(1)), Txflags(tfSponsorCreatedAccount), Fee(XRP(1)));
2552 env.close();
2553
2554 auto const charlieSle = env.le(keylet::account(charlie));
2555 BEAST_EXPECT(charlieSle->isFieldPresent(sfSponsor));
2556 BEAST_EXPECT(charlieSle->getAccountID(sfSponsor) == sponsor2.id());
2557 BEAST_EXPECT(sponsoredOwnerCount(env, charlie) == 0);
2558 BEAST_EXPECT(sponsoringAccountCount(env, sponsor2) == 1);
2559 // verify sponsor balance decreased by payment + Fee
2560 BEAST_EXPECT(env.balance(sponsor2) == sponsor2BalanceBefore - drops(1) - XRP(1));
2561 }
2562 {
2563 // insufficient reserve to sponsor acount
2564
2565 auto const sendAmount = drops(1);
2566 // 2 account reserve + send amount
2567 auto const requireBalance = accountReserve(env, 2) + sendAmount;
2568 adjustAccountXRPBalance(env, sponsor3, requireBalance - drops(1));
2569 env(pay(sponsor3, dave, sendAmount),
2570 Txflags(tfSponsorCreatedAccount),
2571 Fee(XRP(1)),
2573 env.close();
2574
2575 adjustAccountXRPBalance(env, sponsor3, requireBalance);
2576 env(pay(sponsor3, dave, sendAmount),
2577 Txflags(tfSponsorCreatedAccount),
2578 Fee(XRP(1)),
2579 Ter(tesSUCCESS));
2580 env.close();
2581 }
2582 }
2583
2584 void
2586 {
2587 using namespace test::jtx;
2588 {
2589 testcase("SponsorshipRequireSignForReserve");
2590
2591 Env env{*this, testableAmendments()};
2592 Account const alice("alice");
2593 Account const bob("bob");
2594 Account const sponsor("sponsor");
2595 env.fund(XRP(10000), alice, bob, sponsor);
2596 env.close();
2597
2598 // set flag
2599 env(sponsor::set_reserve(sponsor, tfSponsorshipSetRequireSignForReserve, 10),
2600 sponsor::SponseeAcc(alice));
2601 env.close();
2602
2603 env(check::create(alice, bob, XRP(100)),
2604 Fee(XRP(10)),
2607
2608 BEAST_EXPECT(ownerCount(env, alice) == 0);
2609 BEAST_EXPECT(sponsoredOwnerCount(env, alice) == 0);
2610 BEAST_EXPECT(sponsoringOwnerCount(env, sponsor) == 0);
2611
2612 // clear flag
2613 env(sponsor::set_reserve(sponsor, tfSponsorshipClearRequireSignForReserve, 1),
2614 sponsor::SponseeAcc(alice));
2615 env.close();
2616
2617 // CheckCreate is re-applied
2618 BEAST_EXPECT(ownerCount(env, alice) == 1);
2619 BEAST_EXPECT(sponsoredOwnerCount(env, alice) == 1);
2620 BEAST_EXPECT(sponsoringOwnerCount(env, sponsor) == 1);
2621 }
2622
2623 {
2624 testcase("SponsorshipRequireSignForFee");
2625
2626 Env env{*this, testableAmendments()};
2627 Account const alice("alice");
2628 Account const bob("bob");
2629 Account const sponsor("sponsor");
2630 env.fund(XRP(10000), alice, bob, sponsor);
2631 env.close();
2632
2633 // set flag
2634 env(sponsor::set_fee(sponsor, tfSponsorshipSetRequireSignForFee, XRP(10)),
2635 sponsor::SponseeAcc(alice));
2636 env.close();
2637
2638 env(check::create(alice, bob, XRP(100)),
2639 Fee(XRP(10)),
2642
2643 BEAST_EXPECT(ownerCount(env, alice) == 0);
2644 BEAST_EXPECT(
2645 env.le(keylet::sponsorship(sponsor, alice))->getFieldAmount(sfFeeAmount) ==
2646 XRP(10));
2647
2648 // clear flag
2649 env(sponsor::set(sponsor, tfSponsorshipClearRequireSignForFee),
2650 sponsor::SponseeAcc(alice));
2651 env.close();
2652
2653 // CheckCreate is re-applied
2654 BEAST_EXPECT(ownerCount(env, alice) == 1);
2655 BEAST_EXPECT(!env.le(keylet::sponsorship(sponsor, alice))->isFieldPresent(sfFeeAmount));
2656 }
2657 }
2658
2659 void
2661 {
2662 testcase("SponsorReserveSimple");
2663 using namespace test::jtx;
2664 Env env{*this, testableAmendments()};
2665 Account const alice("alice");
2666 Account const bob("bob");
2667 Account const sponsor("sponsor");
2668
2669 env.fund(XRP(10000), alice, bob, sponsor);
2670 env.close();
2671
2672 if (cosigning)
2673 {
2674 adjustAccountXRPBalance(env, sponsor, reserve(env, 1) - drops(1));
2675
2676 env(check::create(alice, bob, XRP(100)),
2678 Sig(sfSponsorSignature, sponsor),
2680 env.close();
2681
2683
2684 env(check::create(alice, bob, XRP(100)),
2686 Sig(sfSponsorSignature, sponsor),
2687 Ter(tesSUCCESS));
2688 env.close();
2689 }
2690 else
2691 {
2692 env(sponsor::set_reserve(sponsor, 0, 250), sponsor::SponseeAcc(alice));
2693 env.close();
2694
2695 adjustAccountXRPBalance(env, sponsor, reserve(env, 2) - drops(1));
2696
2697 env(check::create(alice, bob, XRP(100)),
2700 env.close();
2701
2703
2704 env(check::create(alice, bob, XRP(100)),
2706 Ter(tesSUCCESS));
2707 env.close();
2708 }
2709 }
2710
2711 // test helper for both cosigning and pre-funded sponsorship
2712 template <typename SubmitCallback>
2713 void
2715 test::jtx::Env& env,
2716 bool cosigning,
2717 jtx::Account const& sponsor,
2718 jtx::Account const& sponsee,
2719 uint32_t reserveCount,
2720 uint32_t sponsorReserveCount,
2721 TER insufficientReserveResult,
2722 SubmitCallback callback,
2723 std::optional<std::function<void()>> expected = std::nullopt)
2724 {
2725 using namespace test::jtx;
2726 auto const sponseeOwnerCountBefore = ownerCount(env, sponsee);
2727 auto const sponseeSponsoredOwnerCountBefore = sponsoredOwnerCount(env, sponsee);
2728 auto const sponseeSponsoringOwnerCountBefore = sponsoringOwnerCount(env, sponsee);
2729 auto const sponsorOwnerCountBefore = ownerCount(env, sponsor);
2730 auto const sponsorSponsoredOwnerCountBefore = sponsoredOwnerCount(env, sponsor);
2731 auto const sponsorSponsoringOwnerCountBefore = sponsoringOwnerCount(env, sponsor);
2732
2733 std::optional<Sig> sponsorSig =
2734 cosigning ? std::optional<Sig>(Sig(sfSponsorSignature, sponsor)) : std::nullopt;
2735
2736 auto const sponsorCurrentOwnerCount = ownerCount(env, sponsor) -
2738
2739 auto const submit = [&](TER ter) {
2740 return [&, ter](json::Value const& jv, auto const&... fN) {
2741 if (sponsorSig)
2742 {
2743 env(jv, fN..., sponsor::As(sponsor, spfSponsorReserve), *sponsorSig, Ter(ter));
2744 }
2745 else
2746 {
2747 env(jv, fN..., sponsor::As(sponsor, spfSponsorReserve), Ter(ter));
2748 }
2749 };
2750 };
2751
2752 // Insufficient Reserve
2753 {
2754 if (cosigning)
2755 {
2757 env,
2758 sponsor,
2759 reserve(env, sponsorCurrentOwnerCount + sponsorReserveCount) - drops(1));
2760 }
2761 else
2762 {
2763 // cleanup previous sponsorship
2764 if (env.le(keylet::sponsorship(sponsor, sponsee)))
2765 {
2767 env.close();
2768 }
2769
2770 if (sponsorReserveCount > 1)
2771 {
2772 env(sponsor::set(sponsor, 0, sponsorReserveCount - 1, XRP(1)),
2773 sponsor::SponseeAcc(sponsee));
2774 }
2775 else
2776 {
2777 // just create sponsor object
2778 env(sponsor::set(sponsor, 0, std::nullopt, XRP(1)),
2779 sponsor::SponseeAcc(sponsee));
2780 }
2781 env.close();
2782 }
2783
2784 // A failed sponsored create must not consume prefunded reserve or mutate owner counts.
2785 auto const sponseeOwnerCountBeforeAttempt = ownerCount(env, sponsee);
2786 auto const sponseeSponsoredOwnerCountBeforeAttempt = sponsoredOwnerCount(env, sponsee);
2787 auto const sponseeSponsoringOwnerCountBeforeAttempt =
2788 sponsoringOwnerCount(env, sponsee);
2789 auto const sponsorOwnerCountBeforeAttempt = ownerCount(env, sponsor);
2790 auto const sponsorSponsoredOwnerCountBeforeAttempt = sponsoredOwnerCount(env, sponsor);
2791 auto const sponsorSponsoringOwnerCountBeforeAttempt =
2793 auto const sponsorshipSleBeforeAttempt = env.le(keylet::sponsorship(sponsor, sponsee));
2794 bool const reserveCountPresentBeforeAttempt = sponsorshipSleBeforeAttempt &&
2795 sponsorshipSleBeforeAttempt->isFieldPresent(sfRemainingOwnerCount);
2796 std::uint32_t const reserveCountBeforeAttempt = reserveCountPresentBeforeAttempt
2797 ? sponsorshipSleBeforeAttempt->getFieldU32(sfRemainingOwnerCount)
2798 : 0;
2799
2800 callback(env, submit(insufficientReserveResult));
2801 env.close();
2802
2803 BEAST_EXPECT(ownerCount(env, sponsee) == sponseeOwnerCountBeforeAttempt);
2804 BEAST_EXPECT(
2805 sponsoredOwnerCount(env, sponsee) == sponseeSponsoredOwnerCountBeforeAttempt);
2806 BEAST_EXPECT(
2807 sponsoringOwnerCount(env, sponsee) == sponseeSponsoringOwnerCountBeforeAttempt);
2808 BEAST_EXPECT(ownerCount(env, sponsor) == sponsorOwnerCountBeforeAttempt);
2809 BEAST_EXPECT(
2810 sponsoredOwnerCount(env, sponsor) == sponsorSponsoredOwnerCountBeforeAttempt);
2811 BEAST_EXPECT(
2812 sponsoringOwnerCount(env, sponsor) == sponsorSponsoringOwnerCountBeforeAttempt);
2813
2814 auto const sponsorshipSleAfterAttempt = env.le(keylet::sponsorship(sponsor, sponsee));
2815 BEAST_EXPECT(
2816 static_cast<bool>(sponsorshipSleAfterAttempt) ==
2817 static_cast<bool>(sponsorshipSleBeforeAttempt));
2818 if (sponsorshipSleAfterAttempt)
2819 {
2820 BEAST_EXPECT(
2821 sponsorshipSleAfterAttempt->isFieldPresent(sfRemainingOwnerCount) ==
2822 reserveCountPresentBeforeAttempt);
2823 if (reserveCountPresentBeforeAttempt)
2824 {
2825 BEAST_EXPECT(
2826 sponsorshipSleAfterAttempt->getFieldU32(sfRemainingOwnerCount) ==
2827 reserveCountBeforeAttempt);
2828 }
2829 }
2830 }
2831
2832 // Success
2833 {
2834 if (cosigning)
2835 {
2837 env, sponsor, reserve(env, sponsorCurrentOwnerCount + sponsorReserveCount));
2838 }
2839 else
2840 {
2841 // reset sponsorship
2843 env(sponsor::set(sponsor, 0, sponsorReserveCount, XRP(1)),
2844 sponsor::SponseeAcc(sponsee));
2845 env.close();
2846 }
2847 callback(env, submit(tesSUCCESS));
2848 env.close();
2849
2850 if (!cosigning)
2851 {
2852 // Prefunded success consumes the reserved owner slot before cleanup.
2853 auto const sponsorshipSle = env.le(keylet::sponsorship(sponsor, sponsee));
2854 BEAST_EXPECT(sponsorshipSle);
2855 BEAST_EXPECT(
2856 !sponsorshipSle->isFieldPresent(sfRemainingOwnerCount) ||
2857 sponsorshipSle->getFieldU32(sfRemainingOwnerCount) == 0);
2858
2859 // cleanup sponsorship
2861 env.close();
2862 }
2863 }
2864
2865 if (expected)
2866 {
2867 (*expected)();
2868 }
2869 else
2870 {
2871 BEAST_EXPECT(ownerCount(env, sponsee) - sponseeOwnerCountBefore == reserveCount);
2872 BEAST_EXPECT(
2873 sponsoredOwnerCount(env, sponsee) - sponseeSponsoredOwnerCountBefore ==
2874 sponsorReserveCount);
2875 BEAST_EXPECT(
2876 sponsoringOwnerCount(env, sponsee) - sponseeSponsoringOwnerCountBefore == 0);
2877 BEAST_EXPECT(ownerCount(env, sponsor) == sponsorOwnerCountBefore);
2878 BEAST_EXPECT(sponsoredOwnerCount(env, sponsor) == sponsorSponsoredOwnerCountBefore);
2879 BEAST_EXPECT(
2880 sponsoringOwnerCount(env, sponsor) - sponsorSponsoringOwnerCountBefore ==
2881 sponsorReserveCount);
2882 }
2883 };
2884
2885 void
2886 testCheck(bool cosigning)
2887 {
2888 testcase("Check");
2889 using namespace test::jtx;
2890 Account const alice("alice");
2891 Account const bob("bob");
2892 Account const gw("gw");
2893 Account const sponsor("sponsor");
2894 Account const sponsor2("sponsor2");
2895
2896 auto const usd = gw["usd"];
2897
2898 {
2899 Env env{*this, testableAmendments()};
2900 env.fund(XRP(10000), alice, bob, sponsor, sponsor2);
2901 env.close();
2902
2903 // CheckCreate -> Check -> CheckCancel
2904
2905 uint32_t seq = 0;
2907 env,
2908 cosigning,
2909 sponsor,
2910 alice,
2911 1,
2912 1,
2914 [&](Env& env, auto const& submit) {
2915 seq = env.seq(alice);
2916 submit(check::create(alice, bob, XRP(1)));
2917 });
2918
2919 BEAST_EXPECT(ownerCount(env, alice) == 1); // Check
2920 BEAST_EXPECT(sponsoredOwnerCount(env, alice) == 1);
2921 BEAST_EXPECT(sponsoringOwnerCount(env, alice) == 0);
2922 BEAST_EXPECT(sponsoringOwnerCount(env, sponsor) == 1);
2923
2924 auto const keylet = keylet::check(alice, SeqProxy::rawSequence(seq));
2925 BEAST_EXPECT(env.le(keylet)->getAccountID(sfSponsor) == sponsor.id());
2926
2927 if (cosigning)
2928 {
2929 // transfer sponsor
2930 env(sponsor::transfer(alice, tfSponsorshipReassign, keylet.key),
2931 sponsor::As(sponsor2, spfSponsorReserve),
2932 Sig(sfSponsorSignature, sponsor2));
2933 env.close();
2934 }
2935 else
2936 {
2937 env(sponsor::set_reserve(sponsor2, 0, 1), sponsor::SponseeAcc(alice));
2938 env.close();
2939
2940 // transfer sponsor
2941 env(sponsor::transfer(alice, tfSponsorshipReassign, keylet.key),
2942 sponsor::As(sponsor2, spfSponsorReserve));
2943 env.close();
2944 }
2945
2946 BEAST_EXPECT(ownerCount(env, alice) == 1); // Check
2947 BEAST_EXPECT(sponsoredOwnerCount(env, alice) == 1);
2948 BEAST_EXPECT(sponsoringOwnerCount(env, alice) == 0);
2949 BEAST_EXPECT(sponsoringOwnerCount(env, sponsor) == 0);
2950 BEAST_EXPECT(sponsoringOwnerCount(env, sponsor2) == 1);
2951
2952 BEAST_EXPECT(env.le(keylet)->getAccountID(sfSponsor) == sponsor2.id());
2953
2954 // CheckCancel
2955 env(check::cancel(alice, keylet.key));
2956 env.close();
2957
2958 BEAST_EXPECT(ownerCount(env, alice) == 0);
2959 BEAST_EXPECT(sponsoredOwnerCount(env, alice) == 0);
2960 BEAST_EXPECT(sponsoringOwnerCount(env, sponsor) == 0);
2961 BEAST_EXPECT(sponsoringOwnerCount(env, sponsor2) == 0);
2962 }
2963
2964 {
2965 Env env{*this, testableAmendments()};
2966 env.fund(XRP(10000), alice, bob, sponsor);
2967 env.close();
2968
2969 // CheckCreate -> CheckCash
2970 uint32_t seq2 = 0;
2972 env,
2973 cosigning,
2974 sponsor,
2975 alice,
2976 1,
2977 1,
2979 [&](Env& env, auto const& submit) {
2980 seq2 = env.seq(alice);
2981 submit(check::create(alice, bob, XRP(1)));
2982 });
2983
2984 BEAST_EXPECT(ownerCount(env, bob) == 0);
2985 BEAST_EXPECT(sponsoredOwnerCount(env, bob) == 0);
2986
2987 // CheckCash
2988 auto const checkId2 = keylet::check(alice, SeqProxy::rawSequence(seq2)).key;
2989 env(check::cash(bob, checkId2, XRP(1)));
2990 env.close();
2991
2992 BEAST_EXPECT(ownerCount(env, alice) == 0);
2993 BEAST_EXPECT(ownerCount(env, bob) == 0);
2994 BEAST_EXPECT(sponsoredOwnerCount(env, alice) == 0);
2995 BEAST_EXPECT(sponsoredOwnerCount(env, bob) == 0);
2996 BEAST_EXPECT(sponsoringOwnerCount(env, sponsor) == 0);
2997 }
2998
2999 // RippleState sponsor (CheckCashMakesTrustLine)
3000 {
3001 Env env{*this, testableAmendments()};
3002 env.fund(XRP(10000), alice, bob, gw, sponsor, sponsor2);
3003 env.close();
3004
3005 env.trust(usd(100), alice);
3006 env.close();
3007 env(pay(gw, alice, usd(100)));
3008 env.close();
3009
3010 // CheckCreate -> CheckCash
3011 uint32_t seq2 = 0;
3013 env,
3014 cosigning,
3015 sponsor,
3016 alice,
3017 1,
3018 1,
3020 [&](Env& env, auto const& submit) {
3021 seq2 = env.seq(alice);
3022 submit(check::create(alice, bob, usd(1)));
3023 });
3024
3025 BEAST_EXPECT(ownerCount(env, bob) == 0);
3026 BEAST_EXPECT(sponsoredOwnerCount(env, bob) == 0);
3027
3028 auto const keylet = keylet::check(alice, SeqProxy::rawSequence(seq2));
3029 BEAST_EXPECT(env.le(keylet)->getAccountID(sfSponsor) == sponsor.id());
3030
3031 // CheckCash
3033 env,
3034 cosigning,
3035 sponsor,
3036 bob,
3037 1,
3038 1,
3040 [&](Env& env, auto const& submit) { submit(check::cash(bob, keylet.key, usd(1))); },
3041 [&] {
3042 BEAST_EXPECT(ownerCount(env, alice) == 1); // RippleState
3043 BEAST_EXPECT(ownerCount(env, bob) == 1); // RippleState
3044 BEAST_EXPECT(sponsoredOwnerCount(env, alice) == 0);
3045 BEAST_EXPECT(sponsoredOwnerCount(env, bob) == 1);
3046 BEAST_EXPECT(sponsoringOwnerCount(env, sponsor) == 1);
3047
3048 // the newly-created trust line carries the sponsor on
3049 // bob's side, and no sponsor on the counterparty side
3050 bool const bobLow = bob.id() < gw.id();
3051 auto const lineSle = env.le(keylet::trustLine(bob, gw, usd.currency));
3052 BEAST_EXPECT(lineSle);
3053 if (lineSle)
3054 {
3055 BEAST_EXPECT(
3056 lineSle->getAccountID(bobLow ? sfLowSponsor : sfHighSponsor) ==
3057 sponsor.id());
3058 BEAST_EXPECT(
3059 !lineSle->isFieldPresent(bobLow ? sfHighSponsor : sfLowSponsor));
3060 }
3061 });
3062 }
3063
3064 // MPT sponsor: cashing an MPT check creates a sponsored MPToken for
3065 // the casher. Unlike the trust-line path, this returns
3066 // tecINSUFFICIENT_RESERVE (not tecNO_LINE_INSUF_RESERVE) on shortfall.
3067 {
3068 Env env{*this, testableAmendments()};
3069 env.fund(XRP(10000), bob, sponsor, sponsor2);
3070 env.close();
3071
3072 MPTTester mptGw(env, gw, {.holders = {alice}});
3073 mptGw.create({.ownerCount = 1, .holderCount = 0, .flags = tfMPTCanTransfer});
3074 mptGw.authorize({.account = alice});
3075 auto const mpt = mptGw["MPT"];
3076 env(pay(gw, alice, mpt(10'000)));
3077 env.close();
3078
3079 // CheckCreate (alice -> bob) paying the MPT
3080 uint32_t seq2 = 0;
3082 env,
3083 cosigning,
3084 sponsor,
3085 alice,
3086 1,
3087 1,
3089 [&](Env& env, auto const& submit) {
3090 seq2 = env.seq(alice);
3091 submit(check::create(alice, bob, mpt(1)));
3092 });
3093
3094 auto const checkKeylet = keylet::check(alice, SeqProxy::rawSequence(seq2));
3095 BEAST_EXPECT(env.le(checkKeylet)->getAccountID(sfSponsor) == sponsor.id());
3096 BEAST_EXPECT(ownerCount(env, bob) == 0);
3097
3098 // CheckCash by bob (no MPToken yet) creates a sponsored MPToken
3100 env,
3101 cosigning,
3102 sponsor,
3103 bob,
3104 1,
3105 1,
3107 [&](Env& env, auto const& submit) {
3108 submit(check::cash(bob, checkKeylet.key, mpt(1)));
3109 },
3110 [&] {
3111 BEAST_EXPECT(ownerCount(env, bob) == 1); // MPToken
3112 BEAST_EXPECT(sponsoredOwnerCount(env, bob) == 1);
3113 BEAST_EXPECT(sponsoringOwnerCount(env, sponsor) == 1);
3114 BEAST_EXPECT(
3115 env.le(keylet::mptoken(mptGw.issuanceID(), bob))->getAccountID(sfSponsor) ==
3116 sponsor.id());
3117 });
3118 }
3119 }
3120
3121 void
3122 testDelegate(bool cosigning)
3123 {
3124 testcase("Delegate");
3125 using namespace test::jtx;
3126 Account const alice("alice");
3127 Account const bob("bob");
3128 Account const sponsor("sponsor");
3129 Account const sponsor2("sponsor2");
3130
3131 {
3132 Env env{*this, testableAmendments()};
3133 env.fund(XRP(1000000), alice, bob, sponsor, sponsor2);
3134 env.close();
3135
3136 // DelegateSet
3138 env,
3139 cosigning,
3140 sponsor,
3141 alice,
3142 1,
3143 1,
3145 [&](Env& env, auto const& submit) {
3146 submit(delegate::set(alice, bob, {"Payment"}));
3147 });
3148
3149 // the created Delegate object carries the sponsor
3150 auto const keylet = keylet::delegate(alice, bob);
3151 BEAST_EXPECT(env.le(keylet)->getAccountID(sfSponsor) == sponsor.id());
3152
3153 // transfer sponsor
3154 if (cosigning)
3155 {
3156 env(sponsor::transfer(alice, tfSponsorshipReassign, keylet.key),
3157 sponsor::As(sponsor2, spfSponsorReserve),
3158 Sig(sfSponsorSignature, sponsor2));
3159 env.close();
3160 }
3161 else
3162 {
3163 env(sponsor::set_reserve(sponsor2, 0, 1), sponsor::SponseeAcc(alice));
3164 env.close();
3165
3166 env(sponsor::transfer(alice, tfSponsorshipReassign, keylet.key),
3167 sponsor::As(sponsor2, spfSponsorReserve));
3168 env.close();
3169 }
3170
3171 BEAST_EXPECT(ownerCount(env, alice) == 1);
3172 BEAST_EXPECT(sponsoredOwnerCount(env, alice) == 1);
3173 BEAST_EXPECT(sponsoringOwnerCount(env, sponsor) == 0);
3174 BEAST_EXPECT(sponsoringOwnerCount(env, sponsor2) == 1);
3175 BEAST_EXPECT(env.le(keylet)->getAccountID(sfSponsor) == sponsor2.id());
3176
3177 // delete
3178 env(delegate::set(alice, bob, {}));
3179 env.close();
3180
3181 BEAST_EXPECT(ownerCount(env, alice) == 0);
3182 BEAST_EXPECT(sponsoredOwnerCount(env, alice) == 0);
3183 BEAST_EXPECT(sponsoringOwnerCount(env, sponsor) == 0);
3184 }
3185 }
3186
3187 void
3188 testDepositPreauth(bool cosigning)
3189 {
3190 testcase("DepositPreauth");
3191 using namespace test::jtx;
3192 Account const alice("alice");
3193 Account const sponsor("sponsor");
3194 Account const sponsor2("sponsor2");
3195 auto const credType = std::string("credType");
3196
3197 {
3198 Env env{*this, testableAmendments()};
3199 env.fund(XRP(1000000), alice, sponsor, sponsor2);
3200 env.close();
3201
3202 // DepositPreauthSet
3204 env,
3205 cosigning,
3206 sponsor,
3207 alice,
3208 1,
3209 1,
3211 [&](Env& env, auto const& submit) { submit(deposit::auth(alice, sponsor)); });
3212
3213 // the created DepositPreauth object carries the sponsor
3214 auto const keylet = keylet::depositPreauth(alice, sponsor);
3215 BEAST_EXPECT(env.le(keylet)->getAccountID(sfSponsor) == sponsor.id());
3216
3217 // transfer sponsor
3218 if (cosigning)
3219 {
3220 env(sponsor::transfer(alice, tfSponsorshipReassign, keylet.key),
3221 sponsor::As(sponsor2, spfSponsorReserve),
3222 Sig(sfSponsorSignature, sponsor2));
3223 env.close();
3224 }
3225 else
3226 {
3227 env(sponsor::set_reserve(sponsor2, 0, 1), sponsor::SponseeAcc(alice));
3228 env.close();
3229 // No sponsor signature here: this exercises the prefunded reassign path.
3230 env(sponsor::transfer(alice, tfSponsorshipReassign, keylet.key),
3231 sponsor::As(sponsor2, spfSponsorReserve));
3232 env.close();
3233
3234 auto const sponsor2Sle = env.le(keylet::sponsorship(sponsor2, alice));
3235 BEAST_EXPECT(sponsor2Sle);
3236 if (sponsor2Sle)
3237 {
3238 BEAST_EXPECT(
3239 !sponsor2Sle->isFieldPresent(sfRemainingOwnerCount) ||
3240 sponsor2Sle->getFieldU32(sfRemainingOwnerCount) == 0);
3241 }
3242 }
3243
3244 BEAST_EXPECT(ownerCount(env, alice) == 1);
3245 BEAST_EXPECT(sponsoredOwnerCount(env, alice) == 1);
3246 BEAST_EXPECT(sponsoringOwnerCount(env, sponsor) == 0);
3247 BEAST_EXPECT(sponsoringOwnerCount(env, sponsor2) == 1);
3248 BEAST_EXPECT(env.le(keylet)->getAccountID(sfSponsor) == sponsor2.id());
3249
3250 // DepositPreauthDelete
3251 env(deposit::unauth(alice, sponsor));
3252 env.close();
3253
3254 BEAST_EXPECT(ownerCount(env, alice) == 0);
3255 BEAST_EXPECT(sponsoredOwnerCount(env, alice) == 0);
3256 BEAST_EXPECT(sponsoringOwnerCount(env, sponsor) == 0);
3257 BEAST_EXPECT(sponsoringOwnerCount(env, sponsor2) == 0);
3258 }
3259
3260 {
3261 Env env{*this, testableAmendments()};
3262 env.fund(XRP(1000000), alice, sponsor);
3263 env.close();
3264 auto const authCreds = std::vector<deposit::AuthorizeCredentials>{
3265 {.issuer = sponsor, .credType = credType},
3266 };
3267 auto const preauthKeylet = keylet::depositPreauth(
3268 alice.id(),
3270 {sponsor.id(), Slice(credType.data(), credType.size())},
3271 });
3272
3273 // Cover DepositPreauth's sfAuthorizeCredentials sponsor-reserve branch.
3275 env,
3276 cosigning,
3277 sponsor,
3278 alice,
3279 1,
3280 1,
3282 [&](Env&, auto const& submit) {
3283 submit(deposit::authCredentials(alice, authCreds));
3284 });
3285
3286 // Cover sfUnauthorizeCredentials cleanup for a sponsored preauth object.
3287 BEAST_EXPECT(env.le(preauthKeylet));
3288 BEAST_EXPECT(env.le(preauthKeylet)->getAccountID(sfSponsor) == sponsor.id());
3289 BEAST_EXPECT(ownerCount(env, alice) == 1);
3290 BEAST_EXPECT(sponsoredOwnerCount(env, alice) == 1);
3291 BEAST_EXPECT(sponsoringOwnerCount(env, sponsor) == 1);
3292
3293 env(deposit::unauthCredentials(alice, authCreds));
3294 env.close();
3295
3296 BEAST_EXPECT(!env.le(preauthKeylet));
3297 BEAST_EXPECT(ownerCount(env, alice) == 0);
3298 BEAST_EXPECT(sponsoredOwnerCount(env, alice) == 0);
3299 BEAST_EXPECT(sponsoringOwnerCount(env, sponsor) == 0);
3300 }
3301 }
3302
3303 void
3304 testCredential(bool cosigning)
3305 {
3306 testcase("Credential");
3307 using namespace test::jtx;
3308 Account const alice("alice");
3309 Account const bob("bob");
3310 Account const sponsor("sponsor");
3311 Account const sponsor2("sponsor2");
3312 auto const credType = std::string("test");
3313
3314 // Self-issued credential: alice creates for herself, sponsor covers reserve
3315 {
3316 Env env{*this, testableAmendments()};
3317 env.fund(XRP(1000000), alice, bob, sponsor, sponsor2);
3318 env.close();
3319
3321 env,
3322 cosigning,
3323 sponsor,
3324 alice,
3325 1,
3326 1,
3328 [&](Env& env, auto const& submit) {
3329 submit(credentials::create(alice, alice, credType));
3330 });
3331
3332 auto const credKeylet = credentials::keylet(alice, alice, credType);
3333 BEAST_EXPECT(env.le(credKeylet)->getAccountID(sfSponsor) == sponsor.id());
3334
3335 BEAST_EXPECT(ownerCount(env, alice) == 1);
3336 BEAST_EXPECT(sponsoredOwnerCount(env, alice) == 1);
3337 BEAST_EXPECT(sponsoringOwnerCount(env, alice) == 0);
3338 BEAST_EXPECT(sponsoringOwnerCount(env, sponsor) == 1);
3339
3340 // Transfer sponsor
3341 if (cosigning)
3342 {
3343 env(sponsor::transfer(alice, tfSponsorshipReassign, credKeylet.key),
3344 sponsor::As(sponsor2, spfSponsorReserve),
3345 Sig(sfSponsorSignature, sponsor2));
3346 env.close();
3347 }
3348 else
3349 {
3350 env(sponsor::set_reserve(sponsor2, 0, 1), sponsor::SponseeAcc(alice));
3351 env.close();
3352 env(sponsor::transfer(alice, tfSponsorshipReassign, credKeylet.key),
3353 sponsor::As(sponsor2, spfSponsorReserve));
3354 env.close();
3355 }
3356
3357 BEAST_EXPECT(ownerCount(env, alice) == 1);
3358 BEAST_EXPECT(sponsoredOwnerCount(env, alice) == 1);
3359 BEAST_EXPECT(sponsoringOwnerCount(env, sponsor) == 0);
3360 BEAST_EXPECT(sponsoringOwnerCount(env, sponsor2) == 1);
3361 BEAST_EXPECT(env.le(credKeylet)->getAccountID(sfSponsor) == sponsor2.id());
3362
3363 // CredentialDelete
3364 env(credentials::deleteCred(alice, alice, alice, credType));
3365 env.close();
3366
3367 BEAST_EXPECT(ownerCount(env, alice) == 0);
3368 BEAST_EXPECT(sponsoredOwnerCount(env, alice) == 0);
3369 BEAST_EXPECT(sponsoringOwnerCount(env, sponsor) == 0);
3370 BEAST_EXPECT(sponsoringOwnerCount(env, sponsor2) == 0);
3371 }
3372
3373 // Issuer creates for subject; sponsorship transfers to subject on accept
3374 {
3375 Env env{*this, testableAmendments()};
3376 env.fund(XRP(1000000), alice, bob, sponsor);
3377 env.close();
3378
3379 // alice (issuer) creates credential for bob (subject), sponsor covers alice's reserve
3381 env,
3382 cosigning,
3383 sponsor,
3384 alice,
3385 1,
3386 1,
3388 [&](Env& env, auto const& submit) {
3389 submit(credentials::create(bob, alice, credType));
3390 });
3391
3392 // Before accept: alice (issuer) owns the credential
3393 auto const credKeylet = credentials::keylet(bob, alice, credType);
3394 BEAST_EXPECT(env.le(credKeylet)->getAccountID(sfSponsor) == sponsor.id());
3395
3396 BEAST_EXPECT(ownerCount(env, alice) == 1);
3397 BEAST_EXPECT(sponsoredOwnerCount(env, alice) == 1);
3398 BEAST_EXPECT(sponsoringOwnerCount(env, sponsor) == 1);
3399 BEAST_EXPECT(ownerCount(env, bob) == 0);
3400 BEAST_EXPECT(sponsoredOwnerCount(env, bob) == 0);
3401
3402 // Bob accepts: issuer's sponsorship ends, bob becomes unsponsored owner
3403 env(credentials::accept(bob, alice, credType));
3404 env.close();
3405
3406 BEAST_EXPECT(ownerCount(env, alice) == 0);
3407 BEAST_EXPECT(sponsoredOwnerCount(env, alice) == 0);
3408 BEAST_EXPECT(sponsoringOwnerCount(env, sponsor) == 0); // original sponsorship ended
3409 BEAST_EXPECT(ownerCount(env, bob) == 1);
3410 BEAST_EXPECT(sponsoredOwnerCount(env, bob) == 0); // bob owns it without a sponsor
3411
3412 // CredentialDelete by subject
3413 env(credentials::deleteCred(bob, bob, alice, credType));
3414 env.close();
3415
3416 BEAST_EXPECT(ownerCount(env, alice) == 0);
3417 BEAST_EXPECT(ownerCount(env, bob) == 0);
3418 BEAST_EXPECT(sponsoredOwnerCount(env, alice) == 0);
3419 BEAST_EXPECT(sponsoredOwnerCount(env, bob) == 0);
3420 BEAST_EXPECT(sponsoringOwnerCount(env, sponsor) == 0);
3421 }
3422
3423 // Issuer creates for subject; accept tx itself is reserve-sponsored
3424 // This exercises the checkReserve() call in CredentialAccept::doApply()
3425 // that guards the sponsor's reserve when featureSponsor is enabled.
3426 {
3427 Env env{*this, testableAmendments()};
3428 env.fund(XRP(1000000), alice, bob, sponsor);
3429 env.close();
3430
3431 // alice (issuer) creates credential for bob (subject) without sponsor
3432 env(credentials::create(bob, alice, credType));
3433 env.close();
3434
3435 auto const credKeylet = credentials::keylet(bob, alice, credType);
3436 BEAST_EXPECT(ownerCount(env, alice) == 1);
3437 BEAST_EXPECT(ownerCount(env, bob) == 0);
3438
3439 // Bob accepts with a sponsored reserve; the first attempt uses an
3440 // undercapitalized sponsor and must fail with tecINSUFFICIENT_RESERVE;
3441 // the second attempt uses a properly funded sponsor and must succeed.
3443 env,
3444 cosigning,
3445 sponsor,
3446 bob,
3447 1,
3448 1,
3450 [&](Env& env, auto const& submit) {
3451 submit(credentials::accept(bob, alice, credType));
3452 });
3453
3454 // After successful accept: alice (issuer) no longer owns the credential,
3455 // bob owns it and sponsor covers his reserve.
3456 BEAST_EXPECT(ownerCount(env, alice) == 0);
3457 BEAST_EXPECT(ownerCount(env, bob) == 1);
3458 BEAST_EXPECT(sponsoredOwnerCount(env, bob) == 1);
3459 BEAST_EXPECT(sponsoringOwnerCount(env, sponsor) == 1);
3460 BEAST_EXPECT(env.le(credKeylet)->getAccountID(sfSponsor) == sponsor.id());
3461
3462 // Cleanup
3463 env(credentials::deleteCred(bob, bob, alice, credType));
3464 env.close();
3465 }
3466 }
3467
3468 void
3469 testEscrow(bool cosigning)
3470 {
3471 testcase("Escrow");
3472 using namespace test::jtx;
3473 using namespace std::chrono_literals;
3474
3475 Account const alice("alice");
3476 Account const bob("bob");
3477 Account const sponsor("sponsor");
3478 Account const sponsor2("sponsor2");
3479 {
3480 // Native Escrow
3481 Env env{*this, testableAmendments()};
3482 auto const baseFee = env.current()->fees().base;
3483
3484 env.fund(XRP(1000000), alice, bob, sponsor, sponsor2);
3485 env.close();
3486
3487 // EscrowCreate
3488 uint32_t seq = 0;
3490 env,
3491 cosigning,
3492 sponsor,
3493 alice,
3494 1,
3495 1,
3497 [&](Env& env, auto const& submit) {
3498 seq = env.seq(alice);
3499 submit(
3500 escrow::create(alice, bob, XRP(100)),
3502 escrow::kCancelTime(env.now() + 100s));
3503 });
3504 BEAST_EXPECT(
3505 env.le(keylet::escrow(alice, SeqProxy::rawSequence(seq)))
3506 ->getAccountID(sfSponsor) == sponsor.id());
3507
3508 // transfer sponsor
3509 if (cosigning)
3510 {
3512 alice,
3513 tfSponsorshipReassign,
3514 keylet::escrow(alice, SeqProxy::rawSequence(seq)).key),
3515 sponsor::As(sponsor2, spfSponsorReserve),
3516 Sig(sfSponsorSignature, sponsor2));
3517 env.close();
3518 }
3519 else
3520 {
3521 env(sponsor::set_reserve(sponsor2, 0, 1), sponsor::SponseeAcc(alice));
3522 env.close();
3523
3525 alice,
3526 tfSponsorshipReassign,
3527 keylet::escrow(alice, SeqProxy::rawSequence(seq)).key),
3528 sponsor::As(sponsor2, spfSponsorReserve));
3529 env.close();
3530 }
3531
3532 BEAST_EXPECT(ownerCount(env, alice) == 1);
3533 BEAST_EXPECT(sponsoredOwnerCount(env, alice) == 1);
3534 BEAST_EXPECT(sponsoringOwnerCount(env, sponsor) == 0);
3535 BEAST_EXPECT(sponsoringOwnerCount(env, sponsor2) == 1);
3536
3537 BEAST_EXPECT(
3538 env.le(keylet::escrow(alice, SeqProxy::rawSequence(seq)))
3539 ->getAccountID(sfSponsor) == sponsor2.id());
3540
3541 // EscrowFinish
3542 env(escrow::finish(bob, alice, seq),
3545 Fee(baseFee * 150));
3546 env.close();
3547
3548 BEAST_EXPECT(ownerCount(env, alice) == 0);
3549 BEAST_EXPECT(sponsoredOwnerCount(env, alice) == 0);
3550 BEAST_EXPECT(sponsoringOwnerCount(env, sponsor) == 0);
3551 BEAST_EXPECT(sponsoringOwnerCount(env, sponsor2) == 0);
3552 }
3553
3554 {
3555 // Bytecode Escrow: its reserve scales with the Bytecode size, so
3556 // every leg of a sponsorship has to move the whole weight.
3557 auto env = Env{*this, testableAmendments()};
3558
3559 env.fund(XRP(1000000), alice, bob, sponsor, sponsor2);
3560 env.close();
3561
3562 auto const seq = env.seq(alice);
3563 env(escrow::create(alice, bob, XRP(100)),
3565 escrow::kCancelTime(env.now() + 100s));
3566 env.close();
3567
3568 auto const escrowKeylet = keylet::escrow(alice, SeqProxy::rawSequence(seq));
3569 std::size_t const bytecodeSize = 1200;
3570 std::uint32_t const bytecodeWeight = 3; // ceil(1200 / 500)
3571
3572 if (!cosigning)
3573 {
3574 env(sponsor::set_reserve(sponsor, 0, bytecodeWeight), sponsor::SponseeAcc(alice));
3575 env(sponsor::set_reserve(sponsor2, 0, bytecodeWeight), sponsor::SponseeAcc(alice));
3576 env.close();
3577 }
3578
3579 // EscrowCreate's preclaim runs the WASM preflight, so a real
3580 // 1200-byte contract cannot be assembled from here; the Bytecode
3581 // field is injected directly and the owner's OwnerCount restored
3582 // to the weight such a create would have charged.
3583 env.app().getOpenLedger().modify([&](OpenView& view, beast::Journal) -> bool {
3584 auto const existing = view.read(escrowKeylet);
3585 if (!existing)
3586 {
3587 return false;
3588 }
3589 auto const escrowSle = std::make_shared<SLE>(*existing);
3590 auto const account = std::make_shared<SLE>(*view.read(keylet::account(alice.id())));
3591 escrowSle->setFieldVL(sfBytecode, Blob(bytecodeSize, 0x00));
3592 account->setFieldU32(sfOwnerCount, bytecodeWeight);
3593 view.rawReplace(escrowSle);
3594 view.rawReplace(account);
3595 return true;
3596 });
3597 BEAST_EXPECT(ownerCount(env, alice) == bytecodeWeight);
3598
3599 std::optional<Sig> const sponsorSig =
3600 cosigning ? std::optional<Sig>(Sig(sfSponsorSignature, sponsor)) : std::nullopt;
3601 std::optional<Sig> const sponsor2Sig =
3602 cosigning ? std::optional<Sig>(Sig(sfSponsorSignature, sponsor2)) : std::nullopt;
3603
3604 // create sponsor: charges the whole bytecode weight, not 1
3605 if (sponsorSig)
3606 {
3607 env(sponsor::transfer(alice, tfSponsorshipCreate, escrowKeylet.key),
3609 *sponsorSig);
3610 }
3611 else
3612 {
3613 env(sponsor::transfer(alice, tfSponsorshipCreate, escrowKeylet.key),
3615 }
3616
3617 BEAST_EXPECT(sponsoredOwnerCount(env, alice) == bytecodeWeight);
3618 BEAST_EXPECT(sponsoringOwnerCount(env, sponsor) == bytecodeWeight);
3619 BEAST_EXPECT(env.le(escrowKeylet)->getAccountID(sfSponsor) == sponsor.id());
3620
3621 // transfer sponsor: moves the whole weight between the two sponsors
3622 if (sponsor2Sig)
3623 {
3624 env(sponsor::transfer(alice, tfSponsorshipReassign, escrowKeylet.key),
3625 sponsor::As(sponsor2, spfSponsorReserve),
3626 *sponsor2Sig);
3627 }
3628 else
3629 {
3630 env(sponsor::transfer(alice, tfSponsorshipReassign, escrowKeylet.key),
3631 sponsor::As(sponsor2, spfSponsorReserve));
3632 }
3633
3634 BEAST_EXPECT(sponsoredOwnerCount(env, alice) == bytecodeWeight);
3635 BEAST_EXPECT(sponsoringOwnerCount(env, sponsor) == 0);
3636 BEAST_EXPECT(sponsoringOwnerCount(env, sponsor2) == bytecodeWeight);
3637 BEAST_EXPECT(env.le(escrowKeylet)->getAccountID(sfSponsor) == sponsor2.id());
3638
3639 // end sponsor: hands the whole weight back to the owner
3640 env(sponsor::transfer(alice, tfSponsorshipEnd, escrowKeylet.key));
3641
3642 BEAST_EXPECT(ownerCount(env, alice) == bytecodeWeight);
3643 BEAST_EXPECT(sponsoredOwnerCount(env, alice) == 0);
3644 BEAST_EXPECT(sponsoringOwnerCount(env, sponsor) == 0);
3645 BEAST_EXPECT(sponsoringOwnerCount(env, sponsor2) == 0);
3646 BEAST_EXPECT(!env.le(escrowKeylet)->isFieldPresent(sfSponsor));
3647 }
3648
3649 Account const gw("gw");
3650 auto const usd = gw["usd"];
3651 {
3652 // IOU Escrow
3653 Env env{*this, testableAmendments()};
3654 auto const baseFee = env.current()->fees().base;
3655
3656 env.fund(XRP(1000000), alice, bob, gw, sponsor, sponsor2);
3657 env.close();
3658
3659 env(fset(gw, asfAllowTrustLineLocking));
3660 env.close();
3661
3662 env.trust(usd(1000000), alice);
3663 env.close();
3664 env(pay(gw, alice, usd(10000)));
3665 env.close();
3666
3667 BEAST_EXPECT(ownerCount(env, alice) == 1);
3668
3669 // EscrowCreate
3670 uint32_t seq = 0;
3672 env,
3673 cosigning,
3674 sponsor,
3675 alice,
3676 1,
3677 1,
3679 [&](Env& env, auto const& submit) {
3680 seq = env.seq(alice);
3681 submit(
3682 escrow::create(alice, bob, usd(100)),
3684 escrow::kCancelTime(env.now() + 100s));
3685 });
3686
3687 BEAST_EXPECT(
3688 env.le(keylet::escrow(alice, SeqProxy::rawSequence(seq)))
3689 ->getAccountID(sfSponsor) == sponsor.id());
3690
3691 // EscrowFinish
3693 env,
3694 cosigning,
3695 sponsor2,
3696 bob,
3697 1,
3698 1,
3700 [&](Env& env, auto const& submit) {
3701 submit(
3702 escrow::finish(bob, alice, seq),
3705 Fee(baseFee * 150));
3706 });
3707
3708 BEAST_EXPECT(ownerCount(env, alice) == 1);
3709 BEAST_EXPECT(sponsoredOwnerCount(env, alice) == 0);
3710 BEAST_EXPECT(sponsoringOwnerCount(env, sponsor) == 0);
3711
3712 BEAST_EXPECT(
3713 env.le(keylet::trustLine(bob, gw, usd.currency))->getAccountID(sfHighSponsor) ==
3714 sponsor2.id());
3715 }
3716 {
3717 // IOU EscrowFinish recycles reserve when the same sponsor backs
3718 // the escrow being removed and the destination line being created.
3719 Env env{*this, testableAmendments()};
3720 auto const baseFee = env.current()->fees().base;
3721
3722 env.fund(XRP(1000000), alice, bob, gw, sponsor);
3723 env.close();
3724
3725 env(fset(gw, asfAllowTrustLineLocking));
3726 env.close();
3727
3728 env.trust(usd(1000000), alice);
3729 env.close();
3730 env(pay(gw, alice, usd(10000)));
3731 env.close();
3732
3733 uint32_t seq = 0;
3735 env,
3736 cosigning,
3737 sponsor,
3738 alice,
3739 1,
3740 1,
3742 [&](Env& env, auto const& submit) {
3743 seq = env.seq(alice);
3744 submit(
3745 escrow::create(alice, bob, usd(100)),
3747 escrow::kCancelTime(env.now() + 100s));
3748 });
3749
3750 BEAST_EXPECT(
3751 env.le(keylet::escrow(alice, SeqProxy::rawSequence(seq)))
3752 ->getAccountID(sfSponsor) == sponsor.id());
3753
3754 if (cosigning)
3755 {
3757 }
3758 else
3759 {
3761 env.close();
3762 }
3763
3764 if (cosigning)
3765 {
3766 env(escrow::finish(bob, alice, seq),
3770 Sig(sfSponsorSignature, sponsor),
3771 Fee(baseFee * 150),
3772 Ter(tesSUCCESS));
3773 }
3774 else
3775 {
3776 env(escrow::finish(bob, alice, seq),
3780 Fee(baseFee * 150),
3781 Ter(tesSUCCESS));
3782 }
3783 env.close();
3784
3785 BEAST_EXPECT(ownerCount(env, alice) == 1);
3786 BEAST_EXPECT(ownerCount(env, bob) == 1);
3787 BEAST_EXPECT(sponsoredOwnerCount(env, alice) == 0);
3788 BEAST_EXPECT(sponsoredOwnerCount(env, bob) == 1);
3789 BEAST_EXPECT(sponsoringOwnerCount(env, sponsor) == 1);
3790
3791 BEAST_EXPECT(
3792 env.le(keylet::trustLine(bob, gw, usd.currency))->getAccountID(sfHighSponsor) ==
3793 sponsor.id());
3794 }
3795 {
3796 // IOU Escrow cancel re-creates the owner's trust line, and the
3797 // cancel transaction's sponsor can cover that new line's reserve.
3798 // Creating an IOU escrow moves the sender's balance to the issuer,
3799 // so the sender can delete their now-zero trust line while the
3800 // escrow is pending. Cancelling returns the funds, re-creating the
3801 // line.
3802 Env env{*this, testableAmendments()};
3803
3804 env.fund(XRP(1000000), alice, bob, gw, sponsor, sponsor2);
3805 env.close();
3806
3807 env(fset(gw, asfAllowTrustLineLocking));
3808 env.close();
3809
3810 env.trust(usd(1000000), alice);
3811 env.close();
3812 env(pay(gw, alice, usd(10000)));
3813 env.close();
3814
3815 BEAST_EXPECT(ownerCount(env, alice) == 1);
3816
3817 // alice escrows her entire balance so the trust line can be removed
3818 auto const cancelAfter = env.now() + 100s;
3819 auto const seq = env.seq(alice);
3820 env(escrow::create(alice, bob, usd(10000)),
3822 escrow::kCancelTime(cancelAfter));
3823 env.close();
3824
3825 BEAST_EXPECT(ownerCount(env, alice) == 2); // trust line + escrow
3826
3827 // alice deletes her now-zero trust line while the escrow is pending
3828 env(trust(alice, usd(0)));
3829 env.close();
3830 BEAST_EXPECT(!env.le(keylet::trustLine(alice, gw, usd.currency)));
3831 BEAST_EXPECT(ownerCount(env, alice) == 1); // just the escrow
3832
3833 // advance the ledger past the cancel time
3834 for (; env.now() < cancelAfter; env.close())
3835 {
3836 }
3837
3838 // EscrowCancel by alice re-creates her trust line; the sponsor
3839 // covers the new line's reserve. On the insufficient-reserve
3840 // attempt the whole transaction rolls back, leaving the escrow
3841 // intact to be cancelled on the success attempt.
3842 bool const aliceLow = alice.id() < gw.id();
3844 env,
3845 cosigning,
3846 sponsor,
3847 alice,
3848 1,
3849 1,
3851 [&](Env& env, auto const& submit) { submit(escrow::cancel(alice, alice, seq)); },
3852 [&] {
3853 BEAST_EXPECT(!env.le(keylet::escrow(alice, SeqProxy::rawSequence(seq))));
3854 auto const trustSle = env.le(keylet::trustLine(alice, gw, usd.currency));
3855 BEAST_EXPECT(trustSle);
3856 if (trustSle)
3857 {
3858 BEAST_EXPECT(
3859 trustSle->getAccountID(aliceLow ? sfLowSponsor : sfHighSponsor) ==
3860 sponsor.id());
3861 BEAST_EXPECT(
3862 !trustSle->isFieldPresent(aliceLow ? sfHighSponsor : sfLowSponsor));
3863 }
3864 BEAST_EXPECT(ownerCount(env, alice) == 1); // re-created trust line
3865 BEAST_EXPECT(sponsoredOwnerCount(env, alice) == 1);
3866 BEAST_EXPECT(sponsoringOwnerCount(env, sponsor) == 1);
3867 });
3868 }
3869 {
3870 // MPT Escrow
3871 Env env{*this, testableAmendments()};
3872 env.fund(XRP(1000000), bob, sponsor);
3873 env.close();
3874
3875 MPTTester mptGw(env, gw, {.holders = {alice}});
3876 mptGw.create(
3877 {.ownerCount = 1, .holderCount = 0, .flags = tfMPTCanEscrow | tfMPTCanTransfer});
3878 mptGw.authorize({.account = alice});
3879 auto const mpt = mptGw["MPT"];
3880 env(pay(gw, alice, mpt(10'000)));
3881 env.close();
3882
3883 // create Escrow from alice to bob
3884 auto const seq = env.seq(alice);
3885 env(escrow::create(alice, bob, mpt(100)),
3887 escrow::kCancelTime(env.now() + 100s));
3888 env.close();
3889
3890 BEAST_EXPECT(ownerCount(env, alice) == 2);
3891 BEAST_EXPECT(ownerCount(env, bob) == 0);
3892 BEAST_EXPECT(sponsoringOwnerCount(env, sponsor) == 0);
3893
3894 // finish Escrow: bob has no MPToken, so finishing creates one and
3895 // the finish transaction's sponsor covers its reserve. The MPT
3896 // create-token path returns tecINSUFFICIENT_RESERVE (not
3897 // tecNO_LINE_INSUF_RESERVE) when the sponsor is underfunded.
3899 env,
3900 cosigning,
3901 sponsor,
3902 bob,
3903 1,
3904 1,
3906 [&](Env& env, auto const& submit) {
3907 submit(
3908 escrow::finish(bob, alice, seq),
3911 Fee(XRP(1)));
3912 });
3913
3914 BEAST_EXPECT(ownerCount(env, alice) == 1);
3915 BEAST_EXPECT(ownerCount(env, bob) == 1);
3916 BEAST_EXPECT(sponsoredOwnerCount(env, bob) == 1);
3917 BEAST_EXPECT(sponsoringOwnerCount(env, sponsor) == 1);
3918 BEAST_EXPECT(
3919 env.le(keylet::mptoken(mptGw.issuanceID(), bob))->getAccountID(sfSponsor) ==
3920 sponsor.id());
3921 }
3922 {
3923 // MPT EscrowFinish has the same reserve recycling behavior as IOU
3924 // when it creates the destination MPToken.
3925 Env env{*this, testableAmendments()};
3926 auto const baseFee = env.current()->fees().base;
3927 env.fund(XRP(1000000), bob, sponsor);
3928 env.close();
3929
3930 MPTTester mptGw(env, gw, {.holders = {alice}});
3931 mptGw.create(
3932 {.ownerCount = 1, .holderCount = 0, .flags = tfMPTCanEscrow | tfMPTCanTransfer});
3933 mptGw.authorize({.account = alice});
3934 auto const mpt = mptGw["MPT"];
3935 env(pay(gw, alice, mpt(10'000)));
3936 env.close();
3937
3938 uint32_t seq = 0;
3940 env,
3941 cosigning,
3942 sponsor,
3943 alice,
3944 1,
3945 1,
3947 [&](Env& env, auto const& submit) {
3948 seq = env.seq(alice);
3949 submit(
3950 escrow::create(alice, bob, mpt(100)),
3952 escrow::kCancelTime(env.now() + 100s));
3953 });
3954
3955 BEAST_EXPECT(
3956 env.le(keylet::escrow(alice, SeqProxy::rawSequence(seq)))
3957 ->getAccountID(sfSponsor) == sponsor.id());
3958
3959 if (cosigning)
3960 {
3962 }
3963 else
3964 {
3966 env.close();
3967 }
3968
3969 if (cosigning)
3970 {
3971 env(escrow::finish(bob, alice, seq),
3975 Sig(sfSponsorSignature, sponsor),
3976 Fee(baseFee * 150),
3977 Ter(tesSUCCESS));
3978 }
3979 else
3980 {
3981 env(escrow::finish(bob, alice, seq),
3985 Fee(baseFee * 150),
3986 Ter(tesSUCCESS));
3987 }
3988 env.close();
3989
3990 BEAST_EXPECT(ownerCount(env, alice) == 1);
3991 BEAST_EXPECT(ownerCount(env, bob) == 1);
3992 BEAST_EXPECT(sponsoredOwnerCount(env, alice) == 0);
3993 BEAST_EXPECT(sponsoredOwnerCount(env, bob) == 1);
3994 BEAST_EXPECT(sponsoringOwnerCount(env, sponsor) == 1);
3995
3996 BEAST_EXPECT(
3997 env.le(keylet::mptoken(mptGw.issuanceID(), bob))->getAccountID(sfSponsor) ==
3998 sponsor.id());
3999 }
4000
4001 // A sponsored EscrowCreate must still verify that the source
4002 // can fund the escrow amount and stay above its own base
4003 // reserve. The sponsor covers the new object's owner
4004 // increment, but cannot cover the source's base reserve.
4005 {
4006 Env env{*this, testableAmendments()};
4007 env.fund(XRP(10000), alice, bob, sponsor);
4008 env.close();
4009
4010 // alice's balance is just above the base reserve. After
4011 // locking escrowAmount she would dip below it.
4012 adjustAccountXRPBalance(env, alice, accountReserve(env, 1) + XRP(1));
4013
4014 auto const escrowAmount = XRP(2);
4015 auto const seq = env.seq(alice);
4016
4017 if (cosigning)
4018 {
4019 env(escrow::create(alice, bob, escrowAmount),
4021 escrow::kCancelTime(env.now() + 100s),
4023 Sig(sfSponsorSignature, sponsor),
4024 Ter(tecUNFUNDED));
4025 }
4026 else
4027 {
4028 env(sponsor::set(sponsor, 0, 1, XRP(1)), sponsor::SponseeAcc(alice));
4029 env.close();
4030
4031 env(escrow::create(alice, bob, escrowAmount),
4033 escrow::kCancelTime(env.now() + 100s),
4035 Ter(tecUNFUNDED));
4036 }
4037 env.close();
4038
4039 BEAST_EXPECT(!env.le(keylet::escrow(alice, SeqProxy::rawSequence(seq))));
4040 BEAST_EXPECT(ownerCount(env, alice) == 0);
4041 BEAST_EXPECT(sponsoredOwnerCount(env, alice) == 0);
4042 BEAST_EXPECT(sponsoringOwnerCount(env, sponsor) == 0);
4043 }
4044 }
4045
4046 void
4047 testMPToken(bool cosigning)
4048 {
4049 testcase("MPToken");
4050 using namespace test::jtx;
4051 Account const alice("alice");
4052 Account const bob("bob");
4053 Account const sponsor("sponsor");
4054 Account const sponsor2("sponsor2");
4055
4056 {
4057 Env env{*this, testableAmendments()};
4058 env.fund(XRP(1000000), alice, bob, sponsor, sponsor2);
4059 env.close();
4060
4061 // MPTokenIssuanceCreate
4062 json::Value jv = {};
4063 jv[sfAccount] = alice.human();
4064 jv[sfTransactionType] = jss::MPTokenIssuanceCreate;
4065 MPTID mptid;
4067 env,
4068 cosigning,
4069 sponsor,
4070 alice,
4071 1,
4072 1,
4074 [&](Env& env, auto const& submit) {
4075 mptid = makeMptID(env.seq(alice), alice.id());
4076 submit(jv);
4077 });
4078
4079 // transfer sponsor
4080 auto const mptIssuanceKeylet = keylet::mptokenIssuance(mptid);
4081
4082 if (cosigning)
4083 {
4084 env(sponsor::transfer(alice, tfSponsorshipReassign, mptIssuanceKeylet.key),
4085 sponsor::As(sponsor2, spfSponsorReserve),
4086 Sig(sfSponsorSignature, sponsor2));
4087 env.close();
4088 }
4089 else
4090 {
4091 env(sponsor::set_reserve(sponsor2, 0, 1), sponsor::SponseeAcc(alice));
4092 env.close();
4093
4094 env(sponsor::transfer(alice, tfSponsorshipReassign, mptIssuanceKeylet.key),
4095 sponsor::As(sponsor2, spfSponsorReserve));
4096 env.close();
4097 }
4098
4099 // MPTokenAuthorize
4100 jv = {};
4101 jv[sfTransactionType] = jss::MPTokenAuthorize;
4102 jv[sfAccount] = bob.human();
4103 jv[sfMPTokenIssuanceID] = to_string(mptid);
4104
4105 if (cosigning)
4106 {
4108 env(ticket::create(sponsor, 2)); // adjust for free mptoken
4109 env.close();
4110 }
4111
4113 env,
4114 cosigning,
4115 sponsor,
4116 bob,
4117 1,
4118 1,
4120 [&](Env& env, auto const& submit) { submit(jv); });
4121
4122 BEAST_EXPECT(ownerCount(env, alice) == 1);
4123 BEAST_EXPECT(sponsoredOwnerCount(env, alice) == 1);
4124
4125 // transfer sponsor
4126 auto const mptTokenKeylet = keylet::mptoken(mptid, bob);
4127 if (cosigning)
4128 {
4129 env(sponsor::transfer(bob, tfSponsorshipReassign, mptTokenKeylet.key),
4130 sponsor::As(sponsor2, spfSponsorReserve),
4131 Sig(sfSponsorSignature, sponsor2));
4132 env.close();
4133 }
4134 else
4135 {
4136 env(sponsor::set_reserve(sponsor2, 0, 1), sponsor::SponseeAcc(bob));
4137 env.close();
4138
4139 env(sponsor::transfer(bob, tfSponsorshipReassign, mptTokenKeylet.key),
4140 sponsor::As(sponsor2, spfSponsorReserve));
4141 env.close();
4142 }
4143
4144 BEAST_EXPECT(ownerCount(env, alice) == 1);
4145 BEAST_EXPECT(ownerCount(env, bob) == 1);
4146 BEAST_EXPECT(sponsoredOwnerCount(env, alice) == 1);
4147 BEAST_EXPECT(sponsoredOwnerCount(env, bob) == 1);
4148 BEAST_EXPECT(sponsoringOwnerCount(env, sponsor) == 0);
4149 BEAST_EXPECT(sponsoringOwnerCount(env, sponsor2) == 2);
4150
4151 // MPTokenAuthorize Unauthorize
4152 jv = {};
4153 jv[sfTransactionType] = jss::MPTokenAuthorize;
4154 jv[sfAccount] = bob.human();
4155 jv[sfMPTokenIssuanceID] = to_string(mptid);
4156 jv[sfFlags] = tfMPTUnauthorize;
4157 env(jv);
4158 env.close();
4159
4160 BEAST_EXPECT(ownerCount(env, alice) == 1);
4161 BEAST_EXPECT(ownerCount(env, bob) == 0);
4162 BEAST_EXPECT(sponsoredOwnerCount(env, alice) == 1);
4163 BEAST_EXPECT(sponsoredOwnerCount(env, bob) == 0);
4164 BEAST_EXPECT(sponsoringOwnerCount(env, sponsor2) == 1);
4165
4166 // MPTokenIssuanceDestroy
4167 jv = {};
4168 jv[sfTransactionType] = jss::MPTokenIssuanceDestroy;
4169 jv[sfAccount] = alice.human();
4170 jv[sfMPTokenIssuanceID] = to_string(mptid);
4171 env(jv);
4172 env.close();
4173
4174 BEAST_EXPECT(ownerCount(env, alice) == 0);
4175 BEAST_EXPECT(sponsoredOwnerCount(env, alice) == 0);
4176 BEAST_EXPECT(sponsoringOwnerCount(env, sponsor2) == 0);
4177 }
4178 {
4179 // check INSUFFICIENT_RESERVE for MPToken
4180 Env env{*this, testableAmendments()};
4181 env.fund(XRP(1000000), alice, bob, sponsor);
4182 env.close();
4183
4184 // MPTokenAuthorize
4185 json::Value jv = {};
4186 jv[sfAccount] = alice.human();
4187 jv[sfTransactionType] = jss::MPTokenIssuanceCreate;
4188 auto const mptid = makeMptID(env.seq(alice), alice.id());
4189 env(jv);
4190 env.close();
4191
4192 // Create tickets so the sponsor is past free-tier reserve behavior.
4193 std::uint32_t const ticketSeq{env.seq(sponsor) + 1};
4194 env(ticket::create(sponsor, 2));
4195 env.close();
4196
4197 jv = {};
4198 jv[sfTransactionType] = jss::MPTokenAuthorize;
4199 jv[sfAccount] = bob.human();
4200 jv[sfMPTokenIssuanceID] = to_string(mptid);
4201 // error (non-free mptoken)
4202 if (cosigning)
4203 {
4204 adjustAccountXRPBalance(env, sponsor, reserve(env, 3) - drops(1));
4205 env(jv,
4207 Sig(sfSponsorSignature, sponsor),
4209 env.close();
4210 }
4211 else
4212 {
4213 env(sponsor::set(sponsor, 0, std::nullopt, XRP(1)), sponsor::SponseeAcc(bob));
4214 env.close();
4215
4217 env.close();
4218 }
4219
4220 env(noop(sponsor), ticket::Use(ticketSeq));
4221 env.close();
4222
4223 // pass (free-tier mptoken for the holder, but the sponsor is still
4224 // charged a reserve increment regardless of the ownerCount < 2 shortcut).
4225 if (cosigning)
4226 {
4228 env(jv,
4230 Sig(sfSponsorSignature, sponsor),
4231 Ter(tesSUCCESS));
4232 env.close();
4233 }
4234 else
4235 {
4237 env.close();
4239 env.close();
4240 }
4241 }
4242 }
4243
4244 void
4245 testPayChan(bool cosigning)
4246 {
4247 testcase("PayChan");
4248 using namespace test::jtx;
4249 using namespace std::literals::chrono_literals;
4250 Account const alice("alice");
4251 Account const bob("bob");
4252 Account const sponsor("sponsor");
4253 Account const sponsor2("sponsor2");
4254
4255 {
4256 Env env{*this, testableAmendments()};
4257 env.fund(XRP(1000000), alice, bob, sponsor, sponsor2);
4258 env.close();
4259
4260 // PayChanCreate
4261 auto const pk = alice.pk();
4262 auto const settleDelay = 10s;
4263 UInt256 chan;
4265 env,
4266 cosigning,
4267 sponsor,
4268 alice,
4269 1,
4270 1,
4272 [&](Env& env, auto const& submit) {
4273 chan = paychan::channel(alice, bob, env.seq(alice));
4274 submit(paychan::create(alice, bob, XRP(100), settleDelay, pk));
4275 });
4276
4277 // the created PayChannel object carries the sponsor
4278 BEAST_EXPECT(env.le(Keylet(ltPAYCHAN, chan))->getAccountID(sfSponsor) == sponsor.id());
4279
4280 // transfer sponsor
4281 if (cosigning)
4282 {
4283 env(sponsor::transfer(alice, tfSponsorshipReassign, chan),
4284 sponsor::As(sponsor2, spfSponsorReserve),
4285 Sig(sfSponsorSignature, sponsor2));
4286 env.close();
4287 }
4288 else
4289 {
4290 env(sponsor::set_reserve(sponsor2, 0, 1), sponsor::SponseeAcc(alice));
4291 env.close();
4292
4293 env(sponsor::transfer(alice, tfSponsorshipReassign, chan),
4294 sponsor::As(sponsor2, spfSponsorReserve));
4295 env.close();
4296 }
4297
4298 BEAST_EXPECT(ownerCount(env, alice) == 1);
4299 BEAST_EXPECT(sponsoredOwnerCount(env, alice) == 1);
4300 BEAST_EXPECT(sponsoringOwnerCount(env, sponsor) == 0);
4301 BEAST_EXPECT(sponsoringOwnerCount(env, sponsor2) == 1);
4302 BEAST_EXPECT(env.le(Keylet(ltPAYCHAN, chan))->getAccountID(sfSponsor) == sponsor2.id());
4303
4304 env.close(env.now() + settleDelay);
4305 // PayChanClaim (delete PayChan)
4306 env(paychan::claim(bob, chan), Txflags(tfClose));
4307 env.close();
4308
4309 BEAST_EXPECT(ownerCount(env, alice) == 0);
4310 BEAST_EXPECT(sponsoredOwnerCount(env, alice) == 0);
4311 BEAST_EXPECT(sponsoringOwnerCount(env, sponsor) == 0);
4312 BEAST_EXPECT(sponsoringOwnerCount(env, sponsor2) == 0);
4313 }
4314
4315 // A sponsored PaymentChannelCreate must still verify that the
4316 // source can fund the channel amount and stay above its own
4317 // base reserve. The sponsor covers the new object's owner
4318 // increment, but cannot cover the source's base reserve.
4319 {
4320 Env env{*this, testableAmendments()};
4321 env.fund(XRP(10000), alice, bob, sponsor);
4322 env.close();
4323
4324 // alice's balance is just above the base reserve. After
4325 // locking channelAmount she would dip below it.
4326 adjustAccountXRPBalance(env, alice, accountReserve(env, 1) + XRP(1));
4327
4328 auto const pk = alice.pk();
4329 auto const settleDelay = 10s;
4330 auto const channelAmount = XRP(2);
4331 auto const chan = paychan::channel(alice, bob, env.seq(alice));
4332
4333 if (cosigning)
4334 {
4335 env(paychan::create(alice, bob, channelAmount, settleDelay, pk),
4337 Sig(sfSponsorSignature, sponsor),
4338 Ter(tecUNFUNDED));
4339 }
4340 else
4341 {
4342 env(sponsor::set(sponsor, 0, 1, XRP(1)), sponsor::SponseeAcc(alice));
4343 env.close();
4344
4345 env(paychan::create(alice, bob, channelAmount, settleDelay, pk),
4347 Ter(tecUNFUNDED));
4348 }
4349 env.close();
4350
4351 BEAST_EXPECT(!paychan::channelExists(*env.current(), chan));
4352 BEAST_EXPECT(ownerCount(env, alice) == 0);
4353 BEAST_EXPECT(sponsoredOwnerCount(env, alice) == 0);
4354 BEAST_EXPECT(sponsoringOwnerCount(env, sponsor) == 0);
4355 }
4356 }
4357
4358 void
4359 testSignerList(bool cosigning)
4360 {
4361 testcase("SignerList");
4362 using namespace test::jtx;
4363 Account const alice("alice");
4364 Account const bob("bob");
4365 Account const sponsor("sponsor");
4366 Account const sponsor2("sponsor2");
4367
4368 Env env{*this, testableAmendments()};
4369 env.fund(XRP(1000000), alice, bob, sponsor, sponsor2);
4370 env.close();
4371
4372 // SignerListSet
4374 env,
4375 cosigning,
4376 sponsor,
4377 alice,
4378 1,
4379 1,
4381 [&](Env& env, auto const& submit) { submit(signers(alice, 1, {{bob, 1}})); });
4382
4383 // the created SignerList object carries the sponsor
4384 BEAST_EXPECT(env.le(keylet::signerList(alice))->getAccountID(sfSponsor) == sponsor.id());
4385
4386 // transfer sponsor
4387 if (cosigning)
4388 {
4389 // invalid signer list owner 1
4390 // account doesn't have signer list but specified signer list exists
4391 env(sponsor::transfer(bob, tfSponsorshipReassign, keylet::signerList(alice).key),
4392 sponsor::As(sponsor2, spfSponsorReserve),
4393 Sig(sfSponsorSignature, sponsor2),
4395 // invalid signer list owner 2
4396 // account has signer list and specified signer list exists
4397 env(signers(bob, 1, {{alice, 1}}));
4398 env.close();
4399 env(sponsor::transfer(alice, tfSponsorshipReassign, keylet::signerList(bob).key),
4400 sponsor::As(sponsor2, spfSponsorReserve),
4401 Sig(sfSponsorSignature, sponsor2),
4403 env(sponsor::transfer(alice, tfSponsorshipReassign, keylet::signerList(alice).key),
4404 sponsor::As(sponsor2, spfSponsorReserve),
4405 Sig(sfSponsorSignature, sponsor2));
4406 env.close();
4407 }
4408 else
4409 {
4410 env(sponsor::set_reserve(sponsor2, 0, 1), sponsor::SponseeAcc(alice));
4411 env.close();
4412 env(sponsor::transfer(alice, tfSponsorshipReassign, keylet::signerList(alice).key),
4413 sponsor::As(sponsor2, spfSponsorReserve));
4414 env.close();
4415 }
4416
4417 BEAST_EXPECT(ownerCount(env, alice) == 1);
4418 BEAST_EXPECT(sponsoredOwnerCount(env, alice) == 1);
4419 BEAST_EXPECT(sponsoringOwnerCount(env, sponsor) == 0);
4420 BEAST_EXPECT(sponsoringOwnerCount(env, sponsor2) == 1);
4421 BEAST_EXPECT(env.le(keylet::signerList(alice))->getAccountID(sfSponsor) == sponsor2.id());
4422
4423 // Delete
4424 env(signers(alice, NoneT()));
4425 env.close();
4426
4427 BEAST_EXPECT(ownerCount(env, alice) == 0);
4428 BEAST_EXPECT(sponsoredOwnerCount(env, alice) == 0);
4429 BEAST_EXPECT(sponsoringOwnerCount(env, sponsor) == 0);
4430 BEAST_EXPECT(sponsoringOwnerCount(env, sponsor2) == 0);
4431 }
4432
4433 // Legacy (pre-MultiSignReserve) SignerLists lack lsfOneOwnerCount and cost
4434 // 2 + signer_count owner units, whereas modern lists cost 1.
4435 void
4437 {
4438 testcase("Legacy SignerList sponsorship reserve");
4439 using namespace test::jtx;
4440
4441 Account const alice("alice");
4442 Account const bob("bob");
4443 Account const carol("carol");
4444 Account const dave("dave");
4445 Account const sponsor("sponsor");
4446
4447 Env env{*this, testableAmendments()};
4448 env.fund(XRP(1000000), alice, bob, carol, dave, sponsor);
4449 env.close();
4450
4451 // Modern 3-signer list: weight 1, lsfOneOwnerCount set.
4452 env(signers(alice, 1, {{bob, 1}, {carol, 1}, {dave, 1}}));
4453 env.close();
4454
4455 auto const signerListKeylet = keylet::signerList(alice.id());
4456 auto const sponsorKeylet = keylet::sponsorship(sponsor.id(), alice.id());
4457 std::uint32_t const legacyWeight = 5; // 2 + 3 signers
4458 BEAST_EXPECT(ownerCount(env, alice) == 1);
4459
4460 // Pre-fund exactly the legacy weight
4461 env(sponsor::set_reserve(sponsor, 0, legacyWeight), sponsor::SponseeAcc(alice));
4462 env.close();
4463 if (auto const sle = env.le(sponsorKeylet); BEAST_EXPECT(sle))
4464 BEAST_EXPECT(sle->getFieldU32(sfRemainingOwnerCount) == legacyWeight);
4465
4466 // Synthesize a pre-MultiSignReserve list: clear lsfOneOwnerCount and
4467 // restore the owner's OwnerCount to the legacy weight.
4468 env.app().getOpenLedger().modify([&](OpenView& view, beast::Journal) -> bool {
4469 auto const signerList = std::make_shared<SLE>(*view.read(signerListKeylet));
4470 auto const account = std::make_shared<SLE>(*view.read(keylet::account(alice.id())));
4471 signerList->clearFlag(lsfOneOwnerCount);
4472 account->setFieldU32(sfOwnerCount, legacyWeight);
4473 view.rawReplace(signerList);
4474 view.rawReplace(account);
4475 return true;
4476 });
4477 if (auto const sle = env.le(signerListKeylet); BEAST_EXPECT(sle))
4478 BEAST_EXPECT((sle->getFlags() & lsfOneOwnerCount) == 0);
4479 BEAST_EXPECT(ownerCount(env, alice) == legacyWeight);
4480
4481 // Create must charge the full legacy weight (5), not 1: the bug bumped
4482 // the counters by 1 and left 4 pre-funded units unspent.
4483 env(sponsor::transfer(alice, tfSponsorshipCreate, signerListKeylet.key),
4485
4486 BEAST_EXPECT(sponsoredOwnerCount(env, alice) == legacyWeight);
4487 BEAST_EXPECT(sponsoringOwnerCount(env, sponsor) == legacyWeight);
4488 // All pre-funded units consumed (drained to absent).
4489 if (auto const sle = env.le(sponsorKeylet); BEAST_EXPECT(sle))
4490 BEAST_EXPECT(!sle->isFieldPresent(sfRemainingOwnerCount));
4491
4492 // Delete unwinds the legacy weight; create bumped by the same amount, so
4493 // the counters return to 0 (the bug bumped by 1 -> underflow on delete).
4494 env(signers(alice, NoneT()));
4495
4496 BEAST_EXPECT(!env.le(signerListKeylet));
4497 BEAST_EXPECT(ownerCount(env, alice) == 0);
4498 BEAST_EXPECT(sponsoredOwnerCount(env, alice) == 0);
4499 BEAST_EXPECT(sponsoringOwnerCount(env, sponsor) == 0);
4500 if (auto const sle = env.le(sponsorKeylet); BEAST_EXPECT(sle))
4501 BEAST_EXPECT(!sle->isFieldPresent(sfRemainingOwnerCount));
4502 }
4503
4504 // An escrow carrying Bytecode costs one owner count per 500 bytes, so
4505 // sponsoring one must move that full weight rather than a single unit.
4506 void
4508 {
4509 testcase("Bytecode escrow sponsorship reserve");
4510 using namespace test::jtx;
4511 using namespace std::chrono_literals;
4512
4513 auto const alice = Account{"alice"};
4514 auto const bob = Account{"bob"};
4515 auto const sponsor = Account{"sponsor"};
4516
4517 auto env = Env{*this, testableAmendments()};
4518 env.fund(XRP(1000000), alice, bob, sponsor);
4519 env.close();
4520
4521 auto const seq = env.seq(alice);
4522 env(escrow::create(alice, bob, XRP(100)),
4524 escrow::kCancelTime(env.now() + 100s));
4525 env.close();
4526
4527 auto const escrowKeylet = keylet::escrow(alice, SeqProxy::rawSequence(seq));
4528 auto const sponsorKeylet = keylet::sponsorship(sponsor.id(), alice.id());
4529 std::size_t const bytecodeSize = 1200;
4530 std::uint32_t const bytecodeWeight = 3; // ceil(1200 / 500)
4531 BEAST_EXPECT(ownerCount(env, alice) == 1);
4532
4533 // Pre-fund exactly the bytecode weight
4534 env(sponsor::set_reserve(sponsor, 0, bytecodeWeight), sponsor::SponseeAcc(alice));
4535 env.close();
4536 if (auto const sle = env.le(sponsorKeylet); BEAST_EXPECT(sle))
4537 {
4538 BEAST_EXPECT(sle->getFieldU32(sfRemainingOwnerCount) == bytecodeWeight);
4539 }
4540
4541 // Synthesize a bytecode escrow. EscrowCreate's preclaim runs the WASM
4542 // preflight, so a real 1200-byte contract cannot be assembled from
4543 // here; the Bytecode field is injected directly and the owner's
4544 // OwnerCount restored to the weight such a create would have charged.
4545 env.app().getOpenLedger().modify([&](OpenView& view, beast::Journal) -> bool {
4546 auto const existing = view.read(escrowKeylet);
4547 if (!existing)
4548 {
4549 return false;
4550 }
4551 auto const escrowSle = std::make_shared<SLE>(*existing);
4552 auto const account = std::make_shared<SLE>(*view.read(keylet::account(alice.id())));
4553 escrowSle->setFieldVL(sfBytecode, Blob(bytecodeSize, 0x00));
4554 account->setFieldU32(sfOwnerCount, bytecodeWeight);
4555 view.rawReplace(escrowSle);
4556 view.rawReplace(account);
4557 return true;
4558 });
4559 BEAST_EXPECT(ownerCount(env, alice) == bytecodeWeight);
4560
4561 // Create must charge the full bytecode weight (3), not 1: counting the
4562 // escrow as a single unit would leave 2 pre-funded units unspent.
4563 env(sponsor::transfer(alice, tfSponsorshipCreate, escrowKeylet.key),
4565
4566 BEAST_EXPECT(sponsoredOwnerCount(env, alice) == bytecodeWeight);
4567 BEAST_EXPECT(sponsoringOwnerCount(env, sponsor) == bytecodeWeight);
4568 // All pre-funded units consumed (drained to absent).
4569 if (auto const sle = env.le(sponsorKeylet); BEAST_EXPECT(sle))
4570 {
4571 BEAST_EXPECT(!sle->isFieldPresent(sfRemainingOwnerCount));
4572 }
4573
4574 // End hands the same weight back; create bumped by the same amount, so
4575 // the counters return to 0 (counting 1 here would underflow).
4576 env(sponsor::transfer(alice, tfSponsorshipEnd, escrowKeylet.key));
4577
4578 BEAST_EXPECT(ownerCount(env, alice) == bytecodeWeight);
4579 BEAST_EXPECT(sponsoredOwnerCount(env, alice) == 0);
4580 BEAST_EXPECT(sponsoringOwnerCount(env, sponsor) == 0);
4581 if (auto const sle = env.le(escrowKeylet); BEAST_EXPECT(sle))
4582 {
4583 BEAST_EXPECT(!sle->isFieldPresent(sfSponsor));
4584 }
4585 }
4586
4587 void
4589 {
4590 // An account with ownerCount < 2 may create its first trust lines even
4591 // without meeting the reserve. In any case, the sponsor pays the full
4592 // reserve in all cases, even for the sponsee's very first trust line.
4593 testcase("Sponsored trust line gets no free-reserve exception");
4594 using namespace test::jtx;
4595
4596 Account const issuer("issuer");
4597 Account const alice("alice");
4598 Account const sponsor("sponsor");
4599
4600 Env env{*this, testableAmendments()};
4601 env.fund(XRP(10000), issuer, alice, sponsor);
4602 env.close();
4603
4604 auto const usd = issuer["usd"];
4605 auto const lineKeylet = keylet::trustLine(alice, issuer, usd.currency);
4606
4607 // Sponsor funded for exactly its base reserve
4609
4610 // alice's ownerCount is 0, so an unsponsored first trust line would be
4611 // free; but because it is sponsored, the reserve check is enforced
4612 // against the sponsor, which is one increment short.
4613 env(trust(alice, usd(100)),
4615 Sig(sfSponsorSignature, sponsor),
4617 env.close();
4618
4619 BEAST_EXPECT(!env.le(lineKeylet));
4620 BEAST_EXPECT(sponsoringOwnerCount(env, sponsor) == 0);
4621
4622 // Give the sponsor has exactly one owner-reserve increment; the same
4623 // sponsored first trust line now succeeds and the sponsor pays for it.
4625
4626 env(trust(alice, usd(100)),
4628 Sig(sfSponsorSignature, sponsor));
4629 env.close();
4630
4631 BEAST_EXPECT(env.le(lineKeylet));
4632 BEAST_EXPECT(sponsoringOwnerCount(env, sponsor) == 1);
4633 BEAST_EXPECT(sponsoredOwnerCount(env, alice) == 1);
4634 BEAST_EXPECT(ownerCount(env, alice) == 1);
4635 }
4636
4637 void
4639 {
4640 // sponsor co-signs, so a fee-only object (ReserveCount == 0) makes a co-signed
4641 // reserve sponsorship fail -- with no fallback to the sponsor's balance.
4642 testcase("Co-signed reserve sponsorship is bounded by Sponsorship budget");
4643 using namespace test::jtx;
4644
4645 Env env{*this, testableAmendments()};
4646 Account const sponsor("sponsor");
4647 Account const sponsee("sponsee");
4648 env.fund(XRP(10000), sponsor, sponsee);
4649 env.close();
4650
4651 // Prefund a FEE-only Sponsorship for the sponsee; ReserveCount
4652 // defaults to 0.
4653 env(sponsor::set_fee(sponsor, 0, XRP(100)), sponsor::SponseeAcc(sponsee));
4654 env.close();
4655 BEAST_EXPECT(env.le(keylet::sponsorship(sponsor, sponsee)));
4656
4657 // Sponsee creates a Check with the sponsor co-signing the reserve. The
4658 // fee-only Sponsorship's has ReserveCount (0), so this fails
4659 // with tecINSUFFICIENT_RESERVE
4660 env(check::create(sponsee, sponsor, XRP(1)),
4662 Sig(sfSponsorSignature, sponsor),
4664 env.close();
4665
4666 BEAST_EXPECT(ownerCount(env, sponsee) == 0);
4667 BEAST_EXPECT(sponsoringOwnerCount(env, sponsor) == 0);
4668 BEAST_EXPECT(sponsoredOwnerCount(env, sponsee) == 0);
4669
4670 // Bumping the Sponsorship's ReserveCount budget makes the same
4671 // co-signed reserve sponsorship succeed, the budget is what gates it.
4672 env(sponsor::set_reserve(sponsor, 0, 1), sponsor::SponseeAcc(sponsee));
4673 env.close();
4674
4675 env(check::create(sponsee, sponsor, XRP(1)),
4677 Sig(sfSponsorSignature, sponsor),
4678 Ter(tesSUCCESS));
4679 env.close();
4680
4681 BEAST_EXPECT(ownerCount(env, sponsee) == 1);
4682 BEAST_EXPECT(sponsoringOwnerCount(env, sponsor) == 1);
4683 BEAST_EXPECT(sponsoredOwnerCount(env, sponsee) == 1);
4684 }
4685
4686 void
4687 testTrustSet(bool cosigning)
4688 {
4689 testcase("TrustSet");
4690 using namespace test::jtx;
4691 Account const alice("alice");
4692 Account const bob("bob");
4693 Account const charlie("charlie");
4694 Account const sponsor("sponsor");
4695 Account const sponsor2("sponsor2");
4696
4697 auto const validateSponsoredTrustline =
4698 [&](std::shared_ptr<const SLE> const& sle, bool isIssuerHigh, Account const& sponsor) {
4699 BEAST_EXPECT(
4700 sle->getAccountID(isIssuerHigh ? sfLowSponsor : sfHighSponsor) == sponsor.id());
4701 BEAST_EXPECT(!sle->isFieldPresent(isIssuerHigh ? sfHighSponsor : sfLowSponsor));
4702 };
4703
4704 auto const& highAcc = alice > bob ? alice : bob;
4705 auto const& lowAcc = alice > bob ? bob : alice;
4706
4707 // create and delete
4708 for (bool const isIssuerHigh : {false, true})
4709 {
4710 Env env{*this, testableAmendments()};
4711 env.fund(XRP(1000000), alice, bob, charlie, sponsor, sponsor2);
4712 env.close();
4713
4714 auto const& issuer = isIssuerHigh ? highAcc : lowAcc;
4715 auto const& user = isIssuerHigh ? lowAcc : highAcc;
4716
4717 auto const usd = issuer["usd"];
4718 auto const currency = usd.currency;
4719
4720 // create TrustLine
4721 if (cosigning)
4722 {
4724 env(ticket::create(sponsor, 2)); // adjust for free trustline
4725 env.close();
4726 }
4727
4729 env,
4730 cosigning,
4731 sponsor,
4732 user,
4733 1,
4734 1,
4736 [&](Env& env, auto const& submit) { submit(trust(user, usd(100))); });
4737
4738 auto const keylet = keylet::trustLine(user, issuer, currency);
4739
4740 if (cosigning)
4741 {
4742 // invalid owner
4743 env(sponsor::transfer(charlie, tfSponsorshipReassign, keylet.key),
4744 sponsor::As(sponsor2, spfSponsorReserve),
4745 Sig(sfSponsorSignature, sponsor2),
4747 // invalid reserve owner
4748 env(sponsor::transfer(issuer, tfSponsorshipReassign, keylet.key),
4749 sponsor::As(sponsor2, spfSponsorReserve),
4750 Sig(sfSponsorSignature, sponsor2),
4752 env(sponsor::transfer(user, tfSponsorshipReassign, keylet.key),
4753 sponsor::As(sponsor2, spfSponsorReserve),
4754 Sig(sfSponsorSignature, sponsor2));
4755 env.close();
4756 }
4757 else
4758 {
4759 env(sponsor::set_reserve(sponsor2, 0, 1), sponsor::SponseeAcc(user));
4760 env.close();
4761 env(sponsor::transfer(user, tfSponsorshipReassign, keylet.key),
4762 sponsor::As(sponsor2, spfSponsorReserve));
4763 env.close();
4764 }
4765
4766 // delete TrustLine
4767 env(trust(user, usd(0)));
4768 env.close();
4769
4770 BEAST_EXPECT(ownerCount(env, user) == 0);
4771 BEAST_EXPECT(sponsoredOwnerCount(env, user) == 0);
4772 BEAST_EXPECT(sponsoringOwnerCount(env, sponsor) == 0);
4773
4774 BEAST_EXPECT(!env.le(keylet));
4775 }
4776
4777 // update
4778 for (bool const isIssuerHigh : {false, true})
4779 {
4780 Env env{*this, testableAmendments()};
4781 env.fund(XRP(1000000), alice, bob, sponsor, sponsor2);
4782 env.close();
4783
4784 auto const& issuer = isIssuerHigh ? highAcc : lowAcc;
4785 auto const& user = isIssuerHigh ? lowAcc : highAcc;
4786
4787 auto const usd = issuer["usd"];
4788 auto const currency = usd.currency;
4789
4790 // create TrustLine from issuer
4791 env(trust(issuer, user["usd"](100)));
4792 env.close();
4793
4794 BEAST_EXPECT(env.le(keylet::trustLine(user, issuer, currency)));
4795
4796 if (cosigning)
4797 {
4799 env(ticket::create(sponsor, 2)); // adjust for free trustline
4800 env.close();
4801 }
4802
4804 env,
4805 cosigning,
4806 sponsor,
4807 user,
4808 1,
4809 1,
4811 [&](Env& env, auto const& submit) { submit(trust(user, usd(100))); });
4812
4813 auto const line = env.le(keylet::trustLine(user, issuer, currency));
4814 validateSponsoredTrustline(line, isIssuerHigh, sponsor);
4815
4816 // update TrustLine from user to clear reserve
4817 env(trust(user, usd(0)));
4818 env.close();
4819
4820 BEAST_EXPECT(ownerCount(env, user) == 0);
4821 BEAST_EXPECT(sponsoredOwnerCount(env, user) == 0);
4822 BEAST_EXPECT(sponsoringOwnerCount(env, sponsor) == 0);
4823 BEAST_EXPECT(env.le(keylet::trustLine(user, issuer, currency)));
4824
4825 // remove TrustLine from issuer
4826 env(trust(issuer, user["usd"](0)));
4827 env.close();
4828 BEAST_EXPECT(!env.le(keylet::trustLine(user, issuer, currency)));
4829 }
4830
4831 // both High and Low sponsored
4832 {
4833 Env env{*this, testableAmendments()};
4834 env.fund(XRP(1000000), alice, bob, sponsor);
4835 env.close();
4836
4837 // create TrustLines
4838 env(trust(alice, bob["usd"](100)),
4840 Sig(sfSponsorSignature, sponsor));
4841 env.close();
4842 env(trust(bob, alice["usd"](100)),
4844 Sig(sfSponsorSignature, sponsor));
4845 env.close();
4846
4847 auto sle = env.le(keylet::trustLine(alice, bob, alice["usd"].currency));
4848 BEAST_EXPECT(sle);
4849 BEAST_EXPECT(sle->isFlag(lsfHighReserve));
4850 BEAST_EXPECT(sle->isFlag(lsfLowReserve));
4851 BEAST_EXPECT(sle->getAccountID(sfHighSponsor) == sponsor.id());
4852 BEAST_EXPECT(sle->getAccountID(sfLowSponsor) == sponsor.id());
4853
4854 BEAST_EXPECT(ownerCount(env, alice) == 1);
4855 BEAST_EXPECT(sponsoredOwnerCount(env, alice) == 1);
4856 BEAST_EXPECT(ownerCount(env, bob) == 1);
4857 BEAST_EXPECT(sponsoredOwnerCount(env, bob) == 1);
4858 BEAST_EXPECT(sponsoringOwnerCount(env, sponsor) == 2);
4859
4860 // clear TrustLines
4861 env(trust(alice, bob["usd"](0)));
4862 env.close();
4863 env(trust(bob, alice["usd"](0)));
4864 env.close();
4865
4866 sle = env.le(keylet::trustLine(alice, bob, alice["usd"].currency));
4867 BEAST_EXPECT(!sle);
4868 BEAST_EXPECT(ownerCount(env, alice) == 0);
4869 BEAST_EXPECT(sponsoredOwnerCount(env, alice) == 0);
4870 BEAST_EXPECT(ownerCount(env, bob) == 0);
4871 BEAST_EXPECT(sponsoredOwnerCount(env, bob) == 0);
4872 BEAST_EXPECT(sponsoringOwnerCount(env, sponsor) == 0);
4873 }
4874 }
4875
4876 void
4878 {
4879 testcase("AccountDelete");
4880 using namespace test::jtx;
4881 Account const alice("alice");
4882 Account const bob("bob");
4883 Account const sponsor("sponsor");
4884
4885 {
4886 // Delete Sponsor/Sponsee Account with ltSponsorship (tecHAS_OBLIGATIONS)
4887 Env env{*this, testableAmendments()};
4888 env.fund(XRP(1000000), alice, bob, sponsor);
4889 env.close();
4890
4891 // set sponsor
4892 env(sponsor::set(sponsor, 0, 100, XRP(100)),
4893 sponsor::SponseeAcc(alice),
4894 Ter(tesSUCCESS));
4895 env.close();
4896
4898
4899 auto const keylet = keylet::sponsorship(sponsor, alice);
4900 auto const sponsorObj = env.le(keylet);
4901 BEAST_EXPECT(sponsorObj);
4902
4903 // AccountDelete
4904 auto const requiredFee = drops(env.current()->fees().increment);
4905 env(acctdelete(alice, bob), Fee(requiredFee), Ter(tecHAS_OBLIGATIONS));
4906 env(acctdelete(sponsor, bob), Fee(requiredFee), Ter(tecHAS_OBLIGATIONS));
4907 }
4908
4909 {
4910 // Delete SponsoredAccount
4911 Env env{*this, testableAmendments()};
4912 env.memoize(alice);
4913 env.fund(XRP(1000000), bob, sponsor);
4914 env.close();
4915
4916 // create SponsoredAccount
4917 env(pay(sponsor, alice, XRP(10000)), Txflags(tfSponsorCreatedAccount));
4918 env.close();
4919
4920 incLgrSeqForAccDel(env, alice);
4921
4922 // AccountDelete: destination = non-sponsor
4923 auto const requiredFee = drops(env.current()->fees().increment);
4924 env(acctdelete(alice, bob), Fee(requiredFee), Ter(tecNO_SPONSOR_PERMISSION));
4925
4926 // The failed delete must leave the account sponsored by the original sponsor.
4927 auto const aliceSle = env.le(keylet::account(alice));
4928 BEAST_EXPECT(aliceSle);
4929 if (aliceSle)
4930 BEAST_EXPECT(aliceSle->getAccountID(sfSponsor) == sponsor.id());
4931
4932 auto const sponsorSle = env.le(keylet::account(sponsor));
4933 BEAST_EXPECT(sponsorSle->getFieldU32(sfSponsoringAccountCount) == 1);
4934
4935 incLgrSeqForAccDel(env, alice);
4936
4937 // AccountDelete: destination = sponsor
4938 env(acctdelete(alice, sponsor), Fee(requiredFee), Ter(tesSUCCESS));
4939
4940 auto const sponsorSle2 = env.le(keylet::account(sponsor));
4941 BEAST_EXPECT(!sponsorSle2->isFieldPresent(sfSponsoringAccountCount));
4942 }
4943
4944 {
4945 // Sponsor with sfSponsoringOwnerCount cannot delete (tecHAS_OBLIGATIONS)
4946 Env env{*this, testableAmendments()};
4947 Account const gw("gw");
4948 env.fund(XRP(1000000), alice, bob, sponsor, gw);
4949 env.close();
4950
4951 auto const usd = gw["usd"];
4952
4953 // Create a trust line for alice
4954 env(trust(alice, usd(1000)));
4955 env.close();
4956
4957 // Transfer reserve sponsorship of trust line to sponsor
4958 auto const trustId = keylet::trustLine(alice, gw, usd.currency);
4959 BEAST_EXPECT(env.le(trustId));
4960
4961 env(sponsor::transfer(alice, tfSponsorshipCreate, trustId.key),
4963 Sig(sfSponsorSignature, sponsor));
4964 env.close();
4965
4966 // Verify sfSponsoringOwnerCount is set on sponsor
4967 auto const sponsorSle = env.le(keylet::account(sponsor));
4968 BEAST_EXPECT(sponsorSle->isFieldPresent(sfSponsoringOwnerCount));
4969 auto const sponsoringOwnerCount = sponsorSle->getFieldU32(sfSponsoringOwnerCount);
4970 BEAST_EXPECT(sponsoringOwnerCount >= 1);
4971
4973
4974 // AccountDelete should fail
4975 auto const requiredFee = drops(env.current()->fees().increment);
4976 env(acctdelete(sponsor, bob), Fee(requiredFee), Ter(tecHAS_OBLIGATIONS));
4977 // The failed delete must not decrement the outstanding sponsored-object count.
4978 auto const sponsorSleAfter = env.le(keylet::account(sponsor));
4979 BEAST_EXPECT(sponsorSleAfter->isFieldPresent(sfSponsoringOwnerCount));
4980 BEAST_EXPECT(
4981 sponsorSleAfter->getFieldU32(sfSponsoringOwnerCount) == sponsoringOwnerCount);
4982 }
4983
4984 {
4985 // Sponsor with sfSponsoringAccountCount cannot delete (tecHAS_OBLIGATIONS)
4986 Env env{*this, testableAmendments()};
4987 env.memoize(alice);
4988 env.fund(XRP(1000000), bob, sponsor);
4989 env.close();
4990
4991 // Create SponsoredAccount (sets sfSponsoringAccountCount on sponsor)
4992 env(pay(sponsor, alice, XRP(10000)), Txflags(tfSponsorCreatedAccount));
4993 env.close();
4994
4995 // Verify sfSponsoringAccountCount is set on sponsor
4996 auto const sponsorSle = env.le(keylet::account(sponsor));
4997 BEAST_EXPECT(sponsorSle->isFieldPresent(sfSponsoringAccountCount));
4998 auto const sponsoringAccountCount = sponsorSle->getFieldU32(sfSponsoringAccountCount);
4999 BEAST_EXPECT(sponsoringAccountCount == 1);
5000
5002
5003 // AccountDelete should fail
5004 auto const requiredFee = drops(env.current()->fees().increment);
5005 env(acctdelete(sponsor, bob), Fee(requiredFee), Ter(tecHAS_OBLIGATIONS));
5006 // The failed delete must not decrement the outstanding sponsored-account count.
5007 auto const sponsorSleAfter = env.le(keylet::account(sponsor));
5008 BEAST_EXPECT(sponsorSleAfter->isFieldPresent(sfSponsoringAccountCount));
5009 BEAST_EXPECT(
5010 sponsorSleAfter->getFieldU32(sfSponsoringAccountCount) == sponsoringAccountCount);
5011 }
5012
5013 {
5014 // Account with sponsored objects should be deletable
5015 Env env{*this, testableAmendments()};
5016 env.fund(XRP(1000000), alice, bob, sponsor);
5017 env.close();
5018
5019 // Create sponsored delegate (a non-deletion-blocker)
5020 env(deposit::auth(alice, bob),
5022 Sig(sfSponsorSignature, sponsor));
5023
5024 {
5025 auto const sponsorSle = env.le(keylet::account(sponsor));
5026 auto const aliceSle = env.le(keylet::account(alice));
5027 BEAST_EXPECT(sponsorSle->at(sfSponsoringOwnerCount) == 1);
5028 BEAST_EXPECT(aliceSle->at(sfOwnerCount) == 1);
5029 BEAST_EXPECT(aliceSle->at(sfSponsoredOwnerCount) == 1);
5030 }
5031
5032 incLgrSeqForAccDel(env, alice);
5033
5034 // AccountDelete should succeed
5035 {
5036 auto const requiredFee = drops(env.current()->fees().increment);
5037 env(acctdelete(alice, bob), Fee(requiredFee), Ter(tesSUCCESS));
5038 BEAST_EXPECT(!env.le(keylet::account(alice)));
5039 auto const sponsorSle = env.le(keylet::account(sponsor));
5040 BEAST_EXPECT(sponsorSle->at(sfSponsoringOwnerCount) == 0);
5041 }
5042 }
5043 }
5044
5045 void
5047 {
5048 testcase("DelegatePermission");
5049 using namespace test::jtx;
5050 Account const alice("alice");
5051 Account const bob("bob");
5052 Account const carol("carol");
5053
5054 //
5055 // SponsorshipTransfer is not delegable.
5056 //
5057 {
5058 Env env{*this, testableAmendments()};
5059 env.fund(XRP(1000000), alice, bob, carol);
5060 env.close();
5061
5062 auto const seq = env.seq(alice);
5063 env(check::create(alice, bob, XRP(1)));
5064 env.close();
5065
5066 auto const keylet = keylet::check(alice, SeqProxy::rawSequence(seq));
5067
5068 env(sponsor::transfer(alice, tfSponsorshipCreate, keylet.key),
5070 Sig(sfSponsorSignature, bob),
5071 delegate::As(carol),
5072 Ter(temINVALID));
5073
5074 env(delegate::set(alice, carol, {"SponsorshipTransfer"}), Ter(temMALFORMED));
5075 }
5076 //
5077 // test send SponsorshipSet on other's behalf
5078 //
5079 {
5080 Env env{*this, testableAmendments()};
5081 env.fund(XRP(1000000), alice, bob, carol);
5082 env.close();
5083
5084 env(sponsor::set(alice, 0, 100, XRP(100)),
5086 delegate::As(carol),
5088
5089 env(delegate::set(alice, carol, {"SponsorshipSet"}));
5090 env.close();
5091
5092 env(sponsor::set(alice, 0, 100, XRP(100)),
5094 delegate::As(carol),
5095 Ter(tesSUCCESS));
5096 env.close();
5097 }
5098 }
5099
5100 void
5102 {
5103 testcase("Delegate Block Reserve Sponsor");
5104 using namespace test::jtx;
5105 Account const alice("alice");
5106 Account const bob("bob");
5107 Account const carol("carol");
5108 Account const sponsor("sponsor");
5109
5110 // Co-signed reserve sponsorship is blocked for delegated transactions.
5111 {
5112 Env env{*this, testableAmendments()};
5113 env.fund(XRP(1000000), alice, bob, carol, sponsor);
5114 env.close();
5115
5116 env(delegate::set(alice, bob, {"CheckCreate"}));
5117 env.close();
5118
5119 env(check::create(alice, carol, XRP(1)),
5120 delegate::As(bob),
5122 Sig(sfSponsorSignature, sponsor),
5123 Ter(temINVALID));
5124 }
5125
5126 // Pre-funded reserve sponsorship is blocked for delegated transactions.
5127 {
5128 Env env{*this, testableAmendments()};
5129 env.fund(XRP(1000000), alice, bob, carol, sponsor);
5130 env.close();
5131
5132 env(delegate::set(alice, bob, {"CheckCreate"}));
5134 env.close();
5135
5136 env(check::create(alice, carol, XRP(1)),
5137 delegate::As(bob),
5139 Ter(temINVALID));
5140 }
5141 }
5142
5143 void
5145 {
5146 testcase("Delegate Sponsor Fee Payer");
5147 using namespace test::jtx;
5148 Account const alice("alice");
5149 Account const bob("bob");
5150 Account const carol("carol");
5151 Account const sponsor("sponsor");
5152
5153 // Co-signing: the sponsor account pays the delegated transaction fee.
5154 {
5155 Env env{*this, testableAmendments()};
5156 env.fund(XRP(10000), alice, bob, carol, sponsor);
5157 env.close();
5158
5159 env(delegate::set(alice, bob, {"Payment"}));
5160 env.close();
5161
5162 auto const aliceBalance = env.balance(alice);
5163 auto const bobBalance = env.balance(bob);
5164 auto const carolBalance = env.balance(carol);
5165 auto const sponsorBalance = env.balance(sponsor);
5166 auto const sendAmt = XRP(100);
5167 auto const feeAmt = XRP(10);
5168
5169 env(pay(alice, carol, sendAmt),
5170 delegate::As(bob),
5171 Fee(feeAmt),
5173 Sig(sfSponsorSignature, sponsor));
5174 env.close();
5175
5176 BEAST_EXPECT(env.balance(alice) == aliceBalance - sendAmt);
5177 BEAST_EXPECT(env.balance(bob) == bobBalance);
5178 BEAST_EXPECT(env.balance(carol) == carolBalance + sendAmt);
5179 // sponsor pays the fee
5180 BEAST_EXPECT(env.balance(sponsor) == sponsorBalance - feeAmt);
5181 }
5182
5183 // Pre-funded: the Sponsorship object for sponsorship(sponsor, delegate)
5184 // pays the fee.
5185 {
5186 Env env{*this, testableAmendments()};
5187 env.fund(XRP(10000), alice, bob, carol, sponsor);
5188 env.close();
5189
5190 env(delegate::set(alice, bob, {"Payment"}));
5191 env(sponsor::set_fee(sponsor, 0, XRP(100)), sponsor::SponseeAcc(bob));
5192 env.close();
5193
5194 auto const aliceBalance = env.balance(alice);
5195 auto const bobBalance = env.balance(bob);
5196 auto const carolBalance = env.balance(carol);
5197 auto const sponsorBalance = env.balance(sponsor);
5198 auto const sponsorFee = sponsor::sponsorshipFeeBalance(env, sponsor, bob);
5199 auto const sendAmt = XRP(100);
5200 auto const feeAmt = XRP(10);
5201
5202 // verify sponsorship(sponsor, alice) is not present, because we are testing
5203 // sponsorship(sponsor, bob) will pay the fee. bob is sfDelegate.
5204 BEAST_EXPECT(!env.le(keylet::sponsorship(sponsor, alice)));
5205
5206 env(pay(alice, carol, sendAmt),
5207 delegate::As(bob),
5208 Fee(feeAmt),
5210 env.close();
5211
5212 BEAST_EXPECT(env.balance(alice) == aliceBalance - sendAmt);
5213 BEAST_EXPECT(env.balance(bob) == bobBalance);
5214 BEAST_EXPECT(env.balance(carol) == carolBalance + sendAmt);
5215 BEAST_EXPECT(env.balance(sponsor) == sponsorBalance);
5216 // sponsorship(sponsor, bob) pays the fee, bob is sfDelegate
5217 BEAST_EXPECT(sponsor::sponsorshipFeeBalance(env, sponsor, bob) == sponsorFee - feeAmt);
5218 }
5219 }
5220
5221 void
5223 {
5224 testcase("Batch");
5225 using namespace test::jtx;
5226 Account const alice("alice");
5227 Account const bob("bob");
5228 Account const sponsor("sponsor");
5229
5230 //
5231 // outer transaction
5232 //
5233 {
5234 // test outer transaction with co-signing sponsor
5235 Env env{*this, testableAmendments()};
5236 env.fund(XRP(1000), alice, bob, sponsor);
5237 env.close();
5238
5239 auto const seq = env.seq(alice);
5240 env(batch::outer(alice, seq, XRP(1), tfAllOrNothing),
5241 batch::Inner(noop(alice), seq + 1),
5242 batch::Inner(ticket::create(alice, 1), seq + 2),
5244 Sig(sfSponsorSignature, sponsor),
5245 Ter(tesSUCCESS));
5246 env.close();
5247
5248 // does not affect reserve
5249 BEAST_EXPECT(ownerCount(env, alice) == 1);
5250 BEAST_EXPECT(sponsoredOwnerCount(env, alice) == 0);
5251 BEAST_EXPECT(sponsoringOwnerCount(env, sponsor) == 0);
5252
5253 // Fee is paid by sponsor
5254 BEAST_EXPECT(env.balance(alice) == XRP(1000));
5255 BEAST_EXPECT(env.balance(sponsor) == XRP(1000 - 1));
5256 }
5257 {
5258 Env env{*this, testableAmendments()};
5259 env.fund(XRP(1000), alice, bob, sponsor);
5260 env.close();
5261
5262 // spfSponsorReserve on outer Batch is rejected
5263 for (auto const flags : {spfSponsorReserve | spfSponsorFee, spfSponsorReserve})
5264 {
5265 auto const seq = env.seq(alice);
5266 env(batch::outer(alice, seq, XRP(1), tfAllOrNothing),
5267 batch::Inner(noop(alice), seq + 1),
5268 batch::Inner(noop(alice), seq + 2),
5269 sponsor::As(sponsor, flags),
5270 Sig(sfSponsorSignature, sponsor),
5272 env.close();
5273 }
5274 }
5275 {
5276 // test outer transaction with prefunded sponsor
5277 Env env{*this, testableAmendments()};
5278 env.fund(XRP(1000), alice, bob);
5279 env.fund(XRP(1001), sponsor);
5280 env.close();
5281
5282 env(sponsor::set(sponsor, 0, 100, XRP(100)),
5283 sponsor::SponseeAcc(alice),
5284 Fee(XRP(1)),
5285 Ter(tesSUCCESS));
5286 env.close();
5287
5288 auto const seq = env.seq(alice);
5289 env(batch::outer(alice, seq, XRP(1), tfAllOrNothing),
5290 batch::Inner(noop(alice), seq + 1),
5291 batch::Inner(ticket::create(alice, 1), seq + 2),
5293 Ter(tesSUCCESS));
5294 env.close();
5295
5296 // does not affect reserve
5297 BEAST_EXPECT(ownerCount(env, alice) == 1);
5298 BEAST_EXPECT(sponsoredOwnerCount(env, alice) == 0);
5299 BEAST_EXPECT(sponsoringOwnerCount(env, sponsor) == 0);
5300
5301 // Fee is paid by sponsor object
5302 BEAST_EXPECT(env.balance(alice) == XRP(1000));
5303 BEAST_EXPECT(env.balance(sponsor) == XRP(900));
5304
5305 auto const sponsorshipSle = env.le(keylet::sponsorship(sponsor, alice));
5306 BEAST_EXPECT(sponsorshipSle);
5307 BEAST_EXPECT(sponsorshipSle->at(sfFeeAmount) == XRP(100 - 1));
5308 BEAST_EXPECT(sponsorshipSle->at(sfRemainingOwnerCount) == 100);
5309 }
5310 //
5311 // Inner transaction
5312 //
5313 {
5314 // test invalid Inner transaction with co-signing sponsor
5315 Account const signerAccount("signer");
5316 Env env{*this, testableAmendments()};
5317 env.fund(XRP(1000), alice, bob, sponsor, signerAccount);
5318 env.close();
5319
5320 env(signers(sponsor, 1, {Signer(signerAccount, 1)}));
5321 env.close();
5322
5323 {
5324 auto jt = env.jtnofill(
5325 noop(alice),
5327 Sig(sfSponsorSignature, sponsor));
5328 jt.jv.removeMember(sfTxnSignature.jsonName);
5329
5330 auto const seq = env.seq(alice);
5331 // should fail because Inner transaction cannot include SponsorSignature with
5332 // TxnSignature
5333 BEAST_EXPECT(jt.jv[sfSponsorSignature.jsonName].isMember(sfTxnSignature.jsonName));
5334 env(batch::outer(alice, seq, XRP(1), tfAllOrNothing),
5335 batch::Inner(jt.jv, seq + 1),
5336 batch::Inner(ticket::create(alice, 1), seq + 2),
5338 }
5339
5340 {
5341 auto jt = env.jtnofill(
5342 noop(alice),
5344 Msig(sfSponsorSignature, sponsor, signerAccount));
5345 jt.jv.removeMember(sfTxnSignature.jsonName);
5346
5347 auto const seq = env.seq(alice);
5348 // should fail because Inner transaction cannot include SponsorSignature with
5349 // Signers
5350 BEAST_EXPECT(jt.jv[sfSponsorSignature.jsonName].isMember(sfSigners.jsonName));
5351 env(batch::outer(alice, seq, XRP(1), tfAllOrNothing),
5352 batch::Inner(jt.jv, seq + 1),
5353 batch::Inner(ticket::create(alice, 1), seq + 2),
5355 }
5356
5357 {
5358 auto jt = env.jtnofill(
5359 noop(alice),
5361 Sig(sfSponsorSignature, sponsor));
5362 jt.jv.removeMember(sfTxnSignature.jsonName);
5363 jt.jv[sfSponsorSignature.jsonName].removeMember(sfTxnSignature.jsonName);
5364 jt.jv[sfSponsorSignature.jsonName][sfSigningPubKey.jsonName] = "";
5365
5366 auto const seq = env.seq(alice);
5367 // should fail because BatchSigners does not have signer for SponsorSignature
5368 env(batch::outer(alice, seq, XRP(1), tfAllOrNothing),
5369 batch::Inner(jt.jv, seq + 1),
5370 batch::Inner(ticket::create(alice, 1), seq + 2),
5372 }
5373 }
5374
5375 {
5376 // test Inner transaction with prefunded sponsor
5377 Env env{*this, testableAmendments()};
5378 env.fund(XRP(1000), alice, bob);
5379 env.fund(XRP(1001), sponsor);
5380 env.close();
5381
5382 env(sponsor::set(sponsor, 0, 100, XRP(100)),
5383 sponsor::SponseeAcc(alice),
5384 Fee(XRP(1)),
5385 Ter(tesSUCCESS));
5386 env.close();
5387 BEAST_EXPECT(env.balance(sponsor) == XRP(900));
5388
5389 auto jt = env.jtnofill(
5391 // remove txn signature since it is filled by env.jtnofill()
5392 jt.jv.removeMember(jss::TxnSignature);
5393
5394 auto const seq = env.seq(alice);
5395 env(batch::outer(alice, seq, XRP(1), tfAllOrNothing),
5396 batch::Inner(noop(alice), seq + 1),
5397 batch::Inner(jt.jv, seq + 2),
5398 Ter(tesSUCCESS));
5399 env.close();
5400
5401 // affect sponsor reserve
5402 BEAST_EXPECT(ownerCount(env, alice) == 1);
5403 BEAST_EXPECT(sponsoredOwnerCount(env, alice) == 1);
5404 BEAST_EXPECT(sponsoringOwnerCount(env, sponsor) == 1);
5405
5406 // Fee is paid by outer transaction originator (alice)
5407 BEAST_EXPECT(env.balance(alice) == XRP(999));
5408 BEAST_EXPECT(env.balance(sponsor) == XRP(900));
5409
5410 // reserve count is decreased
5411 auto const sponsorshipSle = env.le(keylet::sponsorship(sponsor, alice));
5412 BEAST_EXPECT(sponsorshipSle);
5413 BEAST_EXPECT(sponsorshipSle->at(sfFeeAmount) == XRP(100));
5414 BEAST_EXPECT(sponsorshipSle->at(sfRemainingOwnerCount) == 99);
5415 }
5416
5417 {
5418 // test Inner transaction with co-signing sponsor
5419 Env env{*this, testableAmendments()};
5420 env.fund(XRP(1000), alice, bob, sponsor);
5421 env.close();
5422
5423 auto jt = env.jtnofill(
5424 check::create(alice, bob, XRP(1)),
5426 Sig(sfSponsorSignature, sponsor));
5427 // remove txn signature since it is filled by env.jtnofill()
5428 jt.jv.removeMember(sfTxnSignature.jsonName);
5429 jt.jv[sfSponsorSignature.jsonName].removeMember(sfTxnSignature.jsonName);
5430 jt.jv[sfSponsorSignature.jsonName][sfSigningPubKey.jsonName] = "";
5431
5432 auto const seq = env.seq(alice);
5433 env(batch::outer(alice, seq, XRP(1), tfAllOrNothing),
5434 batch::Inner(noop(alice), seq + 1),
5435 batch::Inner(jt.jv, seq + 2),
5437 Ter(tesSUCCESS));
5438 env.close();
5439
5440 // affect sponsor reserve
5441 BEAST_EXPECT(ownerCount(env, alice) == 1);
5442 BEAST_EXPECT(sponsoredOwnerCount(env, alice) == 1);
5443 BEAST_EXPECT(sponsoringOwnerCount(env, sponsor) == 1);
5444
5445 // Fee is paid by outer transaction originator (alice)
5446 BEAST_EXPECT(env.balance(alice) == XRP(999));
5447 BEAST_EXPECT(env.balance(sponsor) == XRP(1000));
5448 }
5449
5450 // Inner tx with sfSponsor + spfSponsorFee (pre-funded) is rejected
5451 {
5452 Env env{*this, testableAmendments()};
5453 env.fund(XRP(1000), alice, bob, sponsor);
5454 env.close();
5455
5456 // Create pre-funded sponsorship
5457 env(sponsor::set_fee(sponsor, 0, XRP(1)), sponsor::SponseeAcc(alice), Fee(XRP(1)));
5458 env.close();
5459
5460 auto const seq = env.seq(alice);
5461 auto const batchFee = batch::calcBatchFee(env, 0, 2);
5462
5463 // Create inner transaction with sponsor fee
5464 auto innerPay = pay(alice, bob, XRP(1));
5465 innerPay[sfSponsor.jsonName] = sponsor.human();
5466 innerPay[sfSponsorFlags.jsonName] = static_cast<std::uint32_t>(spfSponsorFee);
5467
5468 // Should be rejected with temBAD_FEE
5469 env(batch::outer(alice, seq, batchFee, tfAllOrNothing),
5470 batch::Inner(innerPay, seq + 1),
5471 batch::Inner(noop(alice), seq + 2),
5473 env.close();
5474 }
5475
5476 // Inner tx with sfSponsor + spfSponsorFee (co-signed) is rejected
5477 {
5478 Env env{*this, testableAmendments()};
5479 env.fund(XRP(1000), alice, bob, sponsor);
5480 env.close();
5481
5482 auto const seq = env.seq(alice);
5483 auto const batchFee = batch::calcBatchFee(env, 1, 2);
5484
5485 auto innerPay = pay(alice, bob, XRP(1));
5486 innerPay[sfSponsor.jsonName] = sponsor.human();
5487 innerPay[sfSponsorFlags.jsonName] = static_cast<std::uint32_t>(spfSponsorFee);
5488
5489 // Should be rejected with temBAD_FEE
5490 env(batch::outer(alice, seq, batchFee, tfAllOrNothing),
5491 batch::Inner(innerPay, seq + 1),
5492 batch::Inner(noop(alice), seq + 2),
5495 env.close();
5496 }
5497
5498 // Inner tx with spfSponsorFee + spfSponsorReserve is rejected
5499 {
5500 Env env{*this, testableAmendments()};
5501 env.fund(XRP(1000), alice, bob, sponsor);
5502 env.close();
5503
5504 auto const seq = env.seq(alice);
5505 auto const batchFee = batch::calcBatchFee(env, 0, 2);
5506
5507 auto innerTx = check::create(alice, bob, XRP(1));
5508 innerTx[sfSponsor.jsonName] = sponsor.human();
5509 innerTx[sfSponsorFlags.jsonName] =
5511
5512 // Should be rejected with temBAD_FEE (fee sponsorship check comes first)
5513 env(batch::outer(alice, seq, batchFee, tfAllOrNothing),
5514 batch::Inner(innerTx, seq + 1),
5515 batch::Inner(noop(alice), seq + 2),
5517 env.close();
5518 }
5519
5520 // Outer batch tx with sponsor fee is allowed
5521 {
5522 Env env{*this, testableAmendments()};
5523 env.fund(XRP(1000), alice, bob, sponsor);
5524 env.close();
5525
5526 auto const seq = env.seq(bob);
5527 auto const batchFee = batch::calcBatchFee(env, 0, 2);
5528
5529 // Outer batch with sponsor fee should work fine
5530 env(batch::outer(bob, seq, batchFee, tfAllOrNothing),
5531 batch::Inner(noop(bob), seq + 1),
5532 batch::Inner(noop(bob), seq + 2),
5534 Sig(sfSponsorSignature, sponsor),
5535 Ter(tesSUCCESS));
5536 env.close();
5537
5538 // Sponsor paid the fee
5539 BEAST_EXPECT(env.balance(bob) == XRP(1000));
5540 }
5541 }
5542
5543 // Verify that the central allow-list in preflight1Sponsor rejects
5544 // spfSponsorReserve for transaction types that v1 does not permit.
5545 void
5547 {
5548 testcase("Reserve sponsor allow-list gate");
5549 using namespace test::jtx;
5550
5551 Env env{*this, testableAmendments()};
5552 Account const alice("alice");
5553 Account const bob("bob");
5554 Account const sponsor("sponsor");
5555 env.fund(XRP(10000), alice, bob, sponsor);
5556 env.close();
5557
5558 env(sponsor::set(sponsor, 0, 10, XRP(10)), sponsor::SponseeAcc(alice));
5559 env.close();
5560
5561 auto const checkBlocked = [&](json::Value const& jv) {
5562 env(jv,
5564 Sig(sfSponsorSignature, sponsor),
5566 };
5567
5568 checkBlocked(ticket::create(alice, 1));
5569 checkBlocked(offer(alice, XRP(100), bob["USD"](100)));
5570 checkBlocked(did::setValid(alice));
5571 checkBlocked(token::mint(alice, 0u));
5572 checkBlocked(sponsor::set(alice, 0, 10, XRP(10)));
5573 checkBlocked(acctdelete(alice, bob));
5574 checkBlocked(loan::set(alice, UInt256(1), Number{1}));
5575 }
5576
5577 void
5578 testSponsorReserve(bool cosigning)
5579 {
5581 testSponsorReserveSimple(cosigning);
5582 testCheck(cosigning);
5583 testCredential(cosigning);
5584 testDelegate(cosigning);
5585 testDepositPreauth(cosigning);
5586 testEscrow(cosigning);
5587 testMPToken(cosigning);
5588 testPayChan(cosigning);
5589 testSignerList(cosigning);
5590 testTrustSet(cosigning);
5591 }
5592
5593 void
5595 {
5596 // Zero-balance sponsored Payment: getFeePayer() consistency check
5597 testcase("Sponsored Payment: minimal-balance account with sponsor-pays-fee");
5598
5599 using namespace jtx;
5600 Env env{*this, testableAmendments()};
5601 Account const alice("alice");
5602 Account const sponsor("sponsor");
5603 Account const dest("dest");
5604
5605 auto const baseFee = env.current()->fees().base;
5606 auto const baseReserve = env.current()->fees().reserve;
5607
5608 // Fund sponsor and dest generously, alice with base reserve + 1 XRP for payment
5609 env.fund(XRP(10000), sponsor, dest);
5610 env.fund(baseReserve + XRP(1), alice);
5611 env.close();
5612
5613 // Precondition: alice has base reserve + 1 XRP (enough for payment but not fee)
5614 BEAST_EXPECT(env.balance(alice) == baseReserve + XRP(1));
5615
5616 // Alice tries to send a Payment to dest where sponsor pays the fee via spfSponsorFee.
5617 // Passed even alice balance doesn't have enough to pay fee.
5618 auto const preDest = env.balance(dest);
5619 auto const preSponsor = env.balance(sponsor);
5620
5621 // Alice sends 1 XRP to dest, sponsor pays the fee
5622 env(pay(alice, dest, XRP(1)),
5624 Sig(sfSponsorSignature, sponsor),
5625 Fee(baseFee));
5626 env.close();
5627
5628 // Payment succeeded
5629 // Alice's balance decreased by 1 XRP (the payment amount, NOT the fee)
5630 BEAST_EXPECT(env.balance(alice) == baseReserve);
5631
5632 // Dest received 1 XRP
5633 BEAST_EXPECT(env.balance(dest) == preDest + XRP(1));
5634
5635 // Sponsor paid the fee (NOT alice)
5636 BEAST_EXPECT(env.balance(sponsor) == preSponsor - baseFee);
5637 }
5638
5639 void
5641 {
5642 // TrustSet's modify path applies the tx-level reserve sponsor to whichever
5643 // side has its reserve gate trip on this update, regardless of whether that
5644 // side belongs to the tx submitter. trustCreate only sets the submitter's
5645 // reserve flag and snapshots the counterparty's asfDefaultRipple state into
5646 // the line's NoRipple bit; if the counterparty later toggles asfDefaultRipple
5647 // (the canonical issuer flow), the line and account flags disagree and on
5648 // the submitter's next TrustSet the counterparty-side gate fires. Sponsor still will be
5649 // checked if it can be applied to that end of the trustLine.
5650
5651 testcase("TrustSet modify with sponsor does not misroute onto counterparty side");
5652
5653 using namespace test::jtx;
5654
5655 Env env{*this, testableAmendments()};
5656 Account const alice{"alice_t2178"};
5657 Account const bob{"bob_t2178"};
5658 Account const carol{"carol_t2178"};
5659
5660 // Fund without auto-setting asfDefaultRipple
5661 env.fund(XRP(100'000), alice, bob, carol);
5662 env.close();
5663
5664 // Determine account ordering
5665 bool const aliceIsHigh = alice.id() > bob.id();
5666
5667 // To trigger the bug, we need the COUNTERPARTY's reserve gate to trip
5668 // We use issuer/holder terminology where:
5669 // - holder creates the trust line (their reserve is set first)
5670 // - issuer enables DefaultRipple after (creates flag mismatch)
5671 // - holder's second TrustSet triggers issuer's reserve gate
5672
5673 auto const issuer = aliceIsHigh ? bob : alice;
5674 auto const holder = aliceIsHigh ? alice : bob;
5675 auto const usd = issuer["USD"];
5676
5677 // Issuer must NOT have DefaultRipple set initially
5678 // Clear it explicitly (env.fund may have set it)
5679 env(fclear(issuer, asfDefaultRipple));
5680 env.close();
5681
5682 // Holder creates the trust line first (holder's reserve flag is set)
5683 // At this point, issuer does NOT have DefaultRipple set, so
5684 // the NoRipple bit on issuer's side is set according to issuer's current flag
5685 env(trust(holder, usd(1'000)));
5686 env.close();
5687
5688 // Issuer now enables asfDefaultRipple (canonical issuer flow)
5689 // This creates a mismatch: issuer's account flag says DefaultRipple=true
5690 // but the trust line's NoRipple bit on issuer's side is still set
5691 env(fset(issuer, asfDefaultRipple));
5692 env.close();
5693
5694 SF_ACCOUNT const& issuerSponsorField = aliceIsHigh ? sfLowSponsor : sfHighSponsor;
5695 SF_ACCOUNT const& holderSponsorField = aliceIsHigh ? sfHighSponsor : sfLowSponsor;
5696
5697 auto const lineKey = keylet::trustLine(alice, bob, usd.currency);
5698 auto const sleLineBefore = env.le(lineKey);
5699 if (!BEAST_EXPECT(sleLineBefore))
5700 return;
5701 BEAST_EXPECT(!sleLineBefore->isFieldPresent(sfLowSponsor));
5702 BEAST_EXPECT(!sleLineBefore->isFieldPresent(sfHighSponsor));
5703
5704 auto const carolBefore = sponsoringOwnerCount(env, carol);
5705 BEAST_EXPECT(carolBefore == 0);
5706 auto const issuerSponsoredBefore = sponsoredOwnerCount(env, issuer);
5707 BEAST_EXPECT(issuerSponsoredBefore == 0);
5708
5709 // Holder modifies the trust line with Carol as sponsor
5710 // This should trigger the issuer's reserve gate because of the DefaultRipple mismatch
5711 // Carol (sponsor) should NOT be applied to issuer's side (issuer != tx submitter)
5712 env(trust(holder, usd(2'000)),
5714 Sig(sfSponsorSignature, carol),
5715 Ter(tesSUCCESS));
5716 env.close();
5717
5718 auto const sleLineAfter = env.le(lineKey);
5719 if (!BEAST_EXPECT(sleLineAfter))
5720 return;
5721
5722 // Carol only agreed to back the holder, not the issuer
5723 BEAST_EXPECT(!sleLineAfter->isFieldPresent(issuerSponsorField));
5724
5725 // Holder's side also has no sponsor because holder's reserve flag was
5726 // already set on the FIRST TrustSet (no sponsor in scope then)
5727 BEAST_EXPECT(!sleLineAfter->isFieldPresent(holderSponsorField));
5728
5729 // Carol's sponsoring count should remain unchanged (no misroute)
5730 auto const carolAfter = sponsoringOwnerCount(env, carol);
5731 BEAST_EXPECT(carolAfter == carolBefore);
5732
5733 // Issuer's sponsored count should remain unchanged (no misroute)
5734 auto const issuerSponsoredAfter = sponsoredOwnerCount(env, issuer);
5735 BEAST_EXPECT(issuerSponsoredAfter == issuerSponsoredBefore);
5736 }
5737
5738 void
5740 {
5741 testcase("Self-escrow finish reserve order gated by amendment");
5742 using namespace test::jtx;
5743 using namespace std::chrono_literals;
5744
5745 // Finishing a self-escrow (source == destination) whose trust line was
5746 // deleted while the escrow was outstanding auto-creates the line. With
5747 // the source's balance in the one-increment window
5748 // [reserve(1), reserve(2)), the finish succeeds only when the escrow
5749 // reserve is released before delivery, which either featureSponsor or
5750 // fixCleanup3_4_0 does.
5751 auto const runTest = [&](FeatureBitset features, TER expected) {
5752 Account const alice("alice");
5753 Account const gw("gw");
5754 auto const usd = gw["usd"];
5755
5756 Env env{*this, features};
5757 auto const baseFee = env.current()->fees().base;
5758
5759 env.fund(XRP(10000), alice, gw);
5760 env.close();
5761
5762 env(fset(gw, asfAllowTrustLineLocking));
5763 env.close();
5764
5765 env.trust(usd(1000), alice);
5766 env.close();
5767 env(pay(gw, alice, usd(100)));
5768 env.close();
5769
5770 // Escrow alice's entire USD balance to herself. The escrowed
5771 // IOUs return to the issuer, zeroing the line balance.
5772 auto const seq = env.seq(alice);
5773 env(escrow::create(alice, alice, usd(100)),
5775 escrow::kCancelTime(env.now() + 100s));
5776 env.close();
5777
5778 // Delete the now-empty trust line. Both accounts have
5779 // DefaultRipple set (jtx fund does that), so a plain limit-0
5780 // TrustSet returns the line to its default state.
5781 env(trust(alice, usd(0)));
5782 env.close();
5783 BEAST_EXPECT(!env.le(keylet::trustLine(alice, gw, usd.currency)));
5784 BEAST_EXPECT(ownerCount(env, alice) == 1); // just the escrow
5785
5786 // Put alice's balance in the window. Pay the excess away
5787 // directly: adjustAccountXRPBalance needs the Sponsor amendment.
5788 STAmount const target = reserve(env, 1) + XRP(1);
5789 env(pay(alice, env.master, env.balance(alice) - target - baseFee), Fee(baseFee));
5790 env.close();
5791 BEAST_EXPECT(env.balance(alice) == target);
5792
5793 env(escrow::finish(alice, alice, seq),
5796 Fee(baseFee * 150),
5797 Ter(expected));
5798 env.close();
5799
5800 if (expected == tesSUCCESS)
5801 {
5802 BEAST_EXPECT(!env.le(keylet::escrow(alice, SeqProxy::rawSequence(seq))));
5803 BEAST_EXPECT(env.le(keylet::trustLine(alice, gw, usd.currency)));
5804 BEAST_EXPECT(env.balance(alice, usd) == usd(100));
5805 BEAST_EXPECT(ownerCount(env, alice) == 1); // the new line
5806 }
5807 else
5808 {
5809 BEAST_EXPECT(env.le(keylet::escrow(alice, SeqProxy::rawSequence(seq))));
5810 BEAST_EXPECT(!env.le(keylet::trustLine(alice, gw, usd.currency)));
5811 BEAST_EXPECT(ownerCount(env, alice) == 1); // still the escrow
5812 }
5813 };
5814
5815 runTest(testableAmendments() - featureSponsor - fixCleanup3_4_0, tecNO_LINE_INSUF_RESERVE);
5816 runTest(testableAmendments() - featureSponsor, tesSUCCESS);
5817 runTest(testableAmendments() - fixCleanup3_4_0, tesSUCCESS);
5818 runTest(testableAmendments(), tesSUCCESS);
5819 }
5820
5821 void
5823 {
5824 // The ValidVault invariant checks that the vault's balance and the
5825 // depositor's balance change by equal amounts. For XRP vaults it adds the
5826 // fee back into the depositor's balance change: normally the depositor
5827 // pays the fee, so their balance drops by (deposit amount + fee), and
5828 // adding the fee back leaves just the deposit amount to compare against
5829 // the vault. But when a fee sponsor pays, the depositor's balance drops
5830 // by only the deposit amount, so the fee must NOT be added back or the
5831 // equal-amount check fails.
5832 testcase("Fee-sponsored VaultDeposit/VaultWithdraw pass ValidVault invariant");
5833 using namespace test::jtx;
5834
5835 Env env{*this, testableAmendments()};
5836 Account const alice("alice");
5837 Account const sponsor("sponsor");
5838 env.fund(XRP(10000), alice, sponsor);
5839 env.close();
5840
5841 PrettyAsset const xrpAsset{xrpIssue(), 1'000'000};
5842 Vault const vault{env};
5843 auto [vaultTx, vaultKeylet] = vault.create({.owner = alice, .asset = xrpAsset});
5844 env(vaultTx);
5845 env.close();
5846
5847 // Control: the same deposit shape, unsponsored, succeeds.
5848 env(vault.deposit({.depositor = alice, .id = vaultKeylet.key, .amount = xrpAsset(100)}),
5849 Ter(tesSUCCESS));
5850 env.close();
5851
5852 // Fee-sponsored (co-signed) deposit succeeds.
5853 env(vault.deposit({.depositor = alice, .id = vaultKeylet.key, .amount = xrpAsset(100)}),
5854 Fee(XRP(1)),
5856 Sig(sfSponsorSignature, sponsor),
5857 Ter(tesSUCCESS));
5858 env.close();
5859
5860 // The same fee-correction logic (ValidVault::deltaAssetsForParty)
5861 // drives the withdraw path, so a fee-sponsored withdrawal back to
5862 // the depositor's own account also passes on the destination side.
5863 env(vault.withdraw({.depositor = alice, .id = vaultKeylet.key, .amount = xrpAsset(50)}),
5864 Fee(XRP(1)),
5866 Sig(sfSponsorSignature, sponsor),
5867 Ter(tesSUCCESS));
5868 env.close();
5869 }
5870
5871 void
5873 {
5874 // Deleting a co-signed reserve-sponsored object must
5875 // refund the sponsor's SponsoringOwnerCount back to zero.
5876 testcase("Sponsored object deletion refunds sponsor owner count");
5877 using namespace test::jtx;
5878
5879 Env env{*this, testableAmendments()};
5880 Account const sponsor("sponsor");
5881 env.fund(XRP(100000), sponsor);
5882 env.close();
5883
5884 // Sponsored Check deletion - verify decreaseOwnerCountForObject
5885 // (used by CheckCancel) reads the object's sfSponsor field and refunds
5886 // the sponsor's owner count.
5887 {
5888 testcase(" — Check deletion");
5889
5890 Account const checkOwner("check_owner");
5891 Account const dest("check_dest");
5892 env.fund(XRP(100000), checkOwner, dest);
5893 env.close();
5894
5895 // Create a check with co-signed reserve sponsorship. This bumps the
5896 // sponsor's sfSponsoringOwnerCount rather than the check owner's.
5897 auto const checkSeq = env.seq(checkOwner);
5898 env(check::create(checkOwner, dest, XRP(1)),
5900 Sig(sfSponsorSignature, sponsor));
5901 env.close();
5902
5903 auto sponsorCountBefore = sponsoringOwnerCount(env, sponsor);
5904 BEAST_EXPECT(sponsorCountBefore == 1); // check costs 1 owner count
5905
5906 // Cancel (delete) the check.
5907 env(check::cancel(
5908 checkOwner, keylet::check(checkOwner, SeqProxy::rawSequence(checkSeq)).key));
5909 env.close();
5910
5911 auto sponsorCountAfter = sponsoringOwnerCount(env, sponsor);
5912 BEAST_EXPECT(sponsorCountAfter == 0); // fully refunded
5913 }
5914
5915 // Sponsored TrustSet (trust line) deletion - verify the sponsor
5916 // refund works when a sponsored trust line is deleted
5917 {
5918 testcase(" — TrustLine deletion");
5919
5920 Account const issuer("issuer");
5921 Account const holder("holder");
5922 env.fund(XRP(100000), issuer, holder);
5923 env.close();
5924
5925 auto const usd = issuer["USD"];
5926
5927 // Create trust line with sponsorship on the holder side
5928 env(trust(holder, usd(1000)),
5930 Sig(sfSponsorSignature, sponsor));
5931 env.close();
5932
5933 auto sponsorCountBefore = sponsoringOwnerCount(env, sponsor);
5934 BEAST_EXPECT(sponsorCountBefore == 1); // trust line costs 1
5935
5936 // Delete the trust line by clearing it to default
5937 env(trust(holder, usd(0)));
5938 env.close();
5939
5940 auto sponsorCountAfter = sponsoringOwnerCount(env, sponsor);
5941 BEAST_EXPECT(sponsorCountAfter == 0); // fully refunded
5942 }
5943 }
5944
5945protected:
5946 void
5995
5996 void
5997 testTxSponsor(bool cosigning)
5998 {
5999 testSponsorReserve(cosigning);
6000 }
6001
6002public:
6003 void
6004 run() override
6005 {
6006 testSponsor();
6007 }
6008};
6009
6011{
6012 void
6013 run() override
6014 {
6015 testTxSponsor(true);
6016 }
6017};
6018
6020{
6021 void
6022 run() override
6023 {
6024 testTxSponsor(false);
6025 }
6026};
6027
6029BEAST_DEFINE_TESTSUITE(SponsorTxCosigning, app, xrpl);
6030BEAST_DEFINE_TESTSUITE(SponsorTxPrefunded, app, xrpl);
6031
6032} // namespace xrpl::test
A generic endpoint for log messages.
Definition Journal.h:44
A testsuite class.
Definition suite.h:52
TestcaseT testcase
Memberspace for declaring test cases.
Definition suite.h:155
Represents a JSON value.
Definition json_value.h:121
Value removeMember(char const *key)
Remove and return the named member.
Number is a floating point type that can represent a wide range of values.
Definition Number.h:351
bool modify(ModifyType const &f)
Modify the open ledger.
Writable ledger view that accumulates state and tx changes.
Definition OpenView.h:59
void rawReplace(SLE::Ref sle) override
Unconditionally replace a state item.
Definition OpenView.cpp:246
SLE::const_pointer read(Keylet const &k) const override
Return the state item associated with a key.
Definition OpenView.cpp:170
Rules const & rules() const override
Returns the tx processing rules.
Definition OpenView.cpp:151
Slice slice() const noexcept
Definition PublicKey.h:115
static constexpr SeqProxy rawSequence(std::uint32_t v)
Factory function to return a sequence-based SeqProxy.
Definition SeqProxy.h:62
static constexpr SeqProxy rawTicket(std::uint32_t v)
Factory function to return a ticket-based SeqProxy.
Definition SeqProxy.h:74
virtual OpenLedger & getOpenLedger()=0
void run() override
Runs the suite.
void run() override
Runs the suite.
void testPayChan(bool cosigning)
void testTxSponsor(bool cosigning)
void testTransferSponsor(FeatureBitset features)
void testSponsorReserveSimple(bool cosigning)
void run() override
Runs the suite.
void testCredential(bool cosigning)
void testSingleSigning(FeatureBitset features)
void testSignerList(bool cosigning)
void testTrustSet(bool cosigning)
void testSponsorReserve(bool cosigning)
void testCheck(bool cosigning)
void testDelegate(bool cosigning)
void testEscrow(bool cosigning)
void testZeroBalanceSponsoredPaymentFeePayerCheck()
void testEachSponsorship(test::jtx::Env &env, bool cosigning, jtx::Account const &sponsor, jtx::Account const &sponsee, uint32_t reserveCount, uint32_t sponsorReserveCount, TER insufficientReserveResult, SubmitCallback callback, std::optional< std::function< void()> > expected=std::nullopt)
void testMPToken(bool cosigning)
void testMultiSigning(FeatureBitset features)
void testCoSignReserveBoundedBySponsorshipBudget()
void testDepositPreauth(bool cosigning)
Immutable cryptographic account descriptor.
Definition jtx/Account.h:21
std::string const & human() const
Returns the human readable public key.
PublicKey const & pk() const
Return the public key.
Definition jtx/Account.h:84
AccountID id() const
Returns the Account ID.
A transaction testing environment.
Definition Env.h:161
Application & app()
Definition Env.h:300
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
std::shared_ptr< ReadView const > closed()
Returns the last closed ledger.
Definition Env.cpp:127
void fund(bool setDefaultRipple, STAmount const &amount, Account const &account)
Definition Env.cpp:323
std::uint32_t seq(Account const &account) const
Returns the next sequence number on account.
Definition Env.cpp:302
Account const & master
Definition Env.h:165
JTx jt(JsonValue &&jv, FN const &... fN)
Create a JTx from parameters.
Definition Env.h:723
PrettyAmount balance(Account const &account) const
Returns the XRP balance on an account.
Definition Env.cpp:201
void trust(STAmount const &amount, Account const &account)
Establish trust lines.
Definition Env.cpp:354
JTx jtnofill(JsonValue &&jv, FN const &... fN)
Create a JTx from parameters.
Definition Env.h:737
void memoize(Account const &account)
Associate AccountID with account.
Definition Env.cpp:174
beast::Journal const journal
Definition Env.h:204
std::shared_ptr< OpenView const > current() const
Returns the current ledger.
Definition Env.h:377
NetClock::time_point now()
Returns the current network time.
Definition Env.h:326
Set the fee on a JTx.
Definition fee.h:20
Test helper for creating, mutating, and asserting MPT and confidential MPT ledger state.
Definition mpt.h:512
static json::Value authorizeJV(MPTAuthorize const &arg=MPTAuthorize{})
Definition mpt.cpp:444
void create(MPTCreate const &arg=MPTCreate{}, std::source_location const &loc=std::source_location::current())
Definition mpt.cpp:346
Set a multisignature on a JTx.
Definition multisign.h:53
Add a path.
Definition paths.h:47
Sets the SendMax on a JTx.
Definition sendmax.h:16
Set the regular signature on a JTx.
Definition sig.h:19
Set the expected result code for a JTx The test will fail if the code doesn't match.
Definition ter.h:18
Set the flags on a JTx.
Definition txflags.h:14
Adds an inner Batch transaction to a JTx and autofills it.
Definition batch.h:91
Sets the Batch transaction signers on a JTx.
Definition batch.h:142
Set a ticket sequence on a JTx.
Definition ticket.h:36
T make_shared(T... args)
T max(T... args)
Keylet computation functions.
Definition Indexes.h:39
Keylet const & skip() noexcept
The index of the "short" skip list.
Definition Indexes.cpp:245
Keylet escrow(AccountID const &src, SeqProxy const &seq) noexcept
An escrow entry.
Definition Indexes.cpp:430
Keylet did(AccountID const &account) noexcept
Definition Indexes.cpp:529
Keylet depositPreauth(AccountID const &owner, AccountID const &preauthorized) noexcept
A DepositPreauth.
Definition Indexes.cpp:386
Keylet const & feeSettings() noexcept
The (fixed) index of the object containing the ledger fees.
Definition Indexes.cpp:267
Keylet signerList(AccountID const &account) noexcept
A SignerList.
Definition Indexes.cpp:360
Keylet ownerDir(AccountID const &id) noexcept
The root page of an account's directory.
Definition Indexes.cpp:415
Keylet check(AccountID const &id, SeqProxy const &seq) noexcept
A Check.
Definition Indexes.cpp:372
Keylet unchecked(UInt256 const &key) noexcept
Any ledger entry.
Definition Indexes.cpp:409
Keylet ticket(AccountID const &id, SeqProxy const &ticketSeq)
A ticket belonging to an account.
Definition Indexes.cpp:344
Keylet nftokenPageMax(AccountID const &owner)
A keylet for the owner's last possible NFT page.
Definition Indexes.cpp:450
Keylet mptoken(MPTID const &issuanceID, AccountID const &holder) noexcept
Definition Indexes.cpp:547
Keylet delegate(AccountID const &account, AccountID const &authorizedAccount) noexcept
A keylet for Delegate object.
Definition Indexes.cpp:523
Keylet loanBroker(AccountID const &owner, SeqProxy const &seq) noexcept
Definition Indexes.cpp:571
Keylet account(AccountID const &id) noexcept
AccountID root.
Definition Indexes.cpp:233
Keylet sponsorship(AccountID const &sponsor, AccountID const &sponsee) noexcept
A Sponsorship.
Definition Indexes.cpp:366
Keylet loan(UInt256 const &loanBrokerID, SeqProxy const &loanSeq) noexcept
Definition Indexes.cpp:577
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
json::Value outer(jtx::Account const &account, uint32_t seq, STAmount const &fee, std::uint32_t flags)
Build an outer Batch transaction JSON object.
Definition batch.cpp:55
XRPAmount calcBatchFee(jtx::Env const &env, uint32_t const &numSigners, uint32_t const &txns=0)
Calculate the expected outer Batch transaction fee.
Definition batch.cpp:37
json::Value cancel(jtx::Account const &dest, UInt256 const &checkId)
Cancel a check.
Definition check.cpp:39
json::Value cash(jtx::Account const &dest, UInt256 const &checkId, STAmount const &amount)
Cash a check requiring that a specific amount be delivered.
Definition check.cpp:15
json::Value create(A const &account, A const &dest, STAmount const &sendMax)
Create a check.
json::Value deleteCred(jtx::Account const &acc, jtx::Account const &subject, jtx::Account const &issuer, std::string_view credType)
Definition creds.cpp:40
json::Value accept(jtx::Account const &subject, jtx::Account const &issuer, std::string_view credType)
Definition creds.cpp:29
json::Value create(jtx::Account const &subject, jtx::Account const &issuer, std::string_view credType)
Definition creds.cpp:16
Keylet keylet(test::jtx::Account const &subject, test::jtx::Account const &issuer, std::string_view credType)
Definition credentials.h:21
json::Value set(jtx::Account const &account, jtx::Account const &authorize, std::vector< std::string > const &permissions)
Definition delegate.cpp:17
json::Value unauthCredentials(jtx::Account const &account, std::vector< AuthorizeCredentials > const &auth)
Definition deposit.cpp:56
json::Value authCredentials(jtx::Account const &account, std::vector< AuthorizeCredentials > const &auth)
Definition deposit.cpp:38
json::Value auth(Account const &account, Account const &auth)
Preauthorize for deposit.
Definition deposit.cpp:16
json::Value unauth(Account const &account, Account const &unauth)
Remove pre-authorization for deposit.
Definition deposit.cpp:27
json::Value setValid(jtx::Account const &account)
Definition dids.cpp:25
json::Value create(AccountID const &account, AccountID const &to, STAmount const &amount)
Definition escrow.cpp:24
json::Value cancel(AccountID const &account, Account const &from, std::uint32_t seq)
Definition escrow.cpp:48
auto const kCondition
Definition escrow.h:100
auto const kCancelTime
Set the "CancelAfter" time tag on a JTx.
Definition escrow.h:98
auto const kFulfillment
Definition escrow.h:102
json::Value finish(AccountID const &account, AccountID const &from, std::uint32_t seq)
Definition escrow.cpp:36
std::array< std::uint8_t, 4 > const kFb1
Definition escrow.h:58
std::array< std::uint8_t, 39 > const kCb1
Definition escrow.h:60
json::Value nftPageLinks(jtx::Account const &acct, jtx::Account const &owner)
Repair the links in an NFToken directory.
json::Value set(AccountID const &account, UInt256 const &vaultId, uint32_t flags)
json::Value set(AccountID const &account, UInt256 const &loanBrokerID, Number principalRequested, std::uint32_t flags)
json::Value create(AccountID const &account, AccountID const &to, STAmount const &amount, NetClock::duration const &settleDelay, PublicKey const &pk, std::optional< NetClock::time_point > const &cancelAfter, std::optional< std::uint32_t > const &dstTag)
Definition paychan.cpp:31
uint256 channel(AccountID const &account, AccountID const &dst, std::uint32_t seqProxyValue)
Definition paychan.cpp:96
json::Value claim(AccountID const &account, uint256 const &channel, std::optional< STAmount > const &balance, std::optional< STAmount > const &amount, std::optional< Slice > const &signature, std::optional< PublicKey > const &pk)
Definition paychan.cpp:72
STAmount channelAmount(ReadView const &view, uint256 const &chan)
Definition paychan.cpp:113
bool channelExists(ReadView const &view, uint256 const &chan)
Definition paychan.cpp:122
json::Value transfer(jtx::Account const &account, uint32_t flags, std::optional< UInt256 > const &index)
Definition sponsor.cpp:52
json::Value set_fee(jtx::Account const &account, std::uint32_t flags, STAmount feeAmountDelta, std::optional< STAmount > maxFee=std::nullopt)
Definition sponsor.h:26
json::Value set_reserve(jtx::Account const &account, std::uint32_t flags, std::int32_t reserveCountDelta)
Definition sponsor.h:36
STAmount sponsorshipFeeBalance(jtx::Env const &env, jtx::Account const &sponsor, jtx::Account const &sponsee)
Definition sponsor.cpp:93
json::Value set_max_fee(jtx::Account const &account, std::uint32_t flags, STAmount maxFee)
Definition sponsor.h:42
json::Value del(jtx::Account const &account)
Definition sponsor.cpp:42
json::Value set(jtx::Account const &account, uint32_t flags, std::optional< int32_t > const reserveCountDelta, std::optional< STAmount > const feeAmountDelta, std::optional< STAmount > const maxFee)
Definition sponsor.cpp:22
json::Value create(Account const &account, std::uint32_t count)
Create one of more tickets.
Definition ticket.cpp:16
json::Value mint(jtx::Account const &account, std::uint32_t nfTokenTaxon)
Mint an NFToken.
Definition token.cpp:23
json::Value pay(AccountID const &account, AccountID const &to, AnyAmount amount)
Create a payment.
Definition pay.cpp:14
json::Value regkey(Account const &account, DisabledT)
Disable the regular key.
Definition regkey.cpp:13
XrpT const XRP
Converts to XRP Issue or STAmount.
Definition amount.cpp:92
json::Value noop(Account const &account)
The null transaction.
Definition noop.h:14
std::uint32_t sponsoringAccountCount(Env const &env, Account const &account)
std::uint32_t ownerCount(Env const &env, Account const &account)
json::Value fclear(Account const &account, std::uint32_t off)
Remove account flag.
Definition flags.h:110
std::uint32_t sponsoringOwnerCount(Env const &env, Account const &account)
FeatureBitset testableAmendments()
Definition Env.h:92
json::Value acctdelete(Account const &account, Account const &dest)
Delete account.
void incLgrSeqForAccDel(jtx::Env &env, jtx::Account const &acc, std::uint32_t margin=0)
json::Value offer(Account const &account, STAmount const &takerPays, STAmount const &takerGets, std::uint32_t flags)
Create an offer.
Definition offer.cpp:14
std::uint32_t sponsoredOwnerCount(Env const &env, Account const &account)
json::Value trust(Account const &account, STAmount const &amount, std::uint32_t flags)
Modify a trust line.
Definition trust.cpp:18
PrettyAmount drops(Integer i)
Returns an XRP PrettyAmount, which is trivially convertible to STAmount.
json::Value signers(Account const &account, std::uint32_t quorum, std::vector< Signer > const &v)
Definition multisign.cpp:31
json::Value fset(Account const &account, std::uint32_t on, std::uint32_t off=0)
Add and/or remove flag.
Definition flags.cpp:15
BEAST_DEFINE_TESTSUITE(AMMClawback, app, xrpl)
static void adjustAccountXRPBalance(jtx::Env &env, jtx::Account const &account, STAmount const &balanceTo)
static STAmount accountReserve(jtx::Env const &env, std::uint32_t count=1)
static XRPAmount reserve(jtx::Env const &env, std::uint32_t count)
Use hash_* containers for keys that do not need a cryptographically secure hashing algorithm.
Definition algorithm.h:5
constexpr FlagValue spfSponsorFee
Definition TxFlags.h:467
@ telINSUF_FEE_P
Definition TER.h:43
@ telENV_RPC_FAILED
Definition TER.h:54
@ terNO_PERMISSION
Definition TER.h:234
@ terINSUF_FEE_B
Definition TER.h:218
@ terNO_DELEGATE_PERMISSION
Definition TER.h:232
@ terNO_ACCOUNT
Definition TER.h:219
Issue const & xrpIssue()
Returns an asset specifier that represents XRP.
Definition Issue.h:108
constexpr FlagValue tfInnerBatchTxn
Definition TxFlags.h:44
PreflightResult preflight(ServiceRegistry &registry, Rules const &rules, STTx const &tx, ApplyFlags flags, beast::Journal j)
Gate a transaction based on static information.
bool isXRP(AccountID const &c)
Definition AccountID.h:84
PreclaimResult preclaim(PreflightResult const &preflightResult, ServiceRegistry &registry, OpenView const &view)
Gate a transaction based on static ledger information.
ApplyResult apply(ServiceRegistry &registry, OpenView &view, STTx const &tx, ApplyFlags flags, beast::Journal journal)
Apply a transaction to an OpenView.
Definition apply.cpp:181
std::string strHex(FwdIt begin, FwdIt end)
Definition strHex.h:13
@ tefBAD_QUORUM
Definition TER.h:174
@ tefMASTER_DISABLED
Definition TER.h:171
@ tefBAD_SIGNATURE
Definition TER.h:173
@ tefBAD_AUTH
Definition TER.h:163
@ tefNOT_MULTI_SIGNING
Definition TER.h:175
TenthBips< std::uint32_t > TenthBips32
Definition Units.h:454
TenthBips< std::uint16_t > TenthBips16
Definition Units.h:453
std::string to_string(BaseUInt< Bits, Tag > const &a)
Definition base_uint.h:658
BaseUInt< 256 > UInt256
Definition base_uint.h:581
BaseUInt< 192 > MPTID
MPTID is a 192-bit value representing MPT Issuance ID, which is a concatenation of a 32-bit sequence ...
Definition UintTypes.h:54
MPTID makeMptID(std::uint32_t const sequence, AccountID const &account)
Definition Indexes.cpp:219
@ TapNone
Definition ApplyView.h:28
@ temINVALID
Definition TER.h:98
@ temINVALID_FLAG
Definition TER.h:99
@ temMALFORMED
Definition TER.h:75
@ temDISABLED
Definition TER.h:102
@ temBAD_AMOUNT
Definition TER.h:77
@ temBAD_SIGNATURE
Definition TER.h:93
@ temREDUNDANT
Definition TER.h:100
@ temBAD_SIGNER
Definition TER.h:103
bool isTesSuccess(TER x) noexcept
Definition TER.h:686
TERSubset< CanCvtToTER > TER
Definition TER.h:657
@ tecPSEUDO_ACCOUNT
Definition TER.h:373
@ tecNO_LINE_INSUF_RESERVE
Definition TER.h:303
@ tecINSUF_RESERVE_LINE
Definition TER.h:299
@ tecINSUFF_FEE
Definition TER.h:313
@ tecUNFUNDED_PAYMENT
Definition TER.h:296
@ tecNO_ENTRY
Definition TER.h:317
@ tecNO_SPONSOR_PERMISSION
Definition TER.h:380
@ tecFAILED_PROCESSING
Definition TER.h:297
@ tecINSUFFICIENT_RESERVE
Definition TER.h:318
@ tecLIMIT_EXCEEDED
Definition TER.h:372
@ tecNO_PERMISSION
Definition TER.h:316
@ tecHAS_OBLIGATIONS
Definition TER.h:328
@ tecNO_DST
Definition TER.h:301
@ tecUNFUNDED
Definition TER.h:306
std::vector< unsigned char > Blob
Storage for linear binary data.
Definition Blob.h:11
TypedField< STAccount > SF_ACCOUNT
Definition SField.h:356
ApplyResult doApply(PreclaimResult const &preclaimResult, ServiceRegistry &registry, OpenView &view)
Apply a prechecked transaction to an OpenView.
constexpr FlagValue spfSponsorReserve
Definition TxFlags.h:468
@ tesSUCCESS
Definition TER.h:253
A pair of SHAMap key and LedgerEntryType.
Definition Keylet.h:20
UInt256 key
Definition Keylet.h:21
json::Value jv
Definition JTx.h:28
Set the sequence number on a JTx.
Definition seq.h:16
A signer in a SignerList.
Definition multisign.h:27