AccountTx_test.cpp

#include <test/jtx/Account.h>
#include <test/jtx/Env.h>
#include <test/jtx/TestHelpers.h>
#include <test/jtx/acctdelete.h>
#include <test/jtx/amount.h>
#include <test/jtx/balance.h>  // IWYU pragma: keep
#include <test/jtx/check.h>
#include <test/jtx/delegate.h>
#include <test/jtx/deposit.h>
#include <test/jtx/envconfig.h>
#include <test/jtx/fee.h>
#include <test/jtx/mpt.h>
#include <test/jtx/multisign.h>
#include <test/jtx/noop.h>
#include <test/jtx/offer.h>
#include <test/jtx/pay.h>
#include <test/jtx/regkey.h>
#include <test/jtx/sig.h>
#include <test/jtx/sponsor.h>
#include <test/jtx/ter.h>
#include <test/jtx/ticket.h>
#include <test/jtx/trust.h>
 
#include <xrpld/core/Config.h>
 
#include <xrpl/basics/base_uint.h>
#include <xrpl/basics/chrono.h>
#include <xrpl/basics/strHex.h>
#include <xrpl/beast/unit_test/suite.h>
#include <xrpl/json/json_value.h>
#include <xrpl/json/to_string.h>
#include <xrpl/protocol/AccountID.h>
#include <xrpl/protocol/ApiVersion.h>
#include <xrpl/protocol/ErrorCodes.h>
#include <xrpl/protocol/Indexes.h>
#include <xrpl/protocol/SField.h>
#include <xrpl/protocol/STAmount.h>
#include <xrpl/protocol/SeqProxy.h>
#include <xrpl/protocol/TER.h>
#include <xrpl/protocol/TxFlags.h>
#include <xrpl/protocol/jss.h>
 
#include <boost/container/flat_set.hpp>
 
#include <chrono>
#include <cstddef>
#include <cstdint>
#include <initializer_list>
#include <iterator>
#include <memory>
#include <optional>
#include <string>
#include <utility>
 
namespace xrpl::test {
 
class AccountTx_test : public beast::unit_test::Suite
{
    // A data structure used to describe the basic structure of a
    // transactions array node as returned by the account_tx RPC command.
    struct NodeSanity
    {
        int const index;
        json::StaticString const& txType;
        boost::container::flat_set<std::string> created;
        boost::container::flat_set<std::string> deleted;
        boost::container::flat_set<std::string> modified;
 
        NodeSanity(
            int idx,
            json::StaticString const& t,
            std::initializer_list<char const*> c,
            std::initializer_list<char const*> d,
            std::initializer_list<char const*> m)
            : index(idx), txType(t)
        {
            auto buildSet = [](auto&& init) {
                boost::container::flat_set<std::string> r;
                r.reserve(init.size());
                for (auto&& s : init)
                    r.insert(s);
                return r;
            };
 
            created = buildSet(c);
            deleted = buildSet(d);
            modified = buildSet(m);
        }
    };
 
    // A helper method tests can use to validate returned JSON vs NodeSanity.
    void
    checkSanity(json::Value const& txNode, NodeSanity const& sane)
    {
        BEAST_EXPECT(txNode[jss::validated].asBool() == true);
        BEAST_EXPECT(txNode[jss::tx][sfTransactionType.jsonName].asString() == sane.txType);
 
        // Make sure all of the expected node types are present.
        boost::container::flat_set<std::string> createdNodes;
        boost::container::flat_set<std::string> deletedNodes;
        boost::container::flat_set<std::string> modifiedNodes;
 
        for (json::Value const& metaNode : txNode[jss::meta][sfAffectedNodes.jsonName])
        {
            if (metaNode.isMember(sfCreatedNode.jsonName))
            {
                createdNodes.insert(
                    metaNode[sfCreatedNode.jsonName][sfLedgerEntryType.jsonName].asString());
            }
            else if (metaNode.isMember(sfDeletedNode.jsonName))
            {
                deletedNodes.insert(
                    metaNode[sfDeletedNode.jsonName][sfLedgerEntryType.jsonName].asString());
            }
            else if (metaNode.isMember(sfModifiedNode.jsonName))
            {
                modifiedNodes.insert(
                    metaNode[sfModifiedNode.jsonName][sfLedgerEntryType.jsonName].asString());
            }
            else
            {
                fail("Unexpected or unlabeled node type in metadata.", __FILE__, __LINE__);
            }
        }
 
        BEAST_EXPECT(createdNodes == sane.created);
        BEAST_EXPECT(deletedNodes == sane.deleted);
        BEAST_EXPECT(modifiedNodes == sane.modified);
    };
 
    void
    testParameters(unsigned int apiVersion)
    {
        testcase("Parameters APIv" + std::to_string(apiVersion));
        using namespace test::jtx;
 
        Env env(*this, envconfig([](std::unique_ptr<Config> cfg) {
            cfg->fees.referenceFee = 10;
            return cfg;
        }));
        Account const a1{"A1"};
        env.fund(XRP(10000), a1);
        env.close();
 
        // Ledger 3 has the two txs associated with funding the account
        // All other ledgers have no txs
 
        auto hasTxs = [apiVersion](json::Value const& j) {
            switch (apiVersion)
            {
                case 1:
                    return j.isMember(jss::result) && (j[jss::result][jss::status] == "success") &&
                        (j[jss::result][jss::transactions].size() == 2) &&
                        (j[jss::result][jss::transactions][0u][jss::tx][jss::TransactionType] ==
                         jss::AccountSet) &&
                        (j[jss::result][jss::transactions][1u][jss::tx][jss::TransactionType] ==
                         jss::Payment) &&
                        (j[jss::result][jss::transactions][1u][jss::tx][jss::DeliverMax] ==
                         "10000000010") &&
                        (j[jss::result][jss::transactions][1u][jss::tx][jss::Amount] ==
                         j[jss::result][jss::transactions][1u][jss::tx][jss::DeliverMax]);
                case 2:
                case 3:
                    if (j.isMember(jss::result) && (j[jss::result][jss::status] == "success") &&
                        (j[jss::result][jss::transactions].size() == 2) &&
                        (j[jss::result][jss::transactions][0u][jss::tx_json]
                          [jss::TransactionType] == jss::AccountSet))
                    {
                        auto const& payment = j[jss::result][jss::transactions][1u];
 
                        return (payment.isMember(jss::tx_json)) &&
                            (payment[jss::tx_json][jss::TransactionType] == jss::Payment) &&
                            (payment[jss::tx_json][jss::DeliverMax] == "10000000010") &&
                            (!payment[jss::tx_json].isMember(jss::Amount)) &&
                            (!payment[jss::tx_json].isMember(jss::hash)) &&
                            (payment[jss::hash] ==
                             "9F3085D85F472D1CC29627F260DF68EDE59D42D1D0C33E345"
                             "ECF0D4CE981D0A8") &&
                            (payment[jss::validated] == true) &&
                            (payment[jss::ledger_index] == 3) &&
                            (payment[jss::ledger_hash] ==
                             "5476DCD816EA04CBBA57D47BBF1FC58A5217CC93A5ADD79CB"
                             "580A5AFDD727E33") &&
                            (payment[jss::close_time_iso] == "2000-01-01T00:00:10Z");
                    }
                    else
                    {
                        return false;
                    }
 
                default:
                    return false;
            }
        };
 
        auto noTxs = [](json::Value const& j) {
            return j.isMember(jss::result) && (j[jss::result][jss::status] == "success") &&
                (j[jss::result][jss::transactions].size() == 0);
        };
 
        auto isErr = [](json::Value const& j, ErrorCodeI code) {
            return j.isMember(jss::result) && j[jss::result].isMember(jss::error) &&
                j[jss::result][jss::error] == rpc::getErrorInfo(code).token;
        };
 
        json::Value jParams;
        jParams[jss::api_version] = apiVersion;
 
        BEAST_EXPECT(isErr(env.rpc("json", "account_tx", to_string(jParams)), RpcInvalidParams));
 
        jParams[jss::account] = "0xDEADBEEF";
 
        BEAST_EXPECT(isErr(env.rpc("json", "account_tx", to_string(jParams)), RpcActMalformed));
 
        jParams[jss::account] = a1.human();
        BEAST_EXPECT(hasTxs(env.rpc(apiVersion, "json", "account_tx", to_string(jParams))));
 
        // Ledger min/max index
        {
            json::Value p{jParams};
            p[jss::ledger_index_min] = -1;
            p[jss::ledger_index_max] = -1;
            BEAST_EXPECT(hasTxs(env.rpc(apiVersion, "json", "account_tx", to_string(p))));
 
            p[jss::ledger_index_min] = 0;
            p[jss::ledger_index_max] = 100;
            if (apiVersion < 2u)
            {
                BEAST_EXPECT(hasTxs(env.rpc(apiVersion, "json", "account_tx", to_string(p))));
            }
            else
            {
                BEAST_EXPECT(
                    isErr(env.rpc("json", "account_tx", to_string(p)), RpcLgrIdxMalformed));
            }
 
            p[jss::ledger_index_min] = 1;
            p[jss::ledger_index_max] = 2;
            if (apiVersion < 2u)
            {
                BEAST_EXPECT(noTxs(env.rpc("json", "account_tx", to_string(p))));
            }
            else
            {
                BEAST_EXPECT(
                    isErr(env.rpc("json", "account_tx", to_string(p)), RpcLgrIdxMalformed));
            }
 
            p[jss::ledger_index_min] = 2;
            p[jss::ledger_index_max] = 1;
            BEAST_EXPECT(isErr(
                env.rpc("json", "account_tx", to_string(p)),
                (apiVersion == 1 ? RpcLgrIdxsInvalid : RpcInvalidLgrRange)));
        }
        // Ledger index min only
        {
            json::Value p{jParams};
            p[jss::ledger_index_min] = -1;
            BEAST_EXPECT(hasTxs(env.rpc(apiVersion, "json", "account_tx", to_string(p))));
 
            p[jss::ledger_index_min] = 1;
            if (apiVersion < 2u)
            {
                BEAST_EXPECT(hasTxs(env.rpc(apiVersion, "json", "account_tx", to_string(p))));
            }
            else
            {
                BEAST_EXPECT(
                    isErr(env.rpc("json", "account_tx", to_string(p)), RpcLgrIdxMalformed));
            }
 
            p[jss::ledger_index_min] = env.current()->header().seq;
            BEAST_EXPECT(isErr(
                env.rpc("json", "account_tx", to_string(p)),
                (apiVersion == 1 ? RpcLgrIdxsInvalid : RpcInvalidLgrRange)));
        }
 
        // Ledger index max only
        {
            json::Value p{jParams};
            p[jss::ledger_index_max] = -1;
            BEAST_EXPECT(hasTxs(env.rpc(apiVersion, "json", "account_tx", to_string(p))));
 
            p[jss::ledger_index_max] = env.current()->header().seq;
            if (apiVersion < 2u)
            {
                BEAST_EXPECT(hasTxs(env.rpc(apiVersion, "json", "account_tx", to_string(p))));
            }
            else
            {
                BEAST_EXPECT(
                    isErr(env.rpc("json", "account_tx", to_string(p)), RpcLgrIdxMalformed));
            }
 
            p[jss::ledger_index_max] = 3;
            BEAST_EXPECT(hasTxs(env.rpc(apiVersion, "json", "account_tx", to_string(p))));
 
            p[jss::ledger_index_max] = env.closed()->header().seq;
            BEAST_EXPECT(hasTxs(env.rpc(apiVersion, "json", "account_tx", to_string(p))));
 
            p[jss::ledger_index_max] = env.closed()->header().seq - 1;
            BEAST_EXPECT(noTxs(env.rpc("json", "account_tx", to_string(p))));
        }
 
        // Ledger Sequence
        {
            json::Value p{jParams};
 
            p[jss::ledger_index] = env.closed()->header().seq;
            BEAST_EXPECT(hasTxs(env.rpc(apiVersion, "json", "account_tx", to_string(p))));
 
            p[jss::ledger_index] = env.closed()->header().seq - 1;
            BEAST_EXPECT(noTxs(env.rpc("json", "account_tx", to_string(p))));
 
            p[jss::ledger_index] = env.current()->header().seq;
            BEAST_EXPECT(isErr(env.rpc("json", "account_tx", to_string(p)), RpcLgrNotValidated));
 
            p[jss::ledger_index] = env.current()->header().seq + 1;
            BEAST_EXPECT(isErr(env.rpc("json", "account_tx", to_string(p)), RpcLgrNotFound));
        }
 
        {
            json::Value p{jParams};
 
            p[jss::ledger_index] = "validated";
            BEAST_EXPECT(hasTxs(env.rpc(apiVersion, "json", "account_tx", to_string(p))));
 
            p[jss::ledger_index] = "closed";
            BEAST_EXPECT(hasTxs(env.rpc(apiVersion, "json", "account_tx", to_string(p))));
 
            p[jss::ledger_index] = "current";
            BEAST_EXPECT(isErr(env.rpc("json", "account_tx", to_string(p)), RpcLgrNotValidated));
 
            p[jss::ledger_index] = "";
            BEAST_EXPECT(isErr(env.rpc("json", "account_tx", to_string(p)), RpcLgrNotValidated));
        }
 
        // Ledger Hash
        {
            json::Value p{jParams};
 
            p[jss::ledger_hash] = to_string(env.closed()->header().hash);
            BEAST_EXPECT(hasTxs(env.rpc(apiVersion, "json", "account_tx", to_string(p))));
 
            p[jss::ledger_hash] = to_string(env.closed()->header().parentHash);
            BEAST_EXPECT(noTxs(env.rpc("json", "account_tx", to_string(p))));
        }
 
        // Ledger index max/min/index all specified
        // ERRORS out with invalid Parenthesis
        {
            jParams[jss::account] = "0xDEADBEEF";
            jParams[jss::account] = a1.human();
            json::Value p{jParams};
 
            p[jss::ledger_index_max] = -1;
            p[jss::ledger_index_min] = -1;
            p[jss::ledger_index] = -1;
 
            if (apiVersion < 2u)
            {
                BEAST_EXPECT(hasTxs(env.rpc(apiVersion, "json", "account_tx", to_string(p))));
            }
            else
            {
                BEAST_EXPECT(isErr(env.rpc("json", "account_tx", to_string(p)), RpcInvalidParams));
            }
        }
 
        // Ledger index max only
        {
            json::Value p{jParams};
            p[jss::ledger_index_max] = env.current()->header().seq;
            if (apiVersion < 2u)
            {
                BEAST_EXPECT(hasTxs(env.rpc(apiVersion, "json", "account_tx", to_string(p))));
            }
            else
            {
                BEAST_EXPECT(
                    isErr(env.rpc("json", "account_tx", to_string(p)), RpcLgrIdxMalformed));
            }
        }
        // test account non-string
        {
            auto testInvalidAccountParam = [&](auto const& param) {
                json::Value params;
                params[jss::account] = param;
                auto jrr = env.rpc("json", "account_tx", to_string(params))[jss::result];
                BEAST_EXPECT(jrr[jss::error] == "invalidParams");
                BEAST_EXPECT(jrr[jss::error_message] == "Invalid field 'account'.");
            };
 
            testInvalidAccountParam(1);
            testInvalidAccountParam(1.1);
            testInvalidAccountParam(true);
            testInvalidAccountParam(json::Value(json::ValueType::Null));
            testInvalidAccountParam(json::Value(json::ValueType::Object));
            testInvalidAccountParam(json::Value(json::ValueType::Array));
        }
        // test binary and forward for bool/non bool values
        {
            json::Value p{jParams};
            p[jss::binary] = "asdf";
            if (apiVersion < 2u)
            {
                json::Value result{env.rpc("json", "account_tx", to_string(p))};
                BEAST_EXPECT(result[jss::result][jss::status] == "success");
            }
            else
            {
                BEAST_EXPECT(isErr(env.rpc("json", "account_tx", to_string(p)), RpcInvalidParams));
            }
 
            p[jss::binary] = true;
            json::Value result{env.rpc("json", "account_tx", to_string(p))};
            BEAST_EXPECT(result[jss::result][jss::status] == "success");
 
            p[jss::forward] = "true";
            if (apiVersion < 2u)
            {
                BEAST_EXPECT(result[jss::result][jss::status] == "success");
            }
            else
            {
                BEAST_EXPECT(isErr(env.rpc("json", "account_tx", to_string(p)), RpcInvalidParams));
            }
 
            p[jss::forward] = false;
            result = env.rpc("json", "account_tx", to_string(p));
            BEAST_EXPECT(result[jss::result][jss::status] == "success");
        }
        // test limit with malformed values
        {
            json::Value p{jParams};
 
            // Test case: limit = 0 should fail (below minimum)
            p[jss::limit] = 0;
            BEAST_EXPECT(isErr(env.rpc("json", "account_tx", to_string(p)), RpcInvalidParams));
 
            // Test case: limit = 1.2 should fail (not an integer)
            p[jss::limit] = 1.2;
            BEAST_EXPECT(
                env.rpc("json", "account_tx", to_string(p))[jss::result][jss::error_message] ==
                rpc::expectedFieldMessage(jss::limit, "unsigned integer"));
 
            // Test case: limit = "10" should fail (string instead of integer)
            p[jss::limit] = "10";
            BEAST_EXPECT(
                env.rpc("json", "account_tx", to_string(p))[jss::result][jss::error_message] ==
                rpc::expectedFieldMessage(jss::limit, "unsigned integer"));
 
            // Test case: limit = true should fail (boolean instead of integer)
            p[jss::limit] = true;
            BEAST_EXPECT(
                env.rpc("json", "account_tx", to_string(p))[jss::result][jss::error_message] ==
                rpc::expectedFieldMessage(jss::limit, "unsigned integer"));
 
            // Test case: limit = false should fail (boolean instead of integer)
            p[jss::limit] = false;
            BEAST_EXPECT(
                env.rpc("json", "account_tx", to_string(p))[jss::result][jss::error_message] ==
                rpc::expectedFieldMessage(jss::limit, "unsigned integer"));
 
            // Test case: limit = -1 should fail (negative number)
            p[jss::limit] = -1;
            BEAST_EXPECT(
                env.rpc("json", "account_tx", to_string(p))[jss::result][jss::error_message] ==
                rpc::expectedFieldMessage(jss::limit, "unsigned integer"));
 
            // Test case: limit = [] should fail (array instead of integer)
            p[jss::limit] = json::Value(json::ValueType::Array);
            BEAST_EXPECT(
                env.rpc("json", "account_tx", to_string(p))[jss::result][jss::error_message] ==
                rpc::expectedFieldMessage(jss::limit, "unsigned integer"));
 
            // Test case: limit = {} should fail (object instead of integer)
            p[jss::limit] = json::Value(json::ValueType::Object);
            BEAST_EXPECT(
                env.rpc("json", "account_tx", to_string(p))[jss::result][jss::error_message] ==
                rpc::expectedFieldMessage(jss::limit, "unsigned integer"));
 
            // Test case: limit = "malformed" should fail (malformed string)
            p[jss::limit] = "malformed";
            BEAST_EXPECT(
                env.rpc("json", "account_tx", to_string(p))[jss::result][jss::error_message] ==
                rpc::expectedFieldMessage(jss::limit, "unsigned integer"));
 
            // Test case: limit = ["limit"] should fail (array with string)
            p[jss::limit] = json::Value(json::ValueType::Array);
            p[jss::limit].append("limit");
            BEAST_EXPECT(
                env.rpc("json", "account_tx", to_string(p))[jss::result][jss::error_message] ==
                rpc::expectedFieldMessage(jss::limit, "unsigned integer"));
 
            // Test case: limit = {"limit": 10} should fail (object with
            // property)
            p[jss::limit] = json::Value(json::ValueType::Object);
            p[jss::limit][jss::limit] = 10;
            BEAST_EXPECT(
                env.rpc("json", "account_tx", to_string(p))[jss::result][jss::error_message] ==
                rpc::expectedFieldMessage(jss::limit, "unsigned integer"));
 
            // Test case: limit = 10 should succeed (valid integer)
            p[jss::limit] = 10;
            BEAST_EXPECT(
                env.rpc("json", "account_tx", to_string(p))[jss::result][jss::status] == "success");
        }
    }
 
    void
    testContents()
    {
        testcase("Contents");
 
        // Get results for all transaction types that can be associated
        // with an account.  Start by generating all transaction types.
        using namespace test::jtx;
        using namespace std::chrono_literals;
 
        Env env(*this);
        Account const alice{"alice"};
        Account const alie{"alie"};
        Account const gw{"gw"};
        auto const usd{gw["USD"]};
 
        env.fund(XRP(1000000), alice, gw);
        env.close();
 
        // AccountSet
        env(noop(alice));
 
        // Payment
        env(pay(alice, gw, XRP(100)));
 
        // Regular key set
        env(regkey(alice, alie));
        env.close();
 
        // Trust and Offers
        env(trust(alice, usd(200)), Sig(alie));
        std::uint32_t const offerSeq{env.seq(alice)};
        env(offer(alice, usd(50), XRP(150)), Sig(alie));
        env.close();
 
        env(offerCancel(alice, offerSeq), Sig(alie));
        env.close();
 
        // SignerListSet
        env(signers(alice, 1, {{"bogie", 1}, {"demon", 1}}), Sig(alie));
 
        // Escrow
        {
            // Create an escrow.  Requires either a CancelAfter or FinishAfter.
            auto escrow = [](Account const& account, Account const& to, STAmount const& amount) {
                json::Value escrow;
                escrow[jss::TransactionType] = jss::EscrowCreate;
                escrow[jss::Account] = account.human();
                escrow[jss::Destination] = to.human();
                escrow[jss::Amount] = amount.getJson(JsonOptions::Values::None);
                return escrow;
            };
 
            NetClock::time_point const nextTime{env.now() + 2s};
 
            json::Value escrowWithFinish{escrow(alice, alice, XRP(500))};
            escrowWithFinish[sfFinishAfter.jsonName] = nextTime.time_since_epoch().count();
 
            std::uint32_t const escrowFinishSeq{env.seq(alice)};
            env(escrowWithFinish, Sig(alie));
 
            json::Value escrowWithCancel{escrow(alice, alice, XRP(500))};
            escrowWithCancel[sfFinishAfter.jsonName] = nextTime.time_since_epoch().count();
            escrowWithCancel[sfCancelAfter.jsonName] = nextTime.time_since_epoch().count() + 1;
 
            std::uint32_t const escrowCancelSeq{env.seq(alice)};
            env(escrowWithCancel, Sig(alie));
            env.close();
 
            {
                json::Value escrowFinish;
                escrowFinish[jss::TransactionType] = jss::EscrowFinish;
                escrowFinish[jss::Account] = alice.human();
                escrowFinish[sfOwner.jsonName] = alice.human();
                escrowFinish[sfOfferSequence.jsonName] = escrowFinishSeq;
                env(escrowFinish, Sig(alie));
            }
            {
                json::Value escrowCancel;
                escrowCancel[jss::TransactionType] = jss::EscrowCancel;
                escrowCancel[jss::Account] = alice.human();
                escrowCancel[sfOwner.jsonName] = alice.human();
                escrowCancel[sfOfferSequence.jsonName] = escrowCancelSeq;
                env(escrowCancel, Sig(alie));
            }
            env.close();
        }
 
        // PayChan
        {
            std::uint32_t const payChanSeq{env.seq(alice)};
            json::Value payChanCreate;
            payChanCreate[jss::TransactionType] = jss::PaymentChannelCreate;
            payChanCreate[jss::Account] = alice.human();
            payChanCreate[jss::Destination] = gw.human();
            payChanCreate[jss::Amount] = XRP(500).value().getJson(JsonOptions::Values::None);
            payChanCreate[sfSettleDelay.jsonName] = NetClock::duration{100s}.count();
            payChanCreate[sfPublicKey.jsonName] = strHex(alice.pk().slice());
            env(payChanCreate, Sig(alie));
            env.close();
 
            std::string const payChanIndex{
                strHex(keylet::payChannel(alice, gw, SeqProxy::rawSequence(payChanSeq)).key)};
 
            {
                json::Value payChanFund;
                payChanFund[jss::TransactionType] = jss::PaymentChannelFund;
                payChanFund[jss::Account] = alice.human();
                payChanFund[sfChannel.jsonName] = payChanIndex;
                payChanFund[jss::Amount] = XRP(200).value().getJson(JsonOptions::Values::None);
                env(payChanFund, Sig(alie));
                env.close();
            }
            {
                json::Value payChanClaim;
                payChanClaim[jss::TransactionType] = jss::PaymentChannelClaim;
                payChanClaim[jss::Flags] = tfClose;
                payChanClaim[jss::Account] = gw.human();
                payChanClaim[sfChannel.jsonName] = payChanIndex;
                payChanClaim[sfPublicKey.jsonName] = strHex(alice.pk().slice());
                env(payChanClaim);
                env.close();
            }
        }
 
        // Check
        {
            auto const aliceCheckId =
                keylet::check(alice, SeqProxy::rawSequence(env.seq(alice))).key;
            env(check::create(alice, gw, XRP(300)), Sig(alie));
 
            auto const gwCheckId = keylet::check(gw, SeqProxy::rawSequence(env.seq(gw))).key;
            env(check::create(gw, alice, XRP(200)));
            env.close();
 
            env(check::cash(alice, gwCheckId, XRP(200)), Sig(alie));
            env(check::cancel(alice, aliceCheckId), Sig(alie));
            env.close();
        }
        {
            // Deposit pre-authorization with a Ticket.
            std::uint32_t const tktSeq{env.seq(alice) + 1};
            env(ticket::create(alice, 1), Sig(alie));
            env.close();
 
            env(deposit::auth(alice, gw), ticket::Use(tktSeq), Sig(alie));
            env.close();
        }
 
        // Setup is done.  Look at the transactions returned by account_tx.
        json::Value params;
        params[jss::account] = alice.human();
        params[jss::ledger_index_min] = -1;
        params[jss::ledger_index_max] = -1;
 
        json::Value const result{env.rpc("json", "account_tx", to_string(params))};
 
        BEAST_EXPECT(result[jss::result][jss::status] == "success");
        BEAST_EXPECT(result[jss::result][jss::transactions].isArray());
 
        json::Value const& txs{result[jss::result][jss::transactions]};
 
        // clang-format off
        // Do a sanity check on each returned transaction.  They should
        // be returned in the reverse order of application to the ledger.
        static const NodeSanity kSanity[]{
            //    txType,                    created,                                                    deleted,                          modified
            {0,  jss::DepositPreauth,         {jss::DepositPreauth},                                      {jss::Ticket},                    {jss::AccountRoot, jss::DirectoryNode}},
            {1,  jss::TicketCreate,           {jss::Ticket},                                              {},                               {jss::AccountRoot, jss::DirectoryNode}},
            {2,  jss::CheckCancel,            {},                                                         {jss::Check},                     {jss::AccountRoot, jss::AccountRoot, jss::DirectoryNode, jss::DirectoryNode}},
            {3,  jss::CheckCash,              {},                                                         {jss::Check},                     {jss::AccountRoot, jss::AccountRoot, jss::DirectoryNode, jss::DirectoryNode}},
            {4,  jss::CheckCreate,            {jss::Check},                                               {},                               {jss::AccountRoot, jss::AccountRoot, jss::DirectoryNode, jss::DirectoryNode}},
            {5,  jss::CheckCreate,            {jss::Check},                                               {},                               {jss::AccountRoot, jss::AccountRoot, jss::DirectoryNode, jss::DirectoryNode}},
            {6,  jss::PaymentChannelClaim,    {},                                                         {jss::PayChannel},                {jss::AccountRoot, jss::AccountRoot, jss::DirectoryNode, jss::DirectoryNode}},
            {7,  jss::PaymentChannelFund,     {},                                                         {},                               {jss::AccountRoot, jss::PayChannel}},
            {8,  jss::PaymentChannelCreate,   {jss::PayChannel},                                          {},                               {jss::AccountRoot, jss::AccountRoot, jss::DirectoryNode, jss::DirectoryNode}},
            {9,  jss::EscrowCancel,           {},                                                         {jss::Escrow},                    {jss::AccountRoot, jss::DirectoryNode}},
            {10, jss::EscrowFinish,           {},                                                         {jss::Escrow},                    {jss::AccountRoot, jss::DirectoryNode}},
            {11, jss::EscrowCreate,           {jss::Escrow},                                              {},                               {jss::AccountRoot, jss::DirectoryNode}},
            {12, jss::EscrowCreate,           {jss::Escrow},                                              {},                               {jss::AccountRoot, jss::DirectoryNode}},
            {13, jss::SignerListSet,          {jss::SignerList},                                          {},                               {jss::AccountRoot, jss::DirectoryNode}},
            {14, jss::OfferCancel,            {},                                                         {jss::Offer, jss::DirectoryNode}, {jss::AccountRoot, jss::DirectoryNode}},
            {15, jss::OfferCreate,            {jss::Offer, jss::DirectoryNode},                           {},                               {jss::AccountRoot, jss::DirectoryNode}},
            {16, jss::TrustSet,               {jss::RippleState, jss::DirectoryNode, jss::DirectoryNode}, {},                               {jss::AccountRoot, jss::AccountRoot}},
            {17, jss::SetRegularKey,          {},                                                         {},                               {jss::AccountRoot}},
            {18, jss::Payment,                {},                                                         {},                               {jss::AccountRoot, jss::AccountRoot}},
            {19, jss::AccountSet,             {},                                                         {},                               {jss::AccountRoot}},
            {20, jss::AccountSet,             {},                                                         {},                               {jss::AccountRoot}},
            {21, jss::Payment,                {jss::AccountRoot},                                         {},                               {jss::AccountRoot}},
        };
        // clang-format on
 
        BEAST_EXPECT(std::size(kSanity) == result[jss::result][jss::transactions].size());
 
        for (unsigned int index{0}; index < std::size(kSanity); ++index)
        {
            checkSanity(txs[index], kSanity[index]);
        }
    }
 
    void
    testAccountDelete()
    {
        testcase("AccountDelete");
 
        // Verify that if an account is resurrected then the account_tx RPC
        // command still recovers all transactions on that account before
        // and after resurrection.
        using namespace test::jtx;
        using namespace std::chrono_literals;
 
        Env env(*this);
        Account const alice{"alice"};
        Account const becky{"becky"};
 
        env.fund(XRP(10000), alice, becky);
        env.close();
 
        // Verify that becky's account root is present.
        Keylet const beckyAcctKey{keylet::account(becky.id())};
        BEAST_EXPECT(env.closed()->exists(beckyAcctKey));
 
        // becky does an AccountSet .
        env(noop(becky));
 
        // Close enough ledgers to be able to delete becky's account.
        std::uint32_t const ledgerCount{env.current()->seq() + 257 - env.seq(becky)};
 
        for (std::uint32_t i = 0; i < ledgerCount; ++i)
            env.close();
 
        auto const beckyPreDelBalance{env.balance(becky)};
 
        auto const acctDelFee{drops(env.current()->fees().increment)};
        env(acctdelete(becky, alice), Fee(acctDelFee));
        env.close();
 
        // Verify that becky's account root is gone.
        BEAST_EXPECT(!env.closed()->exists(beckyAcctKey));
        env.close();
 
        // clang-format off
        // Do a sanity check on each returned transaction.  They should
        // be returned in the reverse order of application to the ledger.
        //
        // Note that the first two transactions in sanity have not occurred
        // yet.  We'll see those after becky's account is resurrected.
        static const NodeSanity kSanity[]
        {
                                    //   txType,                    created,            deleted,            modified
/* becky pays alice              */ { 0, jss::Payment,              {},                 {},                 {jss::AccountRoot, jss::AccountRoot}},
/* alice resurrects becky's acct */ { 1, jss::Payment,              {jss::AccountRoot}, {},                 {jss::AccountRoot}},
/* becky deletes her account     */ { 2, jss::AccountDelete,        {},                 {jss::AccountRoot}, {jss::AccountRoot}},
/* becky's noop                  */ { 3, jss::AccountSet,           {},                 {},                 {jss::AccountRoot}},
/* "fund" sets flags             */ { 4, jss::AccountSet,           {},                 {},                 {jss::AccountRoot}},
/* "fund" creates becky's acct   */ { 5, jss::Payment,              {jss::AccountRoot}, {},                 {jss::AccountRoot}}
        };
        // clang-format on
 
        // Verify that we can recover becky's account_tx information even
        // after the account is deleted.
        {
            json::Value params;
            params[jss::account] = becky.human();
            params[jss::ledger_index_min] = -1;
            params[jss::ledger_index_max] = -1;
 
            json::Value const result{env.rpc("json", "account_tx", to_string(params))};
 
            BEAST_EXPECT(result[jss::result][jss::status] == "success");
            BEAST_EXPECT(result[jss::result][jss::transactions].isArray());
 
            // The first two transactions listed in sanity haven't happened yet.
            static constexpr unsigned int kBeckyDeletedOffset = 2;
            BEAST_EXPECT(
                std::size(kSanity) ==
                result[jss::result][jss::transactions].size() + kBeckyDeletedOffset);
 
            json::Value const& txs{result[jss::result][jss::transactions]};
 
            for (unsigned int index = kBeckyDeletedOffset; index < std::size(kSanity); ++index)
            {
                checkSanity(txs[index - kBeckyDeletedOffset], kSanity[index]);
            }
        }
 
        // All it takes is a large enough XRP payment to resurrect
        // becky's account.  Try too small a payment.
        env(pay(alice, becky, drops(env.current()->fees().accountReserve(0, 1)) - drops(1)),
            Ter(tecNO_DST_INSUF_XRP));
        env.close();
 
        // Actually resurrect becky's account.
        env(pay(alice, becky, XRP(45)));
        env.close();
 
        // becky's account root should be back.
        BEAST_EXPECT(env.closed()->exists(beckyAcctKey));
        BEAST_EXPECT(env.balance(becky) == XRP(45));
 
        // becky pays alice.
        env(pay(becky, alice, XRP(20)));
        env.close();
 
        // Setup is done.  Look at the transactions returned by account_tx.
        // Verify that account_tx locates all of becky's transactions.
        json::Value params;
        params[jss::account] = becky.human();
        params[jss::ledger_index_min] = -1;
        params[jss::ledger_index_max] = -1;
 
        json::Value const result{env.rpc("json", "account_tx", to_string(params))};
 
        BEAST_EXPECT(result[jss::result][jss::status] == "success");
        BEAST_EXPECT(result[jss::result][jss::transactions].isArray());
 
        BEAST_EXPECT(std::size(kSanity) == result[jss::result][jss::transactions].size());
 
        json::Value const& txs{result[jss::result][jss::transactions]};
 
        for (unsigned int index = 0; index < std::size(kSanity); ++index)
        {
            checkSanity(txs[index], kSanity[index]);
        }
    }
 
    void
    testMPT()
    {
        testcase("MPT");
 
        using namespace test::jtx;
        using namespace std::chrono_literals;
 
        auto cfg = makeConfig();
        cfg->fees.referenceFee = 10;
        Env env(*this, std::move(cfg));
 
        Account const alice{"alice"};
        Account const bob{"bob"};
        Account const carol{"carol"};
 
        MPTTester mptAlice(env, alice, {.holders = {bob, carol}});
 
        // check the latest mpt-related txn is in alice's account history
        auto const checkAliceAcctTx = [&](size_t size, json::StaticString txType) {
            json::Value params;
            params[jss::account] = alice.human();
            params[jss::limit] = 100;
            auto const jv = env.rpc("json", "account_tx", to_string(params))[jss::result];
 
            BEAST_EXPECT(jv[jss::transactions].size() == size);
            auto const& tx0(jv[jss::transactions][0u][jss::tx]);
            BEAST_EXPECT(tx0[jss::TransactionType] == txType);
 
            std::string const txHash{
                env.tx()->getJson(JsonOptions::Values::None)[jss::hash].asString()};
            BEAST_EXPECT(tx0[jss::hash] == txHash);
        };
 
        // alice creates issuance
        mptAlice.create(
            {.ownerCount = 1,
             .holderCount = 0,
             .flags = tfMPTCanClawback | tfMPTRequireAuth | tfMPTCanTransfer});
 
        checkAliceAcctTx(3, jss::MPTokenIssuanceCreate);
 
        // bob creates a MPToken;
        mptAlice.authorize({.account = bob});
        checkAliceAcctTx(4, jss::MPTokenAuthorize);
        env.close();
 
        // TODO: windows pipeline fails validation for the hardcoded ledger hash
        // due to having different test config, it can be uncommented after
        // figuring out what happened
        //
        // ledger hash should be fixed regardless any change to account history
        // BEAST_EXPECT(
        //     to_string(env.closed()->header().hash) ==
        //     "0BD507BB87D3C0E73B462485E6E381798A8C82FC49BF17FE39C60E08A1AF035D");
 
        // alice authorizes bob
        mptAlice.authorize({.account = alice, .holder = bob});
        checkAliceAcctTx(5, jss::MPTokenAuthorize);
 
        // carol creates a MPToken;
        mptAlice.authorize({.account = carol});
        checkAliceAcctTx(6, jss::MPTokenAuthorize);
 
        // alice authorizes carol
        mptAlice.authorize({.account = alice, .holder = carol});
        checkAliceAcctTx(7, jss::MPTokenAuthorize);
 
        // alice pays bob 100 tokens
        mptAlice.pay(alice, bob, 100);
        checkAliceAcctTx(8, jss::Payment);
 
        // bob pays carol 10 tokens
        mptAlice.pay(bob, carol, 10);
        checkAliceAcctTx(9, jss::Payment);
    }
 
    void
    testDelegation()
    {
        testcase("Delegation Filtering");
 
        using namespace test::jtx;
 
        Env env(*this);
        Account const alice{"alice"};
        Account const bob{"bob"};
        Account const carol{"carol"};
 
        env.fund(XRP(10000), alice, bob, carol);
        env.close();
 
        // Normal TX: Alice pays Carol (Signed by Alice's Master Key)
        env(pay(alice, carol, XRP(10)));
        env.close();
 
        // Setup Delegation: Alice allows Bob to sign Payments for her
        env(delegate::set(alice, bob, {"Payment"}));
        env.close();
 
        // Delegated TX: Alice pays Bob (Signed by Bob using Delegation)
        env(pay(alice, bob, XRP(20)), delegate::As(bob));
        env.close();
 
        // Normal TX: Bob pays Carol (Signed by Bob for himself)
        env(pay(bob, carol, XRP(30)));
        env.close();
 
        auto const countTxs = [&](AccountID const& account,
                                  json::Value const& delegateParams,
                                  std::optional<std::uint32_t> const limit = std::nullopt) -> int {
            int count = 0;
            json::Value marker;
            bool haveMarker = false;
            int pages = 0;
 
            while (true)
            {
                json::Value params;
                params[jss::account] = toBase58(account);
                params[jss::ledger_index_min] = -1;
                params[jss::ledger_index_max] = -1;
 
                if (!delegateParams.isNull())
                    params[jss::delegate] = delegateParams;
                if (limit)
                    params[jss::limit] = *limit;
                if (haveMarker)
                    params[jss::marker] = marker;
 
                auto const res = env.rpc("json", "account_tx", to_string(params));
                auto const& result = res[jss::result];
 
                if (result.isMember(jss::transactions))
                    count += result[jss::transactions].size();
 
                if (!limit || !result.isMember(jss::marker))
                    break;
 
                marker = result[jss::marker];
                haveMarker = true;
                ++pages;
                if (!BEAST_EXPECT(pages < 20))
                    break;
            }
 
            return count;
        };
 
        auto const checkError = [&](json::Value const& delegateParams,
                                    std::string const& errToken) {
            json::Value params;
            params[jss::account] = alice.human();
            params[jss::delegate] = delegateParams;
            auto res = env.rpc("json", "account_tx", to_string(params));
            BEAST_EXPECT(res[jss::result][jss::error] == errToken);
        };
 
        // Filter: Delegatee. Expects TX #2 (Signed by Bob)
        {
            json::Value p;
            p[jss::delegate_filter] = "actor";
            BEAST_EXPECT(countTxs(alice.id(), p) == 1);
        }
 
        // Filter: Delegatee + Counterparty Bob. Expects TX #2.
        {
            json::Value p;
            p[jss::delegate_filter] = "actor";
            p[jss::counter_party] = bob.human();
            BEAST_EXPECT(countTxs(alice.id(), p) == 1);
        }
 
        // Filter: Delegatee + Counterparty Carol. Expects 0.
        {
            json::Value p;
            p[jss::delegate_filter] = "actor";
            p[jss::counter_party] = carol.human();
            BEAST_EXPECT(countTxs(alice.id(), p) == 0);
        }
 
        // Filter: Delegator. Expects TX #2.
        // (Bob signed it, but Alice is the owner).
        {
            json::Value p;
            p[jss::delegate_filter] = "authorizer";
            BEAST_EXPECT(countTxs(bob.id(), p) == 1);
        }
 
        // Filter: Delegator + Counterparty Alice. Expects TX #2.
        {
            json::Value p;
            p[jss::delegate_filter] = "authorizer";
            p[jss::counter_party] = alice.human();
            BEAST_EXPECT(countTxs(bob.id(), p) == 1);
        }
 
        // Filter: Authorizer. Expect: None.
        // TX #2 has sfDelegate present, but Alice is the delegator/owner, not
        // the delegate signer
        {
            json::Value p;
            p[jss::delegate_filter] = "authorizer";
            BEAST_EXPECT(countTxs(alice.id(), p) == 0);
        }
 
        // Query Bob (Signer), Filter: Delegator, Counterparty: Carol
        // Expect: None (Alice is Owner, not Carol)
        {
            json::Value p;
            p[jss::delegate_filter] = "authorizer";
            p[jss::counter_party] = carol.human();
            BEAST_EXPECT(countTxs(bob.id(), p) == 0);
        }
 
        // Query Bob (Signer), Filter: Delegatee
        // Expect: None. Bob did not employ a delegatee for his own TXs (TX C).
        {
            json::Value p;
            p[jss::delegate_filter] = "actor";
            BEAST_EXPECT(countTxs(bob.id(), p) == 0);
        }
 
        // "delegate" is not an object (e.g., string)
        {
            json::Value const p = "not_an_object";
            checkError(p, "invalidParams");
        }
 
        // Missing "delegate_filter" inside object
        {
            json::Value const p(json::ValueType::Object);
            checkError(p, "invalidParams");
        }
 
        // "delegate_filter" is not a string (e.g., int)
        {
            json::Value p;
            p[jss::delegate_filter] = 123;
            checkError(p, "invalidParams");
        }
 
        // "delegate_filter" has invalid value
        {
            json::Value p;
            p[jss::delegate_filter] = "random_string";
            checkError(p, "invalidParams");
        }
 
        // "counterparty" is not a string
        {
            json::Value p;
            p[jss::delegate_filter] = "actor";
            p[jss::counter_party] = 123;
            checkError(p, "invalidParams");
        }
 
        // "counterparty" is malformed base58
        {
            json::Value p;
            p[jss::delegate_filter] = "actor";
            p[jss::counter_party] = "not_an_account";
            checkError(p, "actMalformed");
        }
 
        // Multi-signed non-delegated TX: Alice pays Carol via multi-sig.
        // sfDelegate is absent and sfSigningPubKey is empty — the filter
        // must skip it without crashing.
        {
            Account const daria{"daria"};
            Account const edward{"edward"};
            env.fund(XRP(1000), daria, edward);
            env.close();
            env(signers(alice, 2, {{daria, 1}, {edward, 1}}));
            env.close();
            env(pay(alice, carol, XRP(1)),
                Fee(drops(env.current()->fees().increment * 2)),
                Msig(daria, edward));
            env.close();
 
            // Alice's actor filter should still see only the 1 delegated tx,
            // not the multi-signed one.
            json::Value p;
            p[jss::delegate_filter] = "actor";
            BEAST_EXPECT(countTxs(alice.id(), p) == 1);
        }
 
        // Regular-key-signed non-delegated TX: Alice pays Bob, signed by Bob
        // as Alice's regular key. This must not be treated as delegation.
        {
            env(regkey(alice, bob));
            env.close();
            env(pay(alice, bob, XRP(1)));
            env.close();
 
            json::Value actorFilter;
            actorFilter[jss::delegate_filter] = "actor";
            BEAST_EXPECT(countTxs(alice.id(), actorFilter) == 1);
            // limit: 1 forces pagination past newer non-delegated rows.
            BEAST_EXPECT(countTxs(alice.id(), actorFilter, 1) == 1);
 
            actorFilter[jss::counter_party] = bob.human();
            BEAST_EXPECT(countTxs(alice.id(), actorFilter) == 1);
            BEAST_EXPECT(countTxs(alice.id(), actorFilter, 1) == 1);
 
            json::Value authorizerFilter;
            authorizerFilter[jss::delegate_filter] = "authorizer";
            BEAST_EXPECT(countTxs(bob.id(), authorizerFilter) == 1);
            BEAST_EXPECT(countTxs(bob.id(), authorizerFilter, 1) == 1);
 
            authorizerFilter[jss::counter_party] = alice.human();
            BEAST_EXPECT(countTxs(bob.id(), authorizerFilter) == 1);
            BEAST_EXPECT(countTxs(bob.id(), authorizerFilter, 1) == 1);
        }
 
        // Pagination marker/delegate-filter consistency. A marker returned by a
        // delegate-filtered query carries a `delegate` flag and is only valid
        // for a follow-up request that repeats the filter; mixing the two
        // marker conventions must be rejected with invalidParams.
        {
            json::Value actorFilter;
            actorFilter[jss::delegate_filter] = "actor";
 
            // Obtain a delegate-filtered marker (limit 1 forces pagination).
            json::Value dp;
            dp[jss::account] = alice.human();
            dp[jss::ledger_index_min] = -1;
            dp[jss::ledger_index_max] = -1;
            dp[jss::delegate] = actorFilter;
            dp[jss::limit] = 1;
            auto const dRes = env.rpc("json", "account_tx", to_string(dp));
            BEAST_EXPECT(dRes[jss::result].isMember(jss::marker));
            json::Value const delegateMarker = dRes[jss::result][jss::marker];
            BEAST_EXPECT(
                delegateMarker.isMember(jss::delegate) && delegateMarker[jss::delegate].asBool());
 
            // Reusing a delegate marker without the delegate filter is rejected.
            {
                json::Value p;
                p[jss::account] = alice.human();
                p[jss::ledger_index_min] = -1;
                p[jss::ledger_index_max] = -1;
                p[jss::limit] = 1;
                p[jss::marker] = delegateMarker;
                auto const r = env.rpc("json", "account_tx", to_string(p));
                BEAST_EXPECT(r[jss::result][jss::error] == "invalidParams");
            }
 
            // Obtain a non-delegate marker; it must not carry the flag.
            json::Value np;
            np[jss::account] = alice.human();
            np[jss::ledger_index_min] = -1;
            np[jss::ledger_index_max] = -1;
            np[jss::limit] = 1;
            auto const nRes = env.rpc("json", "account_tx", to_string(np));
            BEAST_EXPECT(nRes[jss::result].isMember(jss::marker));
            json::Value const normalMarker = nRes[jss::result][jss::marker];
            BEAST_EXPECT(!normalMarker.isMember(jss::delegate));
 
            // Reusing a non-delegate marker with a delegate filter is rejected.
            {
                json::Value p;
                p[jss::account] = alice.human();
                p[jss::ledger_index_min] = -1;
                p[jss::ledger_index_max] = -1;
                p[jss::limit] = 1;
                p[jss::delegate] = actorFilter;
                p[jss::marker] = normalMarker;
                auto const r = env.rpc("json", "account_tx", to_string(p));
                BEAST_EXPECT(r[jss::result][jss::error] == "invalidParams");
            }
        }
    }
 
    void
    testDelegationMultiSign()
    {
        testcase("Delegation filter with multi-signed delegatee");
        using namespace test::jtx;
 
        Env env(*this);
        Account const alice{"alice"};
        Account const bob{"bob"};
        Account const carol{"carol"};
        Account const daria{"daria"};
        Account const edward{"edward"};
 
        env.fund(XRP(10000), alice, bob, carol, daria, edward);
        env.close();
 
        // Bob's identity is established via multi-sig (daria + edward)
        env(signers(bob, 2, {{daria, 1}, {edward, 1}}));
        env.close();
 
        env(delegate::set(alice, bob, {"Payment"}));
        env.close();
 
        // Delegated tx: Alice pays Carol, Bob signs via multi-sig
        env(pay(alice, carol, XRP(10)), Fee(XRP(1)), delegate::As(bob), Msig(daria, edward));
        env.close();
 
        auto const countTxs = [&](AccountID const& account,
                                  json::Value const& delegateParams) -> int {
            json::Value params;
            params[jss::account] = toBase58(account);
            params[jss::ledger_index_min] = -1;
            params[jss::ledger_index_max] = -1;
            params[jss::delegate] = delegateParams;
 
            auto const res = env.rpc("json", "account_tx", to_string(params));
 
            if (res[jss::result].isMember(jss::transactions))
                return res[jss::result][jss::transactions].size();
            return 0;
        };
 
        // Alice (owner) finds the tx with actor filter
        {
            json::Value p;
            p[jss::delegate_filter] = "actor";
            BEAST_EXPECT(countTxs(alice.id(), p) == 1);
        }
 
        // Alice (owner) + counterparty Bob finds the tx
        {
            json::Value p;
            p[jss::delegate_filter] = "actor";
            p[jss::counter_party] = bob.human();
            BEAST_EXPECT(countTxs(alice.id(), p) == 1);
        }
 
        // Bob (delegatee) finds the tx with authorizer filter
        {
            json::Value p;
            p[jss::delegate_filter] = "authorizer";
            BEAST_EXPECT(countTxs(bob.id(), p) == 1);
        }
 
        // Bob (delegatee) + counterparty Alice finds the tx
        {
            json::Value p;
            p[jss::delegate_filter] = "authorizer";
            p[jss::counter_party] = alice.human();
            BEAST_EXPECT(countTxs(bob.id(), p) == 1);
        }
    }
 
    void
    testDelegationMarkerWithinPage()
    {
        testcase("Delegation filter marker within a single query page");
 
        using namespace test::jtx;
 
        Env env(*this);
        Account const alice{"alice"};
        Account const bob{"bob"};
        Account const carol{"carol"};
 
        env.fund(XRP(10000), alice, bob, carol);
        env.close();
 
        env(delegate::set(alice, bob, {"Payment"}));
        env.close();
 
        auto const startLedger = env.closed()->header().seq + 1;
 
        env(pay(alice, carol, XRP(1)), delegate::As(bob));
        env.close();
        env(pay(alice, carol, XRP(1)), delegate::As(bob));
        env.close();
 
        json::Value p;
        p[jss::delegate_filter] = "actor";
 
        json::Value params;
        params[jss::account] = alice.human();
        params[jss::ledger_index_min] = startLedger;
        params[jss::ledger_index_max] = -1;
        params[jss::delegate] = p;
        params[jss::limit] = 1;
 
        auto const res = env.rpc("json", "account_tx", to_string(params));
        auto const& result = res[jss::result];
 
        // The first page emits only the first delegated payment. (as page limit is set to 1)
        BEAST_EXPECT(result[jss::transactions].size() == 1);
        BEAST_EXPECT(result.isMember(jss::marker));
 
        // Following the marker resumes right after the first payment and
        // returns the second one.
        json::Value page2 = params;
        page2[jss::marker] = result[jss::marker];
        auto const res2 = env.rpc("json", "account_tx", to_string(page2));
        BEAST_EXPECT(res2[jss::result][jss::transactions].size() == 1);
    }
 
    void
    testSponsorship()
    {
        // test all sponsored transactions are in sponsor and sponsee's account
        // tx list
        testcase("Sponsorship");
 
        using namespace test::jtx;
        Env env(*this);
        Account const alice("alice");
        Account const sponsor("sponsor");
        Account const sponsor2("sponsor2");
        env.fund(XRP(10000), alice, sponsor, sponsor2);
        env.close();
 
        // check the latest sponsorship-related txn is in account tx list
        auto const checkTx = [&](Account const& account, json::StaticString txType) {
            json::Value params;
            params[jss::account] = account.human();
            params[jss::limit] = 100;
            auto const jv = env.rpc("json", "account_tx", to_string(params))[jss::result];
 
            auto const& tx0(jv[jss::transactions][0u][jss::tx]);
            BEAST_EXPECT(tx0[jss::TransactionType] == txType);
 
            std::string const txHash{
                env.tx()->getJson(JsonOptions::Values::None)[jss::hash].asString()};
            BEAST_EXPECT(tx0[jss::hash] == txHash);
        };
 
        // fee sponsorship
        env(noop(alice), sponsor::As(sponsor, spfSponsorFee), Sig(sfSponsorSignature, sponsor));
        env.close();
        checkTx(alice, jss::AccountSet);
        checkTx(sponsor, jss::AccountSet);
 
        // set sponsor
        env(sponsor::set(sponsor, 0, 100, XRP(100)), sponsor::SponseeAcc(alice), Ter(tesSUCCESS));
        env.close();
        checkTx(alice, jss::SponsorshipSet);
        checkTx(sponsor, jss::SponsorshipSet);
 
        // create an object with sponsor
        auto const checkId = keylet::check(alice, SeqProxy::rawSequence(env.seq(alice))).key;
        env(check::create(alice, sponsor, XRP(1)), sponsor::As(sponsor, spfSponsorReserve));
        env.close();
        checkTx(alice, jss::CheckCreate);
        checkTx(sponsor, jss::CheckCreate);
 
        // transfer object sponsorship
        env(sponsor::transfer(alice, tfSponsorshipReassign, checkId),
            sponsor::As(sponsor2, spfSponsorReserve),
            Sig(sfSponsorSignature, sponsor2));
        env.close();
        checkTx(alice, jss::SponsorshipTransfer);
        checkTx(sponsor, jss::SponsorshipTransfer);
        checkTx(sponsor2, jss::SponsorshipTransfer);
 
        // delete the sponsored object
        env(check::cancel(alice, checkId),
            sponsor::As(sponsor, spfSponsorFee),
            Sig(sfSponsorSignature, sponsor));
        env.close();
        checkTx(alice, jss::CheckCancel);
        checkTx(sponsor, jss::CheckCancel);
        checkTx(sponsor2, jss::CheckCancel);
 
        // account sponsorship
        env(sponsor::transfer(alice, tfSponsorshipCreate),
            sponsor::As(sponsor, spfSponsorReserve),
            Sig(sfSponsorSignature, sponsor));
        env.close();
        checkTx(alice, jss::SponsorshipTransfer);
        checkTx(sponsor, jss::SponsorshipTransfer);
    }
 
public:
    void
    run() override
    {
        forAllApiVersions([this](unsigned apiVersion) { testParameters(apiVersion); });
        testContents();
        testAccountDelete();
        testMPT();
        testDelegation();
        testDelegationMultiSign();
        testDelegationMarkerWithinPage();
        testSponsorship();
    }
};
BEAST_DEFINE_TESTSUITE(AccountTx, rpc, xrpl);
 
}  // namespace xrpl::test