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/envconfig.h>
8#include <test/jtx/fee.h>
9#include <test/jtx/flags.h>
10#include <test/jtx/multisign.h>
11#include <test/jtx/noop.h>
12#include <test/jtx/pay.h>
13#include <test/jtx/proposal.h>
14#include <test/jtx/regkey.h>
15#include <test/jtx/sig.h>
16#include <test/jtx/sponsor.h>
17#include <test/jtx/ter.h>
18#include <test/jtx/ticket.h>
20#include <xrpld/app/misc/TxQ.h>
21#include <xrpld/core/Config.h>
23#include <xrpl/basics/Blob.h>
24#include <xrpl/basics/Slice.h>
25#include <xrpl/basics/base_uint.h>
26#include <xrpl/beast/unit_test/suite.h>
27#include <xrpl/beast/utility/Journal.h>
28#include <xrpl/config/Constants.h>
29#include <xrpl/json/json_value.h>
30#include <xrpl/json/to_string.h>
31#include <xrpl/ledger/ApplyView.h>
32#include <xrpl/ledger/OpenView.h>
33#include <xrpl/ledger/helpers/ProposalHelpers.h>
34#include <xrpl/protocol/Feature.h>
35#include <xrpl/protocol/Indexes.h>
36#include <xrpl/protocol/SField.h>
37#include <xrpl/protocol/STObject.h>
38#include <xrpl/protocol/STTx.h>
39#include <xrpl/protocol/SeqProxy.h>
40#include <xrpl/protocol/Serializer.h>
41#include <xrpl/protocol/TER.h>
42#include <xrpl/protocol/TxFlags.h>
43#include <xrpl/protocol/jss.h>
44#include <xrpl/tx/apply.h>
67 using namespace std::chrono_literals;
69 Account const target = env.
lookup(payload[jss::Account].asString());
99 testcase(
"unrelated spend of a reserved ticket is blocked");
102 using namespace std::chrono_literals;
104 Env env{*
this, features};
107 Account const target{
"target"};
109 env.
fund(
XRP(10000), alice, target, bob);
128 env(
pay(target, bob,
XRP(1)),
156 testcase(
"matching payload consumes the ticket and cleans up");
159 using namespace std::chrono_literals;
161 Env env{*
this, features};
164 Account const target{
"target"};
167 env.
fund(
XRP(10000), alice, target, bob, carol);
178 auto const bobBefore = env.
balance(bob);
182 BEAST_EXPECT(env.
balance(bob) == bobBefore +
XRP(1));
194 env(
signers(target, 2, {{alice, 1}, {bob, 1}, {carol, 1}}));
198 auto const msigFee = env.
current()->fees().base * 3;
203 auto const bobBefore = env.
balance(bob);
207 BEAST_EXPECT(env.
balance(bob) == bobBefore +
XRP(1));
222 testcase(
"cancelling the proposal frees the ticket");
225 using namespace std::chrono_literals;
227 Env env{*
this, features};
230 Account const target{
"target"};
232 env.
fund(
XRP(10000), alice, target, bob);
275 testcase(
"matching payload failing with tec still cleans up");
278 using namespace std::chrono_literals;
280 Env env{*
this, features};
283 Account const target{
"target"};
285 env.
fund(
XRP(10000), alice, target, bob);
311 testcase(
"other account's same-numbered ticket is unaffected");
314 using namespace std::chrono_literals;
316 Env env{*
this, features};
319 Account const target{
"target"};
321 env.
fund(
XRP(10000), alice, target, bob);
331 BEAST_EXPECT(targetTicketSeq == bobTicketSeq);
351 testcase(
"proposer is the target account");
354 using namespace std::chrono_literals;
356 Env env{*
this, features};
360 env.
fund(
XRP(10000), alice, bob);
368 BEAST_EXPECT(sle && sle->getAccountID(sfOwner) == alice.
id());
389 testcase(
"proposed Batch: only the identical Batch spends the ticket");
392 using namespace std::chrono_literals;
394 Env env{*
this, features};
397 Account const target{
"target"};
399 env.
fund(
XRP(10000), alice, target, bob);
407 auto const innerSeq = env.
seq(target);
431 auto const bobBefore = env.
balance(bob);
435 BEAST_EXPECT(env.
balance(bob) == bobBefore +
XRP(2));
449 testcase(
"inner batch transaction cannot spend a reserved ticket");
452 using namespace std::chrono_literals;
454 Env env{*
this, features};
457 Account const target{
"target"};
459 env.
fund(
XRP(10000), alice, target, bob);
471 auto const bobBefore = env.
balance(bob);
472 auto const seq = env.
seq(target);
478 BEAST_EXPECT(env.
balance(bob) == bobBefore);
498 testcase(
"proposed multi-account Batch completes with BatchSigners");
501 using namespace std::chrono_literals;
503 Env env{*
this, features};
506 Account const target{
"target"};
509 env.
fund(
XRP(10000), alice, target, bob, carol);
531 sle && !sle->getFieldObject(sfProposedTransaction).isFieldPresent(sfBatchSigners));
542 auto const bobBefore = env.
balance(bob);
543 auto const carolBefore = env.
balance(carol);
549 BEAST_EXPECT(env.
balance(carol) == carolBefore +
XRP(2));
550 BEAST_EXPECT(env.
balance(bob) == bobBefore +
XRP(1) -
XRP(2));
564 testcase(
"proposed LoanSet completes with a CounterpartySignature");
567 using namespace std::chrono_literals;
569 Env env{*
this, features};
572 Account const target{
"target"};
573 Account const lender{
"lender"};
574 env.
fund(
XRP(10000), alice, target, lender);
581 tx[sfCounterparty.getJsonName()] = lender.
human();
605 testcase(
"proposed payload completes with a SponsorSignature");
608 using namespace std::chrono_literals;
610 Env env{*
this, features};
613 Account const target{
"target"};
615 Account const backer{
"backer"};
616 env.
fund(
XRP(10000), alice, target, bob, backer);
623 tx[sfSponsor.getJsonName()] = backer.
human();
630 sle && !sle->getFieldObject(sfProposedTransaction).isFieldPresent(sfSponsorSignature));
632 auto const fee = env.
current()->fees().base;
633 auto const bobBefore = env.
balance(bob);
634 auto const targetBefore = env.
balance(target);
635 auto const backerBefore = env.
balance(backer);
637 env(payload,
Sig(sfSponsorSignature, backer));
642 BEAST_EXPECT(env.
balance(bob) == bobBefore +
XRP(1));
643 BEAST_EXPECT(env.
balance(target) == targetBefore -
XRP(1));
644 BEAST_EXPECT(env.
balance(backer) == backerBefore - fee);
658 testcase(
"a terminal proposal still reserves its ticket");
661 using namespace std::chrono_literals;
665 Env env{*
this, features};
668 Account const target{
"target"};
670 env.
fund(
XRP(10000), alice, target, bob);
680 payload[sfLastLedgerSequence.getJsonName()] = env.
current()->seq() + 1000;
701 Env env{*
this, features};
704 Account const target{
"target"};
706 env.
fund(
XRP(10000), alice, target, bob);
719 auto const bobBefore = env.
balance(bob);
723 BEAST_EXPECT(env.
balance(bob) == bobBefore +
XRP(1));
737 testcase(
"auto-deleting a sponsored proposal releases its sponsor");
740 using namespace std::chrono_literals;
742 Env env{*
this, features};
745 Account const target{
"target"};
747 Account const backer{
"backer"};
748 env.
fund(
XRP(10000), alice, target, bob, backer);
758 Sig(sfSponsorSignature, backer),
783 testcase(
"deleting the target account deletes the proposal");
786 using namespace std::chrono_literals;
788 Env env{*
this, features};
791 Account const target{
"target"};
793 env.
fund(
XRP(10000), alice, target, bob);
819 testcase(
"target deletion refunds each proposal's own owner");
822 using namespace std::chrono_literals;
824 Env env{*
this, features};
828 Account const target{
"target"};
830 env.
fund(
XRP(10000), alice, bob, target, dest);
836 env(
signers(target, 1, {{alice, 1}, {bob, 1}}));
876 testcase(
"proposal blocks its owner's account deletion");
879 using namespace std::chrono_literals;
881 Env env{*
this, features};
884 Account const target{
"target"};
886 env.
fund(
XRP(10000), alice, target, bob);
905 params[jss::account] = alice.
human();
906 params[jss::deletion_blockers_only] =
true;
907 auto const jrr = env.
rpc(
"json",
"account_objects",
to_string(params))[jss::result];
908 BEAST_EXPECT(jrr[jss::account_objects].size() == 1);
910 jrr[jss::account_objects][0u][sfLedgerEntryType.getJsonName()] ==
911 jss::TransactionProposal);
925 testcase(
"target's SignerList changes under a stored proposal");
928 using namespace std::chrono_literals;
932 Env env{*
this, features};
935 Account const target{
"target"};
938 env.
fund(
XRP(10000), alice, target, bob, carol);
941 env(
signers(target, 2, {{alice, 1}, {bob, 1}, {carol, 1}}));
945 auto const msigFee = env.
current()->fees().base * 3;
952 env(
signers(target, 2, {{alice, 1}, {bob, 1}}));
965 env(payload,
Msig(alice, bob));
978 Env env{*
this, features};
981 Account const target{
"target"};
984 env.
fund(
XRP(10000), alice, target, bob, carol);
987 env(
signers(target, 1, {{alice, 1}, {bob, 1}, {carol, 1}}));
991 auto const msigFee = env.
current()->fees().base * 2;
997 env(
signers(target, 3, {{alice, 1}, {bob, 1}, {carol, 1}}));
1022 auto const bobBefore = env.
balance(bob);
1023 env(payload,
Sig(target));
1026 BEAST_EXPECT(env.
balance(bob) == bobBefore +
XRP(1));
1040 testcase(
"deferred signature-presence checks fire at submission");
1042 using namespace jtx;
1043 using namespace std::chrono_literals;
1049 Env env{*
this, features};
1052 Account const target{
"target"};
1053 Account const lender{
"lender"};
1054 env.
fund(
XRP(10000), alice, target, lender);
1061 tx[sfCounterparty.getJsonName()] = lender.
human();
1077 Env env{*
this, features};
1080 Account const target{
"target"};
1081 Account const backer{
"backer"};
1082 env.
fund(
XRP(10000), alice, target, backer);
1089 tx[sfSponsor.getJsonName()] = backer.
human();
1106 Env env{*
this, features};
1109 Account const target{
"target"};
1110 Account const backer{
"backer"};
1111 env.
fund(
XRP(10000), alice, target, backer);
1118 tx[sfSponsor.getJsonName()] = backer.
human();
1141 testcase(
"a tem submission consumes neither ticket nor proposal");
1143 using namespace jtx;
1144 using namespace std::chrono_literals;
1146 Env env{*
this, features};
1149 Account const target{
"target"};
1152 env.
fund(
XRP(10000), alice, target, bob, carol);
1169 if (!BEAST_EXPECT(sle))
1173 auto const jt = env.
jt(payload);
1174 if (!BEAST_EXPECT(jt.stx))
1179 auto const targetBefore = env.
balance(target);
1180 auto const bobBefore = env.
balance(bob);
1181 auto const carolBefore = env.
balance(carol);
1188 BEAST_EXPECT(env.
balance(target) == targetBefore);
1189 BEAST_EXPECT(env.
balance(bob) == bobBefore);
1190 BEAST_EXPECT(env.
balance(carol) == carolBefore);
1204 BEAST_EXPECT(env.
balance(bob) == bobBefore +
XRP(1) -
XRP(2));
1205 BEAST_EXPECT(env.
balance(carol) == carolBefore +
XRP(2));
1219 testcase(
"malformed BatchSigners rejected at submission");
1221 using namespace jtx;
1222 using namespace std::chrono_literals;
1224 Env env{*
this, features};
1227 Account const target{
"target"};
1230 env.
fund(
XRP(10000), alice, target, bob, carol);
1250 auto const stillTicketReservedForProposal = [&] {
1262 BEAST_EXPECT(target.
id() < alice.
id() && alice.
id() < carol.
id() && carol.
id() < bob.
id());
1267 stillTicketReservedForProposal();
1274 stillTicketReservedForProposal();
1282 auto const first = jt.
jv[sfBatchSigners.jsonName][0u];
1283 auto const second = jt.jv[sfBatchSigners.jsonName][1u];
1284 jt.jv[sfBatchSigners.jsonName][0u] = second;
1285 jt.jv[sfBatchSigners.jsonName][1u] = first;
1289 stillTicketReservedForProposal();
1314 testcase(
"payload's LastLedgerSequence passes while the proposal waits");
1316 using namespace jtx;
1317 using namespace std::chrono_literals;
1323 Env env{*
this, features};
1326 Account const target{
"target"};
1328 env.
fund(
XRP(10000), alice, target, bob);
1337 payload[sfLastLedgerSequence.getJsonName()] = lastLedgerSeq;
1340 while (env.
current()->seq() <= lastLedgerSeq)
1356 Env env{*
this, features};
1359 Account const target{
"target"};
1361 env.
fund(
XRP(10000), alice, target, bob);
1370 payload[sfLastLedgerSequence.getJsonName()] = lastLedgerSeq;
1373 while (env.
current()->seq() < lastLedgerSeq)
1376 auto const bobBefore = env.
balance(bob);
1380 BEAST_EXPECT(env.
balance(bob) == bobBefore +
XRP(1));
1394 testcase(
"submission signed by an unauthorized or disabled key");
1396 using namespace jtx;
1397 using namespace std::chrono_literals;
1402 Env env{*
this, features};
1405 Account const target{
"target"};
1407 env.
fund(
XRP(10000), alice, target, bob);
1427 Env env{*
this, features};
1430 Account const target{
"target"};
1432 env.
fund(
XRP(10000), alice, target, bob);
1442 env(
regkey(target, bob));
1443 env(
fset(target, asfDisableMaster),
Sig(target));
1457 auto const bobBefore = env.
balance(bob);
1458 env(payload,
Sig(bob));
1461 BEAST_EXPECT(env.
balance(bob) == bobBefore +
XRP(1));
1476 testcase(
"fee fixed at creation cannot cover the signatures needed");
1478 using namespace jtx;
1479 using namespace std::chrono_literals;
1483 Env env{*
this, features};
1486 Account const target{
"target"};
1489 env.
fund(
XRP(10000), alice, target, bob, carol);
1526 Env env{*
this, features};
1529 Account const target{
"target"};
1530 Account const lender{
"lender"};
1531 env.
fund(
XRP(10000), alice, target, lender);
1538 tx[sfCounterparty.getJsonName()] = lender.
human();
1545 if (!BEAST_EXPECT(sle))
1548 sle->getFieldObject(sfProposedTransaction).getFieldAmount(sfFee).xrp() ==
1575 testcase(
"submission carrying malformed signature content");
1577 using namespace jtx;
1578 using namespace std::chrono_literals;
1582 Env env{*
this, features};
1585 Account const target{
"target"};
1587 env.
fund(
XRP(10000), alice, target, bob);
1596 auto const jt = env.
jt(payload);
1597 if (!BEAST_EXPECT(jt.stx))
1603 auto const stx =
rebuilt(mutated);
1608 BEAST_EXPECT(!result.applied);
1609 return result.applied;
1617 Env env{*
this, features};
1620 Account const target{
"target"};
1622 env.
fund(
XRP(10000), alice, target, bob);
1631 auto const jt = env.
jt(payload);
1632 auto const jtOther = env.
jt(payload,
Sig(bob));
1633 if (!BEAST_EXPECT(jt.stx && jtOther.stx))
1637 Blob const otherSig = jtOther.stx->getFieldVL(sfTxnSignature);
1639 auto const stx =
rebuilt(mutated);
1644 BEAST_EXPECT(!result.applied);
1645 return result.applied;
1658 testcase(
"open-ledger fee escalation only delays the payload");
1660 using namespace jtx;
1661 using namespace std::chrono_literals;
1670 Env env{*
this, std::move(cfg), features};
1673 Account const target{
"target"};
1678 env.fund(
XRP(10000), alice);
1680 env.fund(
XRP(10000), target);
1682 env.fund(
XRP(10000), bob);
1692 auto const baseFee = env.current()->fees().base;
1709 if (!BEAST_EXPECT(sleProposal))
1712 sleProposal->getFieldObject(sfProposedTransaction).getFieldAmount(sfFee).xrp() ==
1715 toDrops(env.app().getTxQ().getMetrics(*env.current()).openLedgerFeeLevel, baseFee) >
1718 auto const bobBefore = env.balance(bob);
1731 toDrops(env.app().getTxQ().getMetrics(*env.current()).openLedgerFeeLevel, baseFee) ==
1734 BEAST_EXPECT(env.balance(bob) == bobBefore +
XRP(1));
1743 using namespace jtx;
A generic endpoint for log messages.
TestcaseT testcase
Memberspace for declaring test cases.
bool modify(ModifyType const &f)
Modify the open ledger.
Writable ledger view that accumulates state and tx changes.
T::value_type at(TypedField< T > const &f) const
Get the value of a field.
void add(Serializer &s) const override
static constexpr SeqProxy rawTicket(std::uint32_t v)
Factory function to return a ticket-based SeqProxy.
Slice slice() const noexcept
virtual OpenLedger & getOpenLedger()=0
Immutable cryptographic account descriptor.
std::string const & human() const
Returns the human readable 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.
Account const & lookup(AccountID const &id) const
Returns the Account given the AccountID.
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.
json::Value rpc(unsigned apiVersion, std::unordered_map< std::string, std::string > const &headers, std::string const &cmd, Args &&... args)
Execute an RPC command.
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.
std::shared_ptr< OpenView const > current() const
Returns the current ledger.
NetClock::time_point now()
Returns the current network time.
Set a multisignature 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 signerList(AccountID const &account) noexcept
A SignerList.
Keylet txProposal(AccountID const &target, std::uint32_t ticketSequence) noexcept
A TransactionProposal.
Keylet ticket(AccountID const &id, SeqProxy const &ticketSeq)
A ticket belonging to an account.
Keylet account(AccountID const &id) noexcept
AccountID root.
bool payloadMatches(STObject const &proposedTx, STObject const &tx)
Whether tx carries the same payload as a proposal's stored ProposedTransaction (On-Chain Cosigner spe...
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 set(AccountID const &account, UInt256 const &loanBrokerID, Number principalRequested, std::uint32_t flags)
Create create()
Check the ledger effects a TransactionProposalCreate must have, whatever its outcome: on tesSUCCESS a...
json::Value innerTx(json::Value tx, std::uint32_t seq)
Put a transaction into the form an inner transaction of a proposed Batch takes, as batch::Inner does ...
std::uint32_t createTicket(Env &env, Account const &account, std::uint32_t count)
Create tickets for a proposal to be built against, and close the ledger.
json::Value unsignedPayload(Env const &env, json::Value tx, std::uint32_t ticketSeq)
Put a transaction of any type into the form a proposal stores it in: unsigned and ticket-based,...
constexpr std::uint32_t kBatchProposalOwnerCount
Owner-reserve increments held by a proposal of a Batch transaction.
constexpr std::uint32_t kProposalOwnerCount
Owner-reserve increments held by a proposal of an ordinary transaction.
SLE::const_pointer entry(Env const &env, AccountID const &target, std::uint32_t ticketSeq)
The proposal stored against a target account's ticket.
json::Value create(Account const &proposer, json::Value const &proposedTx, std::uint32_t expiration)
Build a TransactionProposalCreate carrying an unsigned proposed transaction.
void authorizeProposer(Env &env, Account const &target, Account const &proposer)
Give proposer a place on target's SignerList, so it may create proposals against target.
json::Value unsignedBatch(Env const &env, Account const &target, std::uint32_t ticketSeq, std::uint32_t flags, std::vector< json::Value > const &inners, std::optional< std::uint32_t > numSigners)
An unsigned outer Batch payload holding inners.
std::uint32_t expiration(Env &env, NetClock::duration delta)
An absolute expiration delta past the environment's current time.
json::Value cancel(Account const &account, uint256 const &proposalID)
Build a TransactionProposalCancel naming the proposal to delete.
json::Value create(Account const &account, std::uint32_t count)
Create one of more tickets.
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 ownerCount(Env const &env, Account const &account)
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)
std::uint32_t sponsoredOwnerCount(Env const &env, Account const &account)
std::unique_ptr< Config > envconfig()
creates and initializes a default configuration for jtx::Env
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)
Use hash_* containers for keys that do not need a cryptographically secure hashing algorithm.
constexpr FlagValue spfSponsorFee
ApplyResult apply(ServiceRegistry ®istry, OpenView &view, STTx const &tx, ApplyFlags flags, beast::Journal journal)
Apply a transaction to an OpenView.
XRPAmount toDrops(FeeLevel< T > const &level, XRPAmount baseFee)
std::string to_string(BaseUInt< Bits, Tag > const &a)
Slice makeSlice(std::array< T, N > const &a)
std::vector< unsigned char > Blob
Storage for linear binary data.
constexpr FlagValue spfSponsorReserve
static constexpr auto kMinimumTxnInLedgerStandalone
static constexpr auto kTransactionQueue
void testMatchingPayloadExecutes(FeatureBitset features)
void testCancelFreesTicket(FeatureBitset features)
void testOpenLedgerFeeEscalation(FeatureBitset features)
void testUnrelatedSpendBlocked(FeatureBitset features)
void testFeeFixedAtCreationCannotCoverSignatures(FeatureBitset features)
static std::shared_ptr< STTx const > rebuilt(STObject const &tx)
void testProposerIsTarget(FeatureBitset features)
void testDeferredSignatureChecksFireOnSubmission(FeatureBitset features)
void testTemSubmissionConsumesNothing(FeatureBitset features)
void run() override
Runs the suite.
void testSubmissionSigningAuthority(FeatureBitset features)
static void makeProposal(jtx::Env &env, jtx::Account const &proposer, json::Value const &payload)
void testTargetDeletionRefundsEachOwner(FeatureBitset features)
void testMatchingTecStillCleansUp(FeatureBitset features)
void testSubmissionSignatureContent(FeatureBitset features)
void testMultiAccountBatchCompletes(FeatureBitset features)
void testPayloadLastLedgerSequencePasses(FeatureBitset features)
void testTerminalStillReservesTicket(FeatureBitset features)
void testBatchProposal(FeatureBitset features)
void testProposalBlocksOwnerAccountDelete(FeatureBitset features)
void testCounterpartySignatureMatches(FeatureBitset features)
void testSponsoredReserveAutoDelete(FeatureBitset features)
void testSponsorSignatureMatches(FeatureBitset features)
void testOtherAccountsSameNumberedTicket(FeatureBitset features)
void testSignerListChangedUnderProposal(FeatureBitset features)
void testInnerBatchSpendBlocked(FeatureBitset features)
void testMalformedBatchSignersOnSubmission(FeatureBitset features)
void testTargetAccountDeleted(FeatureBitset features)