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>
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>
78 return env.
current()->fees().reserve * count;
84 return env.
current()->fees().accountReserve(count, 1);
91 XRPL_ASSERT(
isXRP(balanceTo),
"adjustAccountXRPBalance: balanceTo must be XRP");
92 auto const currentBalance = env.
balance(account);
93 if (currentBalance == balanceTo)
96 auto const baseFee = env.
current()->fees().base;
97 if (currentBalance > balanceTo)
99 env(
pay(account, env.
master, currentBalance - balanceTo),
106 env(
pay(env.
master, account, balanceTo - currentBalance),
Fee(baseFee));
126 auto const jt =
noop(alice);
128 jt1[sfSponsor.jsonName] =
sponsor.human();
150 Account const noFunded(
"noFunded");
153 auto const usd = gw[
"usd"];
169 tfSponsorshipSetRequireSignForFee | tfSponsorshipClearRequireSignForFee),
175 tfSponsorshipSetRequireSignForReserve |
176 tfSponsorshipClearRequireSignForReserve),
180 for (
auto const flag : {
181 tfSponsorshipSetRequireSignForFee,
182 tfSponsorshipClearRequireSignForFee,
183 tfSponsorshipSetRequireSignForReserve,
184 tfSponsorshipClearRequireSignForReserve,
207 for (
auto const& amt : {
XRP(0), usd(1)})
214 for (
auto const& amt : {
XRP(-1), usd(1)})
344 testcase(
"Pseudo account sponsorship");
352 Asset const asset = gw[
"IOU"].asset();
354 env.
fund(
XRP(1000000), alice, bob, gw, sp);
358 Vault const vault{env};
359 auto [tx,
keylet] = vault.create({.owner = alice, .asset = asset});
363 auto const vaultSle = env.
le(
keylet);
364 BEAST_EXPECT(vaultSle);
365 Account const pseudoAcc(
"vault", vaultSle->getAccountID(sfAccount));
387 Env env{*
this, features};
390 Account const invalid(
"invalid");
396 auto tx =
noop(alice);
397 tx[sfSponsor.jsonName] =
sponsor.human();
398 tx[sfSponsorSignature.jsonName][sfSigningPubKey.jsonName] =
strHex(
sponsor.pk().slice());
403 tx[sfSponsorSignature.jsonName][sfTxnSignature.jsonName] =
"DEADBEEF";
410 Sig(sfSponsorSignature, invalid),
421 Account const regKey(
"regKey");
423 env.
fund(
XRP(10000), regKey, other);
430 Sig(sfSponsorSignature, regKey),
437 Sig(sfSponsorSignature, other),
442 Account const sponsorDM(
"sponsorDM");
443 env.
fund(
XRP(10000), sponsorDM);
445 env(
regkey(sponsorDM, regKey));
446 env(
fset(sponsorDM, asfDisableMaster),
Sig(sponsorDM));
451 Sig(sfSponsorSignature, sponsorDM),
459 Vault const vault{env};
460 auto [vtx, vkey] = vault.create({.owner = alice, .asset = gw[
"IOU"].asset()});
463 auto const vaultSle = env.
le(vkey);
464 BEAST_EXPECT(vaultSle);
465 Account const pseudoAcc(
"vault", vaultSle->getAccountID(sfAccount));
470 Sig(sfSponsorSignature, other),
479 Env env{*
this, features};
483 Account const signer1(
"signer1");
484 Account const signer2(
"signer2");
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";
504 Msig(sfSponsorSignature, {signer1}),
510 Msig(sfSponsorSignature, {signer1}),
518 auto const baseFee = env.
current()->fees().base;
520 Fee(baseFee + 2 * baseFee - 1),
522 Msig(sfSponsorSignature, {signer1, signer2}),
526 Fee(baseFee + 2 * baseFee),
528 Msig(sfSponsorSignature, {signer1, signer2}),
536 Msig(sfSponsorSignature, {signer1}),
540 Account const stranger(
"stranger");
541 env.
fund(
XRP(10000), stranger);
546 Msig(sfSponsorSignature, {stranger}),
558 Account const noFunded(
"noFunded");
573 Sig(sfSponsorSignature, noFunded),
585 auto tx =
noop(alice);
586 tx[sfSponsor.jsonName] =
sponsor.human();
610 tfSponsorshipSetRequireSignForFee | tfSponsorshipSetRequireSignForReserve,
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));
637 BEAST_EXPECT(sle->at(sfRemainingOwnerCount) == 50);
638 BEAST_EXPECT(sle->at(sfFeeAmount) ==
XRP(50));
639 BEAST_EXPECT(sle->at(sfMaxFee) ==
XRP(0.5));
651 BEAST_EXPECT(sle->at(sfRemainingOwnerCount) == 200);
652 BEAST_EXPECT(sle->at(sfFeeAmount) ==
XRP(200));
653 BEAST_EXPECT(sle->at(sfMaxFee) ==
XRP(2));
664 tfSponsorshipSetRequireSignForFee | tfSponsorshipSetRequireSignForReserve,
709 BEAST_EXPECT(sle->at(sfRemainingOwnerCount) == 100);
710 BEAST_EXPECT(sle->at(sfFeeAmount) ==
XRP(101));
711 BEAST_EXPECT(sle->at(sfMaxFee) ==
XRP(1));
714 auto const testFlagUpdate = [&](
auto setFlag,
auto clearFlag,
auto ledgerFlag) {
720 BEAST_EXPECT(sle->isFlag(ledgerFlag));
727 BEAST_EXPECT(!sle->isFlag(ledgerFlag));
731 tfSponsorshipSetRequireSignForFee,
732 tfSponsorshipClearRequireSignForFee,
733 lsfSponsorshipRequireSignForFee);
735 tfSponsorshipSetRequireSignForReserve,
736 tfSponsorshipClearRequireSignForReserve,
737 lsfSponsorshipRequireSignForReserve);
748 BEAST_EXPECT(sle->at(sfRemainingOwnerCount) == 100);
749 BEAST_EXPECT(sle->at(sfFeeAmount) ==
XRP(101));
750 BEAST_EXPECT(sle->at(sfMaxFee) ==
XRP(1));
767 BEAST_EXPECT(!sle->isFieldPresent(sfFeeAmount));
768 BEAST_EXPECT(sle->at(sfRemainingOwnerCount) == 100);
790 BEAST_EXPECT(!sle->isFieldPresent(sfFeeAmount));
791 BEAST_EXPECT(sle->at(sfRemainingOwnerCount) == 100);
809 BEAST_EXPECT(!sle->isFieldPresent(sfRemainingOwnerCount));
810 BEAST_EXPECT(sle->at(sfFeeAmount) ==
XRP(100));
825 BEAST_EXPECT(!sle->isFieldPresent(sfRemainingOwnerCount));
826 BEAST_EXPECT(sle->at(sfFeeAmount) ==
XRP(100));
882 testcase(
"RemainingOwnerCount overflow and underflow clamping");
943 BEAST_EXPECT(!sle->isFieldPresent(sfRemainingOwnerCount));
944 BEAST_EXPECT(sle->at(sfFeeAmount) ==
XRP(100));
979 auto const baseFee = env.
current()->fees().base;
988 auto const jt = env.
jt(
996 BEAST_EXPECT(!pf.consequences.isBlocker());
997 BEAST_EXPECT(pf.consequences.fee() ==
drops(baseFee));
998 BEAST_EXPECT(pf.consequences.potentialSpend() ==
XRP(100));
1004 auto const jt = env.
jt(
1012 BEAST_EXPECT(!pf.consequences.isBlocker());
1013 BEAST_EXPECT(pf.consequences.fee() ==
drops(baseFee));
1014 BEAST_EXPECT(pf.consequences.potentialSpend() ==
XRP(0));
1019 auto const jt = env.
jt(
1027 BEAST_EXPECT(!pf.consequences.isBlocker());
1028 BEAST_EXPECT(pf.consequences.fee() ==
drops(baseFee));
1029 BEAST_EXPECT(pf.consequences.potentialSpend() ==
XRP(0));
1040 Account const charlie(
"charlie");
1054 auto const checkSeq = env.
seq(alice);
1064 BEAST_EXPECT(sle->at(sfRemainingOwnerCount) == 99);
1065 BEAST_EXPECT(sle->at(sfFeeAmount) ==
XRP(99));
1073 BEAST_EXPECT(sle->at(sfRemainingOwnerCount) == 99);
1074 BEAST_EXPECT(sle->at(sfFeeAmount) ==
XRP(99));
1112 testcase(
"Sponsored Free-Tier Reserve");
1115 Account const issuer(
"issuer");
1123 env.
fund(
XRP(10000), alice, issuer);
1130 MPTTester mptt(env, issuer, {.fund =
false});
1136 env(
trust(alice, issuer[
"USD"](100)),
1155 (features[fixCleanup3_4_0] ?
"(fixCleanup3_4_0 enabled)"
1156 :
"(fixCleanup3_4_0 disabled)"));
1161 Env env{*
this, features};
1173 (tfSponsorshipCreate | tfSponsorshipReassign | tfSponsorshipEnd) + 1),
1181 for (
auto const flag : {
1182 tfSponsorshipCreate | tfSponsorshipReassign,
1183 tfSponsorshipCreate | tfSponsorshipEnd,
1184 tfSponsorshipReassign | tfSponsorshipEnd,
1185 tfSponsorshipCreate | tfSponsorshipReassign | tfSponsorshipEnd,
1244 if (features[fixCleanup3_5_0])
1264 Env env{*
this, features};
1267 Account const charlie(
"charlie");
1309 Env env{*
this, features};
1312 Account const sponsor1(
"sponsor1");
1313 Account const sponsor2(
"sponsor2");
1314 env.
fund(
XRP(10000), alice, bob, sponsor1, sponsor2);
1326 Sig(sfSponsorSignature, sponsor1),
1334 Sig(sfSponsorSignature, sponsor1));
1344 BEAST_EXPECT(sle1->isFieldPresent(sfSponsor));
1345 BEAST_EXPECT(sle1->getAccountID(sfSponsor) == sponsor1.
id());
1352 Sig(sfSponsorSignature, sponsor2),
1360 Sig(sfSponsorSignature, sponsor2));
1375 BEAST_EXPECT(sle2->isFieldPresent(sfSponsor));
1376 BEAST_EXPECT(sle2->getAccountID(sfSponsor) == sponsor2.
id());
1381 Sig(sfSponsorSignature, sponsor2),
1391 Sig(sfSponsorSignature, sponsor2));
1415 BEAST_EXPECT(!sle3->isFieldPresent(sfSponsor));
1432 BEAST_EXPECT(!sle4->isFieldPresent(sfSponsor));
1440 Env env{*
this, features};
1452 BEAST_EXPECT(env.
le(alice)->getAccountID(sfSponsor) ==
sponsor.id());
1458 BEAST_EXPECT(!env.
le(alice)->isFieldPresent(sfSponsor));
1464 Env env{*
this, features};
1467 Account const sponsor1(
"sponsor1");
1468 Account const sponsor2(
"sponsor2");
1469 env.
fund(
XRP(10000), alice, bob, sponsor1, sponsor2);
1475 auto const seq = env.
seq(alice);
1484 Sig(sfSponsorSignature, sponsor1),
1488 env(
pay(alice, sponsor1,
drops(1)));
1495 Sig(sfSponsorSignature, sponsor1),
1502 Sig(sfSponsorSignature, sponsor1),
1509 Sig(sfSponsorSignature, sponsor1),
1516 Sig(sfSponsorSignature, sponsor1));
1527 BEAST_EXPECT(sle1->isFieldPresent(sfSponsor));
1528 BEAST_EXPECT(sle1->getAccountID(sfSponsor) == sponsor1.
id());
1533 Sig(sfSponsorSignature, sponsor2),
1540 Sig(sfSponsorSignature, sponsor1),
1549 Sig(sfSponsorSignature, sponsor2),
1552 env(
pay(alice, sponsor2,
drops(1)));
1557 Sig(sfSponsorSignature, sponsor2));
1570 BEAST_EXPECT(sle2->isFieldPresent(sfSponsor));
1571 BEAST_EXPECT(sle2->getAccountID(sfSponsor) == sponsor2.
id());
1577 if (features[fixCleanup3_4_0])
1602 BEAST_EXPECT(!sle3->isFieldPresent(sfSponsor));
1607 auto const ticketSeq = env.
seq(alice);
1619 Env env{*
this, features};
1622 Account const sponsor1(
"sponsor1");
1623 Account const sponsor2(
"sponsor2");
1624 env.
fund(
XRP(10000), alice, bob, sponsor1, sponsor2);
1627 auto const seq = env.
seq(alice);
1653 Env env{*
this, features};
1656 Account const sponsor1(
"sponsor1");
1657 Account const sponsor2(
"sponsor2");
1658 env.
fund(
XRP(10000), alice, bob, sponsor1, sponsor2);
1661 auto const seq = env.
seq(alice);
1691 BEAST_EXPECT(checkSle->isFieldPresent(sfSponsor));
1692 BEAST_EXPECT(checkSle->getAccountID(sfSponsor) == sponsor1.
id());
1694 BEAST_EXPECT(sponsor1Sle->getFieldU32(sfRemainingOwnerCount) == 99);
1704 BEAST_EXPECT(sponsor1Sle->getFieldU32(sfRemainingOwnerCount) == 99);
1725 BEAST_EXPECT(checkSle->isFieldPresent(sfSponsor));
1726 BEAST_EXPECT(checkSle->getAccountID(sfSponsor) == sponsor2.
id());
1728 BEAST_EXPECT(sponsor1Sle->getFieldU32(sfRemainingOwnerCount) == 99);
1730 BEAST_EXPECT(sponsor2Sle->getFieldU32(sfRemainingOwnerCount) == 99);
1749 BEAST_EXPECT(!checkSle->isFieldPresent(sfSponsor));
1751 BEAST_EXPECT(sponsor2Sle->getFieldU32(sfRemainingOwnerCount) == 99);
1756 Env env{*
this, features};
1763 auto const seq = env.
seq(alice);
1796 Env env{*
this, features};
1803 auto const seq = env.
seq(alice);
1849 auto const& highAcc = alice > bob ? alice : bob;
1850 auto const& lowAcc = alice > bob ? bob : alice;
1852 for (
bool const isIssuerHigh : {
false,
true})
1854 Env env{*
this, features};
1858 auto const& issuer = isIssuerHigh ? highAcc : lowAcc;
1859 auto const& user = isIssuerHigh ? lowAcc : highAcc;
1861 auto const usd = issuer[
"usd"];
1862 auto const currency = usd.currency;
1864 env(
trust(user, issuer[
"usd"](100)));
1868 BEAST_EXPECT(env.
le(trustId));
1876 BEAST_EXPECT(env.
le(trustId));
1879 env.
le(trustId)->getAccountID(isIssuerHigh ? sfLowSponsor : sfHighSponsor) ==
1882 !env.
le(trustId)->isFieldPresent(isIssuerHigh ? sfHighSponsor : sfLowSponsor));
1888 BEAST_EXPECT(env.
le(trustId));
1890 !env.
le(trustId)->isFieldPresent(isIssuerHigh ? sfLowSponsor : sfHighSponsor));
1892 !env.
le(trustId)->isFieldPresent(isIssuerHigh ? sfHighSponsor : sfLowSponsor));
1898 Env env{*
this, features};
1915 auto const keylets = {
1923 for (
auto const&
keylet : keylets)
1935 Env env{*
this, features};
1941 auto const checkBlocked = [&](
Account const& account,
UInt256 const& objectID) {
1949 auto const ticketSeq = env.
seq(alice);
1954 checkBlocked(alice, ticketID);
1959 BEAST_EXPECT(env.
le(didKeylet));
1960 checkBlocked(alice, didKeylet.key);
1965 BEAST_EXPECT(env.
le(nftPageKeylet));
1966 checkBlocked(alice, nftPageKeylet.key);
1968 Account const borrower(
"borrower");
1969 env.
fund(
XRP(1000000), borrower);
1973 Vault const vault{env};
1977 auto [vaultTx, vaultKeylet, subscriptionDate] =
1978 vault.createClosedEnded({.owner = alice, .asset = xrpAsset});
1983 {.depositor = alice, .id = vaultKeylet.key, .amount = xrpAsset(1000)}));
1986 vault.closePastSubscription(subscriptionDate);
1988 auto const brokerKeylet =
1998 env(
loan::set(borrower, brokerKeylet.key, xrpAsset(100).value()),
1999 Sig(sfCounterpartySignature, alice),
2002 BEAST_EXPECT(env.
le(loanKeylet));
2003 checkBlocked(borrower, loanKeylet.key);
2020 env.
fund(
XRP(10000), alice, bob);
2026 auto const aliceBalance = env.
balance(alice);
2027 auto const bobBalance = env.
balance(bob);
2030 env(
pay(alice, bob,
XRP(100)),
2036 BEAST_EXPECT(env.
balance(alice) == aliceBalance);
2037 BEAST_EXPECT(env.
balance(bob) == bobBalance);
2046 auto const aliceBalance = env.
balance(alice);
2047 auto const bobBalance = env.
balance(bob);
2050 auto const sendAmt =
XRP(100);
2051 auto const feeAmt =
XRP(10);
2052 env(
pay(alice, bob, sendAmt),
2057 BEAST_EXPECT(env.
balance(alice) == aliceBalance - sendAmt);
2058 BEAST_EXPECT(env.
balance(bob) == bobBalance + sendAmt);
2064 auto const aliceBalance = env.
balance(alice);
2065 auto const bobBalance = env.
balance(bob);
2068 env(
pay(alice, bob,
XRP(100)),
2074 BEAST_EXPECT(env.
balance(alice) == aliceBalance);
2075 BEAST_EXPECT(env.
balance(bob) == bobBalance);
2082 auto const aliceBalance = env.
balance(alice);
2083 auto const bobBalance = env.
balance(bob);
2085 auto const feeAmt =
XRP(10);
2087 env(
pay(alice, bob,
XRP(20000)),
2094 BEAST_EXPECT(env.
balance(alice) == aliceBalance);
2095 BEAST_EXPECT(env.
balance(bob) == bobBalance);
2104 auto const feeAmt =
XRP(10);
2151 auto const aliceBalance = env.
balance(alice);
2152 auto const bobBalance = env.
balance(bob);
2155 env(
pay(alice, bob,
XRP(100)),
2160 BEAST_EXPECT(env.
balance(alice) == aliceBalance);
2161 BEAST_EXPECT(env.
balance(bob) == bobBalance);
2170 auto const aliceBalance = env.
balance(alice);
2171 auto const bobBalance = env.
balance(bob);
2175 auto const sendAmt =
XRP(100);
2176 auto const feeAmt =
XRP(10);
2180 BEAST_EXPECT(env.
balance(alice) == aliceBalance - sendAmt);
2181 BEAST_EXPECT(env.
balance(bob) == bobBalance + sendAmt);
2191 auto const aliceBalance = env.
balance(alice);
2192 auto const bobBalance = env.
balance(bob);
2196 env(
pay(alice, bob,
XRP(100)),
2202 BEAST_EXPECT(env.
balance(alice) == aliceBalance);
2203 BEAST_EXPECT(env.
balance(bob) == bobBalance);
2210 auto const aliceBalance = env.
balance(alice);
2211 auto const bobBalance = env.
balance(bob);
2214 env(
pay(alice, bob,
XRP(100)),
2220 BEAST_EXPECT(env.
balance(alice) == aliceBalance -
XRP(100));
2221 BEAST_EXPECT(env.
balance(bob) == bobBalance +
XRP(100));
2235 auto const aliceBalance = env.
balance(alice);
2236 auto const bobBalance = env.
balance(bob);
2240 env(
pay(alice, bob,
XRP(100)),
2246 BEAST_EXPECT(env.
balance(alice) == aliceBalance);
2247 BEAST_EXPECT(env.
balance(bob) == bobBalance);
2256 auto const aliceBalance = env.
balance(alice);
2257 auto const bobBalance = env.
balance(bob);
2260 auto const feeAmt =
XRP(1);
2262 env(
pay(alice, bob,
XRP(20000)),
2268 BEAST_EXPECT(env.
balance(alice) == aliceBalance);
2269 BEAST_EXPECT(env.
balance(bob) == bobBalance);
2284 auto const sponsorAvailableFee =
2287 Fee(sponsorAvailableFee),
2302 Account const carol(
"sponsor");
2304 env.
fund(
XRP(10000), alice, carol);
2315 auto const jt = env.
jt(
2323 BEAST_EXPECT(result.applied);
2328 BEAST_EXPECT(sle->isFieldPresent(sfFeeAmount));
2329 BEAST_EXPECT(sle->getFieldAmount(sfFeeAmount) ==
drops(990));
2342 auto const fixFee =
drops(env.
current()->fees().increment);
2352 BEAST_EXPECT(!sle->isFieldPresent(sfFeeAmount));
2364 auto const fixFee =
drops(env.
current()->fees().increment);
2369 auto const jt = env.
jt(
2380 if (BEAST_EXPECT(original))
2383 sle->makeFieldAbsent(sfFeeAmount);
2387 auto const result =
doApply(pc, env.
app(), overlay);
2389 BEAST_EXPECT(!result.applied);
2406 env(
pay(alice, bob,
XRP(100)),
2440 env(
pay(alice, bob,
XRP(100)),
2447 env(
pay(alice, bob,
XRP(100)),
2467 Account const sponsor2(
"sponsor2");
2468 Account const sponsor3(
"sponsor3");
2470 Account const charlie(
"charlie");
2473 auto const usd = gw[
"usd"];
2489 for (
auto const flag : {
2495 env(
pay(alice, bob,
XRP(100)),
2496 Txflags(tfSponsorCreatedAccount | flag),
2508 Txflags(tfSponsorCreatedAccount),
2514 Txflags(tfSponsorCreatedAccount),
2521 env(
pay(alice, bob,
drops(env.
current()->fees().accountReserve(0, 1))),
2527 BEAST_EXPECT(!bobSle->isFieldPresent(sfSponsor));
2536 Txflags(tfSponsorCreatedAccount),
2541 BEAST_EXPECT(env.
balance(sponsor2) ==
XRP(9999));
2545 Txflags(tfSponsorCreatedAccount),
2550 auto const sponsor2BalanceBefore = env.
balance(sponsor2);
2555 BEAST_EXPECT(charlieSle->isFieldPresent(sfSponsor));
2556 BEAST_EXPECT(charlieSle->getAccountID(sfSponsor) == sponsor2.
id());
2560 BEAST_EXPECT(env.
balance(sponsor2) == sponsor2BalanceBefore -
drops(1) -
XRP(1));
2565 auto const sendAmount =
drops(1);
2569 env(
pay(sponsor3, dave, sendAmount),
2570 Txflags(tfSponsorCreatedAccount),
2576 env(
pay(sponsor3, dave, sendAmount),
2577 Txflags(tfSponsorCreatedAccount),
2589 testcase(
"SponsorshipRequireSignForReserve");
2624 testcase(
"SponsorshipRequireSignForFee");
2712 template <
typename SubmitCallback>
2719 uint32_t reserveCount,
2720 uint32_t sponsorReserveCount,
2721 TER insufficientReserveResult,
2722 SubmitCallback callback,
2726 auto const sponseeOwnerCountBefore =
ownerCount(env, sponsee);
2739 auto const submit = [&](
TER ter) {
2740 return [&, ter](
json::Value const& jv,
auto const&... fN) {
2759 reserve(env, sponsorCurrentOwnerCount + sponsorReserveCount) -
drops(1));
2770 if (sponsorReserveCount > 1)
2785 auto const sponseeOwnerCountBeforeAttempt =
ownerCount(env, sponsee);
2787 auto const sponseeSponsoringOwnerCountBeforeAttempt =
2791 auto const sponsorSponsoringOwnerCountBeforeAttempt =
2794 bool const reserveCountPresentBeforeAttempt = sponsorshipSleBeforeAttempt &&
2795 sponsorshipSleBeforeAttempt->isFieldPresent(sfRemainingOwnerCount);
2796 std::uint32_t const reserveCountBeforeAttempt = reserveCountPresentBeforeAttempt
2797 ? sponsorshipSleBeforeAttempt->getFieldU32(sfRemainingOwnerCount)
2800 callback(env, submit(insufficientReserveResult));
2803 BEAST_EXPECT(
ownerCount(env, sponsee) == sponseeOwnerCountBeforeAttempt);
2816 static_cast<bool>(sponsorshipSleAfterAttempt) ==
2817 static_cast<bool>(sponsorshipSleBeforeAttempt));
2818 if (sponsorshipSleAfterAttempt)
2821 sponsorshipSleAfterAttempt->isFieldPresent(sfRemainingOwnerCount) ==
2822 reserveCountPresentBeforeAttempt);
2823 if (reserveCountPresentBeforeAttempt)
2826 sponsorshipSleAfterAttempt->getFieldU32(sfRemainingOwnerCount) ==
2827 reserveCountBeforeAttempt);
2837 env,
sponsor,
reserve(env, sponsorCurrentOwnerCount + sponsorReserveCount));
2854 BEAST_EXPECT(sponsorshipSle);
2856 !sponsorshipSle->isFieldPresent(sfRemainingOwnerCount) ||
2857 sponsorshipSle->getFieldU32(sfRemainingOwnerCount) == 0);
2871 BEAST_EXPECT(
ownerCount(env, sponsee) - sponseeOwnerCountBefore == reserveCount);
2874 sponsorReserveCount);
2881 sponsorReserveCount);
2894 Account const sponsor2(
"sponsor2");
2896 auto const usd = gw[
"usd"];
2914 [&](
Env& env,
auto const& submit) {
2915 seq = env.
seq(alice);
2925 BEAST_EXPECT(env.
le(
keylet)->getAccountID(sfSponsor) ==
sponsor.id());
2932 Sig(sfSponsorSignature, sponsor2));
2952 BEAST_EXPECT(env.
le(
keylet)->getAccountID(sfSponsor) == sponsor2.
id());
2979 [&](
Env& env,
auto const& submit) {
2980 seq2 = env.
seq(alice);
3005 env.
trust(usd(100), alice);
3007 env(
pay(gw, alice, usd(100)));
3020 [&](
Env& env,
auto const& submit) {
3021 seq2 = env.
seq(alice);
3029 BEAST_EXPECT(env.
le(
keylet)->getAccountID(sfSponsor) ==
sponsor.id());
3050 bool const bobLow = bob.
id() < gw.
id();
3052 BEAST_EXPECT(lineSle);
3056 lineSle->getAccountID(bobLow ? sfLowSponsor : sfHighSponsor) ==
3059 !lineSle->isFieldPresent(bobLow ? sfHighSponsor : sfLowSponsor));
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)));
3089 [&](
Env& env,
auto const& submit) {
3090 seq2 = env.
seq(alice);
3095 BEAST_EXPECT(env.
le(checkKeylet)->getAccountID(sfSponsor) ==
sponsor.id());
3107 [&](
Env& env,
auto const& submit) {
3108 submit(
check::cash(bob, checkKeylet.key, mpt(1)));
3129 Account const sponsor2(
"sponsor2");
3145 [&](
Env& env,
auto const& submit) {
3151 BEAST_EXPECT(env.
le(
keylet)->getAccountID(sfSponsor) ==
sponsor.id());
3158 Sig(sfSponsorSignature, sponsor2));
3175 BEAST_EXPECT(env.
le(
keylet)->getAccountID(sfSponsor) == sponsor2.
id());
3194 Account const sponsor2(
"sponsor2");
3215 BEAST_EXPECT(env.
le(
keylet)->getAccountID(sfSponsor) ==
sponsor.id());
3222 Sig(sfSponsorSignature, sponsor2));
3235 BEAST_EXPECT(sponsor2Sle);
3239 !sponsor2Sle->isFieldPresent(sfRemainingOwnerCount) ||
3240 sponsor2Sle->getFieldU32(sfRemainingOwnerCount) == 0);
3248 BEAST_EXPECT(env.
le(
keylet)->getAccountID(sfSponsor) == sponsor2.
id());
3265 {.issuer =
sponsor, .credType = credType},
3270 {sponsor.id(), Slice(credType.data(), credType.size())},
3282 [&](
Env&,
auto const& submit) {
3287 BEAST_EXPECT(env.
le(preauthKeylet));
3288 BEAST_EXPECT(env.
le(preauthKeylet)->getAccountID(sfSponsor) ==
sponsor.id());
3296 BEAST_EXPECT(!env.
le(preauthKeylet));
3311 Account const sponsor2(
"sponsor2");
3328 [&](
Env& env,
auto const& submit) {
3333 BEAST_EXPECT(env.
le(credKeylet)->getAccountID(sfSponsor) ==
sponsor.id());
3345 Sig(sfSponsorSignature, sponsor2));
3361 BEAST_EXPECT(env.
le(credKeylet)->getAccountID(sfSponsor) == sponsor2.
id());
3388 [&](
Env& env,
auto const& submit) {
3394 BEAST_EXPECT(env.
le(credKeylet)->getAccountID(sfSponsor) ==
sponsor.id());
3450 [&](
Env& env,
auto const& submit) {
3460 BEAST_EXPECT(env.
le(credKeylet)->getAccountID(sfSponsor) ==
sponsor.id());
3473 using namespace std::chrono_literals;
3478 Account const sponsor2(
"sponsor2");
3482 auto const baseFee = env.
current()->fees().base;
3497 [&](
Env& env,
auto const& submit) {
3498 seq = env.
seq(alice);
3506 ->getAccountID(sfSponsor) ==
sponsor.id());
3513 tfSponsorshipReassign,
3516 Sig(sfSponsorSignature, sponsor2));
3526 tfSponsorshipReassign,
3539 ->getAccountID(sfSponsor) == sponsor2.
id());
3545 Fee(baseFee * 150));
3562 auto const seq = env.seq(alice);
3584 auto const existing = view.
read(escrowKeylet);
3591 escrowSle->setFieldVL(sfBytecode,
Blob(bytecodeSize, 0x00));
3592 account->setFieldU32(sfOwnerCount, bytecodeWeight);
3597 BEAST_EXPECT(
ownerCount(env, alice) == bytecodeWeight);
3619 BEAST_EXPECT(env.le(escrowKeylet)->getAccountID(sfSponsor) ==
sponsor.id());
3637 BEAST_EXPECT(env.le(escrowKeylet)->getAccountID(sfSponsor) == sponsor2.
id());
3642 BEAST_EXPECT(
ownerCount(env, alice) == bytecodeWeight);
3646 BEAST_EXPECT(!env.le(escrowKeylet)->isFieldPresent(sfSponsor));
3650 auto const usd = gw[
"usd"];
3654 auto const baseFee = env.
current()->fees().base;
3659 env(
fset(gw, asfAllowTrustLineLocking));
3662 env.
trust(usd(1000000), alice);
3664 env(
pay(gw, alice, usd(10000)));
3679 [&](
Env& env,
auto const& submit) {
3680 seq = env.
seq(alice);
3689 ->getAccountID(sfSponsor) ==
sponsor.id());
3700 [&](
Env& env,
auto const& submit) {
3705 Fee(baseFee * 150));
3720 auto const baseFee = env.
current()->fees().base;
3725 env(
fset(gw, asfAllowTrustLineLocking));
3728 env.
trust(usd(1000000), alice);
3730 env(
pay(gw, alice, usd(10000)));
3742 [&](
Env& env,
auto const& submit) {
3743 seq = env.
seq(alice);
3752 ->getAccountID(sfSponsor) ==
sponsor.id());
3807 env(
fset(gw, asfAllowTrustLineLocking));
3810 env.
trust(usd(1000000), alice);
3812 env(
pay(gw, alice, usd(10000)));
3818 auto const cancelAfter = env.
now() + 100s;
3819 auto const seq = env.
seq(alice);
3828 env(
trust(alice, usd(0)));
3834 for (; env.
now() < cancelAfter; env.
close())
3842 bool const aliceLow = alice.
id() < gw.
id();
3851 [&](
Env& env,
auto const& submit) { submit(
escrow::cancel(alice, alice, seq)); },
3855 BEAST_EXPECT(trustSle);
3859 trustSle->getAccountID(aliceLow ? sfLowSponsor : sfHighSponsor) ==
3862 !trustSle->isFieldPresent(aliceLow ? sfHighSponsor : sfLowSponsor));
3875 MPTTester mptGw(env, gw, {.holders = {alice}});
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)));
3884 auto const seq = env.
seq(alice);
3906 [&](
Env& env,
auto const& submit) {
3926 auto const baseFee = env.
current()->fees().base;
3930 MPTTester mptGw(env, gw, {.holders = {alice}});
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)));
3947 [&](
Env& env,
auto const& submit) {
3948 seq = env.
seq(alice);
3957 ->getAccountID(sfSponsor) ==
sponsor.id());
4014 auto const escrowAmount =
XRP(2);
4015 auto const seq = env.
seq(alice);
4054 Account const sponsor2(
"sponsor2");
4063 jv[sfAccount] = alice.
human();
4064 jv[sfTransactionType] = jss::MPTokenIssuanceCreate;
4074 [&](
Env& env,
auto const& submit) {
4086 Sig(sfSponsorSignature, sponsor2));
4101 jv[sfTransactionType] = jss::MPTokenAuthorize;
4102 jv[sfAccount] = bob.
human();
4103 jv[sfMPTokenIssuanceID] =
to_string(mptid);
4120 [&](
Env& env,
auto const& submit) { submit(jv); });
4131 Sig(sfSponsorSignature, sponsor2));
4153 jv[sfTransactionType] = jss::MPTokenAuthorize;
4154 jv[sfAccount] = bob.
human();
4155 jv[sfMPTokenIssuanceID] =
to_string(mptid);
4156 jv[sfFlags] = tfMPTUnauthorize;
4168 jv[sfTransactionType] = jss::MPTokenIssuanceDestroy;
4169 jv[sfAccount] = alice.
human();
4170 jv[sfMPTokenIssuanceID] =
to_string(mptid);
4186 jv[sfAccount] = alice.
human();
4187 jv[sfTransactionType] = jss::MPTokenIssuanceCreate;
4198 jv[sfTransactionType] = jss::MPTokenAuthorize;
4199 jv[sfAccount] = bob.
human();
4200 jv[sfMPTokenIssuanceID] =
to_string(mptid);
4253 Account const sponsor2(
"sponsor2");
4261 auto const pk = alice.
pk();
4262 auto const settleDelay = 10s;
4272 [&](
Env& env,
auto const& submit) {
4278 BEAST_EXPECT(env.
le(
Keylet(ltPAYCHAN, chan))->getAccountID(sfSponsor) ==
sponsor.id());
4285 Sig(sfSponsorSignature, sponsor2));
4302 BEAST_EXPECT(env.
le(
Keylet(ltPAYCHAN, chan))->getAccountID(sfSponsor) == sponsor2.
id());
4304 env.
close(env.
now() + settleDelay);
4328 auto const pk = alice.
pk();
4329 auto const settleDelay = 10s;
4366 Account const sponsor2(
"sponsor2");
4381 [&](
Env& env,
auto const& submit) { submit(
signers(alice, 1, {{bob, 1}})); });
4393 Sig(sfSponsorSignature, sponsor2),
4397 env(
signers(bob, 1, {{alice, 1}}));
4401 Sig(sfSponsorSignature, sponsor2),
4405 Sig(sfSponsorSignature, sponsor2));
4438 testcase(
"Legacy SignerList sponsorship reserve");
4452 env(
signers(alice, 1, {{bob, 1}, {carol, 1}, {dave, 1}}));
4463 if (
auto const sle = env.
le(sponsorKeylet); BEAST_EXPECT(sle))
4464 BEAST_EXPECT(sle->getFieldU32(sfRemainingOwnerCount) == legacyWeight);
4471 signerList->clearFlag(lsfOneOwnerCount);
4472 account->setFieldU32(sfOwnerCount, legacyWeight);
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);
4489 if (
auto const sle = env.
le(sponsorKeylet); BEAST_EXPECT(sle))
4490 BEAST_EXPECT(!sle->isFieldPresent(sfRemainingOwnerCount));
4496 BEAST_EXPECT(!env.
le(signerListKeylet));
4500 if (
auto const sle = env.
le(sponsorKeylet); BEAST_EXPECT(sle))
4501 BEAST_EXPECT(!sle->isFieldPresent(sfRemainingOwnerCount));
4509 testcase(
"Bytecode escrow sponsorship reserve");
4511 using namespace std::chrono_literals;
4513 auto const alice =
Account{
"alice"};
4514 auto const bob =
Account{
"bob"};
4521 auto const seq = env.seq(alice);
4536 if (
auto const sle = env.le(sponsorKeylet); BEAST_EXPECT(sle))
4538 BEAST_EXPECT(sle->getFieldU32(sfRemainingOwnerCount) == bytecodeWeight);
4546 auto const existing = view.
read(escrowKeylet);
4553 escrowSle->setFieldVL(sfBytecode,
Blob(bytecodeSize, 0x00));
4554 account->setFieldU32(sfOwnerCount, bytecodeWeight);
4559 BEAST_EXPECT(
ownerCount(env, alice) == bytecodeWeight);
4569 if (
auto const sle = env.le(sponsorKeylet); BEAST_EXPECT(sle))
4571 BEAST_EXPECT(!sle->isFieldPresent(sfRemainingOwnerCount));
4578 BEAST_EXPECT(
ownerCount(env, alice) == bytecodeWeight);
4581 if (
auto const sle = env.le(escrowKeylet); BEAST_EXPECT(sle))
4583 BEAST_EXPECT(!sle->isFieldPresent(sfSponsor));
4593 testcase(
"Sponsored trust line gets no free-reserve exception");
4596 Account const issuer(
"issuer");
4604 auto const usd = issuer[
"usd"];
4613 env(
trust(alice, usd(100)),
4619 BEAST_EXPECT(!env.
le(lineKeylet));
4626 env(
trust(alice, usd(100)),
4631 BEAST_EXPECT(env.
le(lineKeylet));
4642 testcase(
"Co-signed reserve sponsorship is bounded by Sponsorship budget");
4647 Account const sponsee(
"sponsee");
4693 Account const charlie(
"charlie");
4695 Account const sponsor2(
"sponsor2");
4697 auto const validateSponsoredTrustline =
4700 sle->getAccountID(isIssuerHigh ? sfLowSponsor : sfHighSponsor) ==
sponsor.id());
4701 BEAST_EXPECT(!sle->isFieldPresent(isIssuerHigh ? sfHighSponsor : sfLowSponsor));
4704 auto const& highAcc = alice > bob ? alice : bob;
4705 auto const& lowAcc = alice > bob ? bob : alice;
4708 for (
bool const isIssuerHigh : {
false,
true})
4714 auto const& issuer = isIssuerHigh ? highAcc : lowAcc;
4715 auto const& user = isIssuerHigh ? lowAcc : highAcc;
4717 auto const usd = issuer[
"usd"];
4718 auto const currency = usd.currency;
4736 [&](
Env& env,
auto const& submit) { submit(
trust(user, usd(100))); });
4745 Sig(sfSponsorSignature, sponsor2),
4750 Sig(sfSponsorSignature, sponsor2),
4754 Sig(sfSponsorSignature, sponsor2));
4767 env(
trust(user, usd(0)));
4778 for (
bool const isIssuerHigh : {
false,
true})
4784 auto const& issuer = isIssuerHigh ? highAcc : lowAcc;
4785 auto const& user = isIssuerHigh ? lowAcc : highAcc;
4787 auto const usd = issuer[
"usd"];
4788 auto const currency = usd.currency;
4791 env(
trust(issuer, user[
"usd"](100)));
4811 [&](
Env& env,
auto const& submit) { submit(
trust(user, usd(100))); });
4814 validateSponsoredTrustline(line, isIssuerHigh,
sponsor);
4817 env(
trust(user, usd(0)));
4826 env(
trust(issuer, user[
"usd"](0)));
4838 env(
trust(alice, bob[
"usd"](100)),
4842 env(
trust(bob, alice[
"usd"](100)),
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());
4861 env(
trust(alice, bob[
"usd"](0)));
4863 env(
trust(bob, alice[
"usd"](0)));
4900 auto const sponsorObj = env.
le(
keylet);
4901 BEAST_EXPECT(sponsorObj);
4904 auto const requiredFee =
drops(env.
current()->fees().increment);
4923 auto const requiredFee =
drops(env.
current()->fees().increment);
4928 BEAST_EXPECT(aliceSle);
4930 BEAST_EXPECT(aliceSle->getAccountID(sfSponsor) ==
sponsor.id());
4933 BEAST_EXPECT(sponsorSle->getFieldU32(sfSponsoringAccountCount) == 1);
4941 BEAST_EXPECT(!sponsorSle2->isFieldPresent(sfSponsoringAccountCount));
4951 auto const usd = gw[
"usd"];
4954 env(
trust(alice, usd(1000)));
4959 BEAST_EXPECT(env.
le(trustId));
4968 BEAST_EXPECT(sponsorSle->isFieldPresent(sfSponsoringOwnerCount));
4975 auto const requiredFee =
drops(env.
current()->fees().increment);
4979 BEAST_EXPECT(sponsorSleAfter->isFieldPresent(sfSponsoringOwnerCount));
4997 BEAST_EXPECT(sponsorSle->isFieldPresent(sfSponsoringAccountCount));
5004 auto const requiredFee =
drops(env.
current()->fees().increment);
5008 BEAST_EXPECT(sponsorSleAfter->isFieldPresent(sfSponsoringAccountCount));
5027 BEAST_EXPECT(sponsorSle->at(sfSponsoringOwnerCount) == 1);
5028 BEAST_EXPECT(aliceSle->at(sfOwnerCount) == 1);
5029 BEAST_EXPECT(aliceSle->at(sfSponsoredOwnerCount) == 1);
5036 auto const requiredFee =
drops(env.
current()->fees().increment);
5040 BEAST_EXPECT(sponsorSle->at(sfSponsoringOwnerCount) == 0);
5059 env.
fund(
XRP(1000000), alice, bob, carol);
5062 auto const seq = env.
seq(alice);
5070 Sig(sfSponsorSignature, bob),
5081 env.
fund(
XRP(1000000), alice, bob, carol);
5103 testcase(
"Delegate Block Reserve Sponsor");
5146 testcase(
"Delegate Sponsor Fee Payer");
5162 auto const aliceBalance = env.
balance(alice);
5163 auto const bobBalance = env.
balance(bob);
5164 auto const carolBalance = env.
balance(carol);
5166 auto const sendAmt =
XRP(100);
5167 auto const feeAmt =
XRP(10);
5169 env(
pay(alice, carol, sendAmt),
5176 BEAST_EXPECT(env.
balance(alice) == aliceBalance - sendAmt);
5177 BEAST_EXPECT(env.
balance(bob) == bobBalance);
5178 BEAST_EXPECT(env.
balance(carol) == carolBalance + sendAmt);
5194 auto const aliceBalance = env.
balance(alice);
5195 auto const bobBalance = env.
balance(bob);
5196 auto const carolBalance = env.
balance(carol);
5199 auto const sendAmt =
XRP(100);
5200 auto const feeAmt =
XRP(10);
5206 env(
pay(alice, carol, sendAmt),
5212 BEAST_EXPECT(env.
balance(alice) == aliceBalance - sendAmt);
5213 BEAST_EXPECT(env.
balance(bob) == bobBalance);
5214 BEAST_EXPECT(env.
balance(carol) == carolBalance + sendAmt);
5239 auto const seq = env.
seq(alice);
5254 BEAST_EXPECT(env.
balance(alice) ==
XRP(1000));
5265 auto const seq = env.
seq(alice);
5278 env.
fund(
XRP(1000), alice, bob);
5288 auto const seq = env.
seq(alice);
5302 BEAST_EXPECT(env.
balance(alice) ==
XRP(1000));
5306 BEAST_EXPECT(sponsorshipSle);
5307 BEAST_EXPECT(sponsorshipSle->at(sfFeeAmount) ==
XRP(100 - 1));
5308 BEAST_EXPECT(sponsorshipSle->at(sfRemainingOwnerCount) == 100);
5315 Account const signerAccount(
"signer");
5330 auto const seq = env.
seq(alice);
5333 BEAST_EXPECT(jt.jv[sfSponsorSignature.jsonName].isMember(sfTxnSignature.jsonName));
5344 Msig(sfSponsorSignature,
sponsor, signerAccount));
5347 auto const seq = env.
seq(alice);
5350 BEAST_EXPECT(jt.jv[sfSponsorSignature.jsonName].isMember(sfSigners.jsonName));
5363 jt.jv[sfSponsorSignature.jsonName].
removeMember(sfTxnSignature.jsonName);
5364 jt.jv[sfSponsorSignature.jsonName][sfSigningPubKey.jsonName] =
"";
5366 auto const seq = env.
seq(alice);
5378 env.
fund(
XRP(1000), alice, bob);
5394 auto const seq = env.
seq(alice);
5407 BEAST_EXPECT(env.
balance(alice) ==
XRP(999));
5412 BEAST_EXPECT(sponsorshipSle);
5413 BEAST_EXPECT(sponsorshipSle->at(sfFeeAmount) ==
XRP(100));
5414 BEAST_EXPECT(sponsorshipSle->at(sfRemainingOwnerCount) == 99);
5429 jt.jv[sfSponsorSignature.jsonName].
removeMember(sfTxnSignature.jsonName);
5430 jt.jv[sfSponsorSignature.jsonName][sfSigningPubKey.jsonName] =
"";
5432 auto const seq = env.
seq(alice);
5446 BEAST_EXPECT(env.
balance(alice) ==
XRP(999));
5460 auto const seq = env.
seq(alice);
5464 auto innerPay =
pay(alice, bob,
XRP(1));
5465 innerPay[sfSponsor.jsonName] =
sponsor.human();
5469 env(
batch::outer(alice, seq, batchFee, tfAllOrNothing),
5482 auto const seq = env.
seq(alice);
5485 auto innerPay =
pay(alice, bob,
XRP(1));
5486 innerPay[sfSponsor.jsonName] =
sponsor.human();
5490 env(
batch::outer(alice, seq, batchFee, tfAllOrNothing),
5504 auto const seq = env.
seq(alice);
5508 innerTx[sfSponsor.jsonName] =
sponsor.human();
5509 innerTx[sfSponsorFlags.jsonName] =
5513 env(
batch::outer(alice, seq, batchFee, tfAllOrNothing),
5526 auto const seq = env.
seq(bob);
5548 testcase(
"Reserve sponsor allow-list gate");
5561 auto const checkBlocked = [&](
json::Value const& jv) {
5569 checkBlocked(
offer(alice,
XRP(100), bob[
"USD"](100)));
5597 testcase(
"Sponsored Payment: minimal-balance account with sponsor-pays-fee");
5599 using namespace jtx;
5605 auto const baseFee = env.
current()->fees().base;
5606 auto const baseReserve = env.
current()->fees().reserve;
5610 env.
fund(baseReserve +
XRP(1), alice);
5614 BEAST_EXPECT(env.
balance(alice) == baseReserve +
XRP(1));
5618 auto const preDest = env.
balance(dest);
5622 env(
pay(alice, dest,
XRP(1)),
5630 BEAST_EXPECT(env.
balance(alice) == baseReserve);
5633 BEAST_EXPECT(env.
balance(dest) == preDest +
XRP(1));
5651 testcase(
"TrustSet modify with sponsor does not misroute onto counterparty side");
5656 Account const alice{
"alice_t2178"};
5657 Account const bob{
"bob_t2178"};
5658 Account const carol{
"carol_t2178"};
5661 env.
fund(
XRP(100'000), alice, bob, carol);
5665 bool const aliceIsHigh = alice.
id() > bob.
id();
5673 auto const issuer = aliceIsHigh ? bob : alice;
5674 auto const holder = aliceIsHigh ? alice : bob;
5675 auto const usd = issuer[
"USD"];
5679 env(
fclear(issuer, asfDefaultRipple));
5685 env(
trust(holder, usd(1'000)));
5691 env(
fset(issuer, asfDefaultRipple));
5694 SF_ACCOUNT const& issuerSponsorField = aliceIsHigh ? sfLowSponsor : sfHighSponsor;
5695 SF_ACCOUNT const& holderSponsorField = aliceIsHigh ? sfHighSponsor : sfLowSponsor;
5698 auto const sleLineBefore = env.
le(lineKey);
5699 if (!BEAST_EXPECT(sleLineBefore))
5701 BEAST_EXPECT(!sleLineBefore->isFieldPresent(sfLowSponsor));
5702 BEAST_EXPECT(!sleLineBefore->isFieldPresent(sfHighSponsor));
5705 BEAST_EXPECT(carolBefore == 0);
5707 BEAST_EXPECT(issuerSponsoredBefore == 0);
5712 env(
trust(holder, usd(2'000)),
5714 Sig(sfSponsorSignature, carol),
5718 auto const sleLineAfter = env.
le(lineKey);
5719 if (!BEAST_EXPECT(sleLineAfter))
5723 BEAST_EXPECT(!sleLineAfter->isFieldPresent(issuerSponsorField));
5727 BEAST_EXPECT(!sleLineAfter->isFieldPresent(holderSponsorField));
5731 BEAST_EXPECT(carolAfter == carolBefore);
5735 BEAST_EXPECT(issuerSponsoredAfter == issuerSponsoredBefore);
5741 testcase(
"Self-escrow finish reserve order gated by amendment");
5743 using namespace std::chrono_literals;
5754 auto const usd = gw[
"usd"];
5756 Env env{*
this, features};
5757 auto const baseFee = env.
current()->fees().base;
5759 env.
fund(
XRP(10000), alice, gw);
5762 env(
fset(gw, asfAllowTrustLineLocking));
5765 env.
trust(usd(1000), alice);
5767 env(
pay(gw, alice, usd(100)));
5772 auto const seq = env.
seq(alice);
5781 env(
trust(alice, usd(0)));
5791 BEAST_EXPECT(env.
balance(alice) == target);
5804 BEAST_EXPECT(env.
balance(alice, usd) == usd(100));
5832 testcase(
"Fee-sponsored VaultDeposit/VaultWithdraw pass ValidVault invariant");
5842 Vault const vault{env};
5843 auto [vaultTx, vaultKeylet] = vault.create({.owner = alice, .asset = xrpAsset});
5848 env(vault.deposit({.depositor = alice, .id = vaultKeylet.key, .amount = xrpAsset(100)}),
5853 env(vault.deposit({.depositor = alice, .id = vaultKeylet.key, .amount = xrpAsset(100)}),
5863 env(vault.withdraw({.depositor = alice, .id = vaultKeylet.key, .amount = xrpAsset(50)}),
5876 testcase(
"Sponsored object deletion refunds sponsor owner count");
5890 Account const checkOwner(
"check_owner");
5891 Account const dest(
"check_dest");
5892 env.
fund(
XRP(100000), checkOwner, dest);
5897 auto const checkSeq = env.
seq(checkOwner);
5904 BEAST_EXPECT(sponsorCountBefore == 1);
5912 BEAST_EXPECT(sponsorCountAfter == 0);
5918 testcase(
" — TrustLine deletion");
5920 Account const issuer(
"issuer");
5921 Account const holder(
"holder");
5922 env.
fund(
XRP(100000), issuer, holder);
5925 auto const usd = issuer[
"USD"];
5928 env(
trust(holder, usd(1000)),
5934 BEAST_EXPECT(sponsorCountBefore == 1);
5937 env(
trust(holder, usd(0)));
5941 BEAST_EXPECT(sponsorCountAfter == 0);
A generic endpoint for log messages.
TestcaseT testcase
Memberspace for declaring test cases.
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.
bool modify(ModifyType const &f)
Modify the open ledger.
Writable ledger view that accumulates state and tx changes.
void rawReplace(SLE::Ref sle) override
Unconditionally replace a state item.
SLE::const_pointer read(Keylet const &k) const override
Return the state item associated with a key.
Rules const & rules() const override
Returns the tx processing rules.
Slice slice() const noexcept
static constexpr SeqProxy rawSequence(std::uint32_t v)
Factory function to return a sequence-based SeqProxy.
static constexpr SeqProxy rawTicket(std::uint32_t v)
Factory function to return a ticket-based SeqProxy.
virtual OpenLedger & getOpenLedger()=0
Immutable cryptographic account descriptor.
std::string const & human() const
Returns the human readable public key.
PublicKey const & pk() const
Return the public key.
AccountID id() const
Returns the Account ID.
A transaction testing environment.
bool close(NetClock::time_point closeTime, std::optional< std::chrono::milliseconds > consensusDelay=std::nullopt)
Close and advance the ledger.
SLE::const_pointer le(Account const &account) const
Return an account root.
std::shared_ptr< ReadView const > closed()
Returns the last closed ledger.
void fund(bool setDefaultRipple, STAmount const &amount, Account const &account)
std::uint32_t seq(Account const &account) const
Returns the next sequence number on account.
JTx jt(JsonValue &&jv, FN const &... fN)
Create a JTx from parameters.
PrettyAmount balance(Account const &account) const
Returns the XRP balance on an account.
void trust(STAmount const &amount, Account const &account)
Establish trust lines.
JTx jtnofill(JsonValue &&jv, FN const &... fN)
Create a JTx from parameters.
void memoize(Account const &account)
Associate AccountID with account.
beast::Journal const journal
std::shared_ptr< OpenView const > current() const
Returns the current ledger.
NetClock::time_point now()
Returns the current network time.
Test helper for creating, mutating, and asserting MPT and confidential MPT ledger state.
static json::Value authorizeJV(MPTAuthorize const &arg=MPTAuthorize{})
void create(MPTCreate const &arg=MPTCreate{}, std::source_location const &loc=std::source_location::current())
Set a multisignature on a JTx.
Sets the SendMax on a JTx.
Set the regular signature on a JTx.
Set the expected result code for a JTx The test will fail if the code doesn't match.
Adds an inner Batch transaction to a JTx and autofills it.
Sets the Batch transaction signers on a JTx.
Set a ticket sequence on a JTx.
Keylet computation functions.
Keylet const & skip() noexcept
The index of the "short" skip list.
Keylet escrow(AccountID const &src, SeqProxy const &seq) noexcept
An escrow entry.
Keylet did(AccountID const &account) noexcept
Keylet depositPreauth(AccountID const &owner, AccountID const &preauthorized) noexcept
A DepositPreauth.
Keylet const & feeSettings() noexcept
The (fixed) index of the object containing the ledger fees.
Keylet signerList(AccountID const &account) noexcept
A SignerList.
Keylet ownerDir(AccountID const &id) noexcept
The root page of an account's directory.
Keylet check(AccountID const &id, SeqProxy const &seq) noexcept
A Check.
Keylet unchecked(UInt256 const &key) noexcept
Any ledger entry.
Keylet ticket(AccountID const &id, SeqProxy const &ticketSeq)
A ticket belonging to an account.
Keylet nftokenPageMax(AccountID const &owner)
A keylet for the owner's last possible NFT page.
Keylet mptoken(MPTID const &issuanceID, AccountID const &holder) noexcept
Keylet delegate(AccountID const &account, AccountID const &authorizedAccount) noexcept
A keylet for Delegate object.
Keylet loanBroker(AccountID const &owner, SeqProxy const &seq) noexcept
Keylet account(AccountID const &id) noexcept
AccountID root.
Keylet sponsorship(AccountID const &sponsor, AccountID const &sponsee) noexcept
A Sponsorship.
Keylet loan(UInt256 const &loanBrokerID, SeqProxy const &loanSeq) noexcept
Keylet mptokenIssuance(MPTID const &issuanceID) noexcept
Keylet trustLine(AccountID const &id0, AccountID const &id1, Currency const ¤cy) noexcept
The index of a trust line for a given currency.
json::Value outer(jtx::Account const &account, uint32_t seq, STAmount const &fee, std::uint32_t flags)
Build an outer Batch transaction JSON object.
XRPAmount calcBatchFee(jtx::Env const &env, uint32_t const &numSigners, uint32_t const &txns=0)
Calculate the expected outer Batch transaction fee.
json::Value cancel(jtx::Account const &dest, UInt256 const &checkId)
Cancel a check.
json::Value cash(jtx::Account const &dest, UInt256 const &checkId, STAmount const &amount)
Cash a check requiring that a specific amount be delivered.
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)
json::Value accept(jtx::Account const &subject, jtx::Account const &issuer, std::string_view credType)
json::Value create(jtx::Account const &subject, jtx::Account const &issuer, std::string_view credType)
Keylet keylet(test::jtx::Account const &subject, test::jtx::Account const &issuer, std::string_view credType)
json::Value set(jtx::Account const &account, jtx::Account const &authorize, std::vector< std::string > const &permissions)
json::Value unauthCredentials(jtx::Account const &account, std::vector< AuthorizeCredentials > const &auth)
json::Value authCredentials(jtx::Account const &account, std::vector< AuthorizeCredentials > const &auth)
json::Value auth(Account const &account, Account const &auth)
Preauthorize for deposit.
json::Value unauth(Account const &account, Account const &unauth)
Remove pre-authorization for deposit.
json::Value setValid(jtx::Account const &account)
json::Value create(AccountID const &account, AccountID const &to, STAmount const &amount)
json::Value cancel(AccountID const &account, Account const &from, std::uint32_t seq)
auto const kCancelTime
Set the "CancelAfter" time tag on a JTx.
json::Value finish(AccountID const &account, AccountID const &from, std::uint32_t seq)
std::array< std::uint8_t, 4 > const kFb1
std::array< std::uint8_t, 39 > const kCb1
json::Value nftPageLinks(jtx::Account const &acct, jtx::Account const &owner)
Repair the links in an NFToken directory.
auto const kManagementFeeRate
json::Value set(AccountID const &account, UInt256 const &vaultId, uint32_t flags)
auto const kCoverRateMinimum
auto const kCoverRateLiquidation
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)
uint256 channel(AccountID const &account, AccountID const &dst, std::uint32_t seqProxyValue)
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)
STAmount channelAmount(ReadView const &view, uint256 const &chan)
bool channelExists(ReadView const &view, uint256 const &chan)
json::Value create(Account const &account, std::uint32_t count)
Create one of more tickets.
json::Value mint(jtx::Account const &account, std::uint32_t nfTokenTaxon)
Mint an NFToken.
json::Value pay(AccountID const &account, AccountID const &to, AnyAmount amount)
Create a payment.
json::Value regkey(Account const &account, DisabledT)
Disable the regular key.
XrpT const XRP
Converts to XRP Issue or STAmount.
json::Value noop(Account const &account)
The null transaction.
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.
std::uint32_t sponsoringOwnerCount(Env const &env, Account const &account)
FeatureBitset testableAmendments()
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.
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.
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)
json::Value fset(Account const &account, std::uint32_t on, std::uint32_t off=0)
Add and/or remove flag.
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.
constexpr FlagValue spfSponsorFee
@ terNO_DELEGATE_PERMISSION
Issue const & xrpIssue()
Returns an asset specifier that represents XRP.
constexpr FlagValue tfInnerBatchTxn
PreflightResult preflight(ServiceRegistry ®istry, Rules const &rules, STTx const &tx, ApplyFlags flags, beast::Journal j)
Gate a transaction based on static information.
bool isXRP(AccountID const &c)
PreclaimResult preclaim(PreflightResult const &preflightResult, ServiceRegistry ®istry, OpenView const &view)
Gate a transaction based on static ledger information.
ApplyResult apply(ServiceRegistry ®istry, OpenView &view, STTx const &tx, ApplyFlags flags, beast::Journal journal)
Apply a transaction to an OpenView.
std::string strHex(FwdIt begin, FwdIt end)
TenthBips< std::uint32_t > TenthBips32
TenthBips< std::uint16_t > TenthBips16
std::string to_string(BaseUInt< Bits, Tag > const &a)
BaseUInt< 192 > MPTID
MPTID is a 192-bit value representing MPT Issuance ID, which is a concatenation of a 32-bit sequence ...
MPTID makeMptID(std::uint32_t const sequence, AccountID const &account)
bool isTesSuccess(TER x) noexcept
TERSubset< CanCvtToTER > TER
@ tecNO_LINE_INSUF_RESERVE
@ tecNO_SPONSOR_PERMISSION
@ tecINSUFFICIENT_RESERVE
std::vector< unsigned char > Blob
Storage for linear binary data.
TypedField< STAccount > SF_ACCOUNT
ApplyResult doApply(PreclaimResult const &preclaimResult, ServiceRegistry ®istry, OpenView &view)
Apply a prechecked transaction to an OpenView.
constexpr FlagValue spfSponsorReserve
A pair of SHAMap key and LedgerEntryType.
Set the sequence number on a JTx.
A signer in a SignerList.