MPToken_test.cpp

//------------------------------------------------------------------------------
/*
  This file is part of rippled: https://github.com/ripple/rippled
  Copyright (c) 2024 Ripple Labs Inc.
 
  Permission to use, copy, modify, and/or distribute this software for any
  purpose  with  or without fee is hereby granted, provided that the above
  copyright notice and this permission notice appear in all copies.
 
  THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
  MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  ANY  SPECIAL ,  DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
  ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
//==============================================================================
 
#include <test/jtx.h>
#include <test/jtx/credentials.h>
#include <test/jtx/permissioned_domains.h>
#include <test/jtx/trust.h>
#include <test/jtx/xchain_bridge.h>
 
#include <xrpl/basics/base_uint.h>
#include <xrpl/beast/utility/Zero.h>
#include <xrpl/protocol/Feature.h>
#include <xrpl/protocol/TER.h>
#include <xrpl/protocol/TxFlags.h>
#include <xrpl/protocol/jss.h>
 
namespace ripple {
namespace test {
 
class MPToken_test : public beast::unit_test::suite
{
    void
    testCreateValidation(FeatureBitset features)
    {
        testcase("Create Validate");
        using namespace test::jtx;
        Account const alice("alice");
 
        // test preflight of MPTokenIssuanceCreate
        {
            // If the MPT amendment is not enabled, you should not be able to
            // create MPTokenIssuances
            Env env{*this, features - featureMPTokensV1};
            MPTTester mptAlice(env, alice);
 
            mptAlice.create({.ownerCount = 0, .err = temDISABLED});
        }
 
        // test preflight of MPTokenIssuanceCreate
        {
            Env env{*this, features};
            MPTTester mptAlice(env, alice);
 
            mptAlice.create({.flags = 0x00000001, .err = temINVALID_FLAG});
 
            // tries to set a txfee while not enabling in the flag
            mptAlice.create(
                {.maxAmt = 100,
                 .assetScale = 0,
                 .transferFee = 1,
                 .metadata = "test",
                 .err = temMALFORMED});
 
            if (!features[featureSingleAssetVault])
            {
                // tries to set DomainID when SAV is disabled
                mptAlice.create(
                    {.maxAmt = 100,
                     .assetScale = 0,
                     .metadata = "test",
                     .flags = tfMPTRequireAuth,
                     .domainID = uint256(42),
                     .err = temDISABLED});
            }
            else if (!features[featurePermissionedDomains])
            {
                // tries to set DomainID when PD is disabled
                mptAlice.create(
                    {.maxAmt = 100,
                     .assetScale = 0,
                     .metadata = "test",
                     .flags = tfMPTRequireAuth,
                     .domainID = uint256(42),
                     .err = temDISABLED});
            }
            else
            {
                // tries to set DomainID when RequireAuth is not set
                mptAlice.create(
                    {.maxAmt = 100,
                     .assetScale = 0,
                     .metadata = "test",
                     .domainID = uint256(42),
                     .err = temMALFORMED});
 
                // tries to set zero DomainID
                mptAlice.create(
                    {.maxAmt = 100,
                     .assetScale = 0,
                     .metadata = "test",
                     .flags = tfMPTRequireAuth,
                     .domainID = beast::zero,
                     .err = temMALFORMED});
            }
 
            // tries to set a txfee greater than max
            mptAlice.create(
                {.maxAmt = 100,
                 .assetScale = 0,
                 .transferFee = maxTransferFee + 1,
                 .metadata = "test",
                 .flags = tfMPTCanTransfer,
                 .err = temBAD_TRANSFER_FEE});
 
            // tries to set a txfee while not enabling transfer
            mptAlice.create(
                {.maxAmt = 100,
                 .assetScale = 0,
                 .transferFee = maxTransferFee,
                 .metadata = "test",
                 .err = temMALFORMED});
 
            // empty metadata returns error
            mptAlice.create(
                {.maxAmt = 100,
                 .assetScale = 0,
                 .transferFee = 0,
                 .metadata = "",
                 .err = temMALFORMED});
 
            // MaximumAmout of 0 returns error
            mptAlice.create(
                {.maxAmt = 0,
                 .assetScale = 1,
                 .transferFee = 1,
                 .metadata = "test",
                 .err = temMALFORMED});
 
            // MaximumAmount larger than 63 bit returns error
            mptAlice.create(
                {.maxAmt = 0xFFFF'FFFF'FFFF'FFF0,  // 18'446'744'073'709'551'600
                 .assetScale = 0,
                 .transferFee = 0,
                 .metadata = "test",
                 .err = temMALFORMED});
            mptAlice.create(
                {.maxAmt = maxMPTokenAmount + 1,  // 9'223'372'036'854'775'808
                 .assetScale = 0,
                 .transferFee = 0,
                 .metadata = "test",
                 .err = temMALFORMED});
        }
    }
 
    void
    testCreateEnabled(FeatureBitset features)
    {
        testcase("Create Enabled");
 
        using namespace test::jtx;
        Account const alice("alice");
 
        {
            // If the MPT amendment IS enabled, you should be able to create
            // MPTokenIssuances
            Env env{*this, features};
            MPTTester mptAlice(env, alice);
            mptAlice.create(
                {.maxAmt = maxMPTokenAmount,  // 9'223'372'036'854'775'807
                 .assetScale = 1,
                 .transferFee = 10,
                 .metadata = "123",
                 .ownerCount = 1,
                 .flags = tfMPTCanLock | tfMPTRequireAuth | tfMPTCanEscrow |
                     tfMPTCanTrade | tfMPTCanTransfer | tfMPTCanClawback});
 
            // Get the hash for the most recent transaction.
            std::string const txHash{
                env.tx()->getJson(JsonOptions::none)[jss::hash].asString()};
 
            Json::Value const result = env.rpc("tx", txHash)[jss::result];
            BEAST_EXPECT(
                result[sfMaximumAmount.getJsonName()] == "9223372036854775807");
        }
 
        if (features[featureSingleAssetVault])
        {
            // Add permissioned domain
            Account const credIssuer1{"credIssuer1"};
            std::string const credType = "credential";
 
            pdomain::Credentials const credentials1{
                {.issuer = credIssuer1, .credType = credType}};
 
            {
                Env env{*this, features};
                env.fund(XRP(1000), credIssuer1);
 
                env(pdomain::setTx(credIssuer1, credentials1));
                auto const domainId1 = [&]() {
                    auto tx = env.tx()->getJson(JsonOptions::none);
                    return pdomain::getNewDomain(env.meta());
                }();
 
                MPTTester mptAlice(env, alice);
                mptAlice.create({
                    .maxAmt = maxMPTokenAmount,  // 9'223'372'036'854'775'807
                    .assetScale = 1,
                    .transferFee = 10,
                    .metadata = "123",
                    .ownerCount = 1,
                    .flags = tfMPTCanLock | tfMPTRequireAuth | tfMPTCanEscrow |
                        tfMPTCanTrade | tfMPTCanTransfer | tfMPTCanClawback,
                    .domainID = domainId1,
                });
 
                // Get the hash for the most recent transaction.
                std::string const txHash{
                    env.tx()->getJson(JsonOptions::none)[jss::hash].asString()};
 
                Json::Value const result = env.rpc("tx", txHash)[jss::result];
                BEAST_EXPECT(
                    result[sfMaximumAmount.getJsonName()] ==
                    "9223372036854775807");
            }
        }
    }
 
    void
    testDestroyValidation(FeatureBitset features)
    {
        testcase("Destroy Validate");
 
        using namespace test::jtx;
        Account const alice("alice");
        Account const bob("bob");
        // MPTokenIssuanceDestroy (preflight)
        {
            Env env{*this, features - featureMPTokensV1};
            MPTTester mptAlice(env, alice);
            auto const id = makeMptID(env.seq(alice), alice);
            mptAlice.destroy({.id = id, .ownerCount = 0, .err = temDISABLED});
 
            env.enableFeature(featureMPTokensV1);
 
            mptAlice.destroy(
                {.id = id, .flags = 0x00000001, .err = temINVALID_FLAG});
        }
 
        // MPTokenIssuanceDestroy (preclaim)
        {
            Env env{*this, features};
            MPTTester mptAlice(env, alice, {.holders = {bob}});
 
            mptAlice.destroy(
                {.id = makeMptID(env.seq(alice), alice),
                 .ownerCount = 0,
                 .err = tecOBJECT_NOT_FOUND});
 
            mptAlice.create({.ownerCount = 1});
 
            // a non-issuer tries to destroy a mptissuance they didn't issue
            mptAlice.destroy({.issuer = bob, .err = tecNO_PERMISSION});
 
            // Make sure that issuer can't delete issuance when it still has
            // outstanding balance
            {
                // bob now holds a mptoken object
                mptAlice.authorize({.account = bob, .holderCount = 1});
 
                // alice pays bob 100 tokens
                mptAlice.pay(alice, bob, 100);
 
                mptAlice.destroy({.err = tecHAS_OBLIGATIONS});
            }
        }
    }
 
    void
    testDestroyEnabled(FeatureBitset features)
    {
        testcase("Destroy Enabled");
 
        using namespace test::jtx;
        Account const alice("alice");
 
        // If the MPT amendment IS enabled, you should be able to destroy
        // MPTokenIssuances
        Env env{*this, features};
        MPTTester mptAlice(env, alice);
 
        mptAlice.create({.ownerCount = 1});
 
        mptAlice.destroy({.ownerCount = 0});
    }
 
    void
    testAuthorizeValidation(FeatureBitset features)
    {
        testcase("Validate authorize transaction");
 
        using namespace test::jtx;
        Account const alice("alice");
        Account const bob("bob");
        Account const cindy("cindy");
        // Validate amendment enable in MPTokenAuthorize (preflight)
        {
            Env env{*this, features - featureMPTokensV1};
            MPTTester mptAlice(env, alice, {.holders = {bob}});
 
            mptAlice.authorize(
                {.account = bob,
                 .id = makeMptID(env.seq(alice), alice),
                 .err = temDISABLED});
        }
 
        // Validate fields in MPTokenAuthorize (preflight)
        {
            Env env{*this, features};
            MPTTester mptAlice(env, alice, {.holders = {bob}});
 
            mptAlice.create({.ownerCount = 1});
 
            // The only valid MPTokenAuthorize flag is tfMPTUnauthorize, which
            // has a value of 1
            mptAlice.authorize(
                {.account = bob, .flags = 0x00000002, .err = temINVALID_FLAG});
 
            mptAlice.authorize(
                {.account = bob, .holder = bob, .err = temMALFORMED});
 
            mptAlice.authorize({.holder = alice, .err = temMALFORMED});
        }
 
        // Try authorizing when MPTokenIssuance doesn't exist in
        // MPTokenAuthorize (preclaim)
        {
            Env env{*this, features};
            MPTTester mptAlice(env, alice, {.holders = {bob}});
            auto const id = makeMptID(env.seq(alice), alice);
 
            mptAlice.authorize(
                {.holder = bob, .id = id, .err = tecOBJECT_NOT_FOUND});
 
            mptAlice.authorize(
                {.account = bob, .id = id, .err = tecOBJECT_NOT_FOUND});
        }
 
        // Test bad scenarios without allowlisting in MPTokenAuthorize
        // (preclaim)
        {
            Env env{*this, features};
            MPTTester mptAlice(env, alice, {.holders = {bob}});
 
            mptAlice.create({.ownerCount = 1});
 
            // bob submits a tx with a holder field
            mptAlice.authorize(
                {.account = bob, .holder = alice, .err = tecNO_PERMISSION});
 
            // alice tries to hold onto her own token
            mptAlice.authorize({.account = alice, .err = tecNO_PERMISSION});
 
            // the mpt does not enable allowlisting
            mptAlice.authorize({.holder = bob, .err = tecNO_AUTH});
 
            // bob now holds a mptoken object
            mptAlice.authorize({.account = bob, .holderCount = 1});
 
            // bob cannot create the mptoken the second time
            mptAlice.authorize({.account = bob, .err = tecDUPLICATE});
 
            // Check that bob cannot delete MPToken when his balance is
            // non-zero
            {
                // alice pays bob 100 tokens
                mptAlice.pay(alice, bob, 100);
 
                // bob tries to delete his MPToken, but fails since he still
                // holds tokens
                mptAlice.authorize(
                    {.account = bob,
                     .flags = tfMPTUnauthorize,
                     .err = tecHAS_OBLIGATIONS});
 
                // bob pays back alice 100 tokens
                mptAlice.pay(bob, alice, 100);
            }
 
            // bob deletes/unauthorizes his MPToken
            mptAlice.authorize({.account = bob, .flags = tfMPTUnauthorize});
 
            // bob receives error when he tries to delete his MPToken that has
            // already been deleted
            mptAlice.authorize(
                {.account = bob,
                 .holderCount = 0,
                 .flags = tfMPTUnauthorize,
                 .err = tecOBJECT_NOT_FOUND});
        }
 
        // Test bad scenarios with allow-listing in MPTokenAuthorize (preclaim)
        {
            Env env{*this, features};
            MPTTester mptAlice(env, alice, {.holders = {bob}});
 
            mptAlice.create({.ownerCount = 1, .flags = tfMPTRequireAuth});
 
            // alice submits a tx without specifying a holder's account
            mptAlice.authorize({.err = tecNO_PERMISSION});
 
            // alice submits a tx to authorize a holder that hasn't created
            // a mptoken yet
            mptAlice.authorize({.holder = bob, .err = tecOBJECT_NOT_FOUND});
 
            // alice specifys a holder acct that doesn't exist
            mptAlice.authorize({.holder = cindy, .err = tecNO_DST});
 
            // bob now holds a mptoken object
            mptAlice.authorize({.account = bob, .holderCount = 1});
 
            // alice tries to unauthorize bob.
            // although tx is successful,
            // but nothing happens because bob hasn't been authorized yet
            mptAlice.authorize({.holder = bob, .flags = tfMPTUnauthorize});
 
            // alice authorizes bob
            // make sure bob's mptoken has set lsfMPTAuthorized
            mptAlice.authorize({.holder = bob});
 
            // alice tries authorizes bob again.
            // tx is successful, but bob is already authorized,
            // so no changes
            mptAlice.authorize({.holder = bob});
 
            // bob deletes his mptoken
            mptAlice.authorize(
                {.account = bob, .holderCount = 0, .flags = tfMPTUnauthorize});
        }
 
        // Test mptoken reserve requirement - first two mpts free (doApply)
        {
            Env env{*this, features};
            auto const acctReserve = env.current()->fees().accountReserve(0);
            auto const incReserve = env.current()->fees().increment;
 
            // 1 drop
            BEAST_EXPECT(incReserve > XRPAmount(1));
            MPTTester mptAlice1(
                env,
                alice,
                {.holders = {bob},
                 .xrpHolders = acctReserve + (incReserve - 1)});
            mptAlice1.create();
 
            MPTTester mptAlice2(env, alice, {.fund = false});
            mptAlice2.create();
 
            MPTTester mptAlice3(env, alice, {.fund = false});
            mptAlice3.create({.ownerCount = 3});
 
            // first mpt for free
            mptAlice1.authorize({.account = bob, .holderCount = 1});
 
            // second mpt free
            mptAlice2.authorize({.account = bob, .holderCount = 2});
 
            mptAlice3.authorize(
                {.account = bob, .err = tecINSUFFICIENT_RESERVE});
 
            env(pay(
                env.master, bob, drops(incReserve + incReserve + incReserve)));
            env.close();
 
            mptAlice3.authorize({.account = bob, .holderCount = 3});
        }
    }
 
    void
    testAuthorizeEnabled(FeatureBitset features)
    {
        testcase("Authorize Enabled");
 
        using namespace test::jtx;
        Account const alice("alice");
        Account const bob("bob");
        // Basic authorization without allowlisting
        {
            Env env{*this, features};
 
            // alice create mptissuance without allowisting
            MPTTester mptAlice(env, alice, {.holders = {bob}});
 
            mptAlice.create({.ownerCount = 1});
 
            // bob creates a mptoken
            mptAlice.authorize({.account = bob, .holderCount = 1});
 
            mptAlice.authorize(
                {.account = bob, .holderCount = 1, .err = tecDUPLICATE});
 
            // bob deletes his mptoken
            mptAlice.authorize(
                {.account = bob, .holderCount = 0, .flags = tfMPTUnauthorize});
        }
 
        // With allowlisting
        {
            Env env{*this, features};
 
            // alice creates a mptokenissuance that requires authorization
            MPTTester mptAlice(env, alice, {.holders = {bob}});
 
            mptAlice.create({.ownerCount = 1, .flags = tfMPTRequireAuth});
 
            // bob creates a mptoken
            mptAlice.authorize({.account = bob, .holderCount = 1});
 
            // alice authorizes bob
            mptAlice.authorize({.account = alice, .holder = bob});
 
            // Unauthorize bob's mptoken
            mptAlice.authorize(
                {.account = alice,
                 .holder = bob,
                 .holderCount = 1,
                 .flags = tfMPTUnauthorize});
 
            mptAlice.authorize(
                {.account = bob, .holderCount = 0, .flags = tfMPTUnauthorize});
        }
 
        // Holder can have dangling MPToken even if issuance has been destroyed.
        // Make sure they can still delete/unauthorize the MPToken
        {
            Env env{*this, features};
            MPTTester mptAlice(env, alice, {.holders = {bob}});
 
            mptAlice.create({.ownerCount = 1});
 
            // bob creates a mptoken
            mptAlice.authorize({.account = bob, .holderCount = 1});
 
            // alice deletes her issuance
            mptAlice.destroy({.ownerCount = 0});
 
            // bob can delete his mptoken even though issuance is no longer
            // existent
            mptAlice.authorize(
                {.account = bob, .holderCount = 0, .flags = tfMPTUnauthorize});
        }
    }
 
    void
    testSetValidation(FeatureBitset features)
    {
        testcase("Validate set transaction");
 
        using namespace test::jtx;
        Account const alice("alice");  // issuer
        Account const bob("bob");      // holder
        Account const cindy("cindy");
        // Validate fields in MPTokenIssuanceSet (preflight)
        {
            Env env{*this, features - featureMPTokensV1};
            MPTTester mptAlice(env, alice, {.holders = {bob}});
 
            mptAlice.set(
                {.account = bob,
                 .id = makeMptID(env.seq(alice), alice),
                 .err = temDISABLED});
 
            env.enableFeature(featureMPTokensV1);
 
            mptAlice.create({.ownerCount = 1, .holderCount = 0});
 
            mptAlice.authorize({.account = bob, .holderCount = 1});
 
            // test invalid flag - only valid flags are tfMPTLock (1) and Unlock
            // (2)
            mptAlice.set(
                {.account = alice,
                 .flags = 0x00000008,
                 .err = temINVALID_FLAG});
 
            if (!features[featureSingleAssetVault] &&
                !features[featureDynamicMPT])
            {
                // test invalid flags - nothing is being changed
                mptAlice.set(
                    {.account = alice,
                     .flags = 0x00000000,
                     .err = tecNO_PERMISSION});
 
                mptAlice.set(
                    {.account = alice,
                     .holder = bob,
                     .flags = 0x00000000,
                     .err = tecNO_PERMISSION});
 
                // cannot set DomainID since SAV is not enabled
                mptAlice.set(
                    {.account = alice,
                     .domainID = uint256(42),
                     .err = temDISABLED});
            }
            else
            {
                // test invalid flags - nothing is being changed
                mptAlice.set(
                    {.account = alice,
                     .flags = 0x00000000,
                     .err = temMALFORMED});
 
                mptAlice.set(
                    {.account = alice,
                     .holder = bob,
                     .flags = 0x00000000,
                     .err = temMALFORMED});
 
                if (!features[featurePermissionedDomains] ||
                    !features[featureSingleAssetVault])
                {
                    // cannot set DomainID since PD is not enabled
                    mptAlice.set(
                        {.account = alice,
                         .domainID = uint256(42),
                         .err = temDISABLED});
                }
                else if (features[featureSingleAssetVault])
                {
                    // cannot set DomainID since Holder is set
                    mptAlice.set(
                        {.account = alice,
                         .holder = bob,
                         .domainID = uint256(42),
                         .err = temMALFORMED});
                }
            }
 
            // set both lock and unlock flags at the same time will fail
            mptAlice.set(
                {.account = alice,
                 .flags = tfMPTLock | tfMPTUnlock,
                 .err = temINVALID_FLAG});
 
            // if the holder is the same as the acct that submitted the tx,
            // tx fails
            mptAlice.set(
                {.account = alice,
                 .holder = alice,
                 .flags = tfMPTLock,
                 .err = temMALFORMED});
        }
 
        // Validate fields in MPTokenIssuanceSet (preclaim)
        // test when a mptokenissuance has disabled locking
        {
            Env env{*this, features};
 
            MPTTester mptAlice(env, alice, {.holders = {bob}});
 
            mptAlice.create({.ownerCount = 1});
 
            // alice tries to lock a mptissuance that has disabled locking
            mptAlice.set(
                {.account = alice,
                 .flags = tfMPTLock,
                 .err = tecNO_PERMISSION});
 
            // alice tries to unlock mptissuance that has disabled locking
            mptAlice.set(
                {.account = alice,
                 .flags = tfMPTUnlock,
                 .err = tecNO_PERMISSION});
 
            // issuer tries to lock a bob's mptoken that has disabled
            // locking
            mptAlice.set(
                {.account = alice,
                 .holder = bob,
                 .flags = tfMPTLock,
                 .err = tecNO_PERMISSION});
 
            // issuer tries to unlock a bob's mptoken that has disabled
            // locking
            mptAlice.set(
                {.account = alice,
                 .holder = bob,
                 .flags = tfMPTUnlock,
                 .err = tecNO_PERMISSION});
        }
 
        // Validate fields in MPTokenIssuanceSet (preclaim)
        // test when mptokenissuance has enabled locking
        {
            Env env{*this, features};
 
            MPTTester mptAlice(env, alice, {.holders = {bob}});
 
            // alice trying to set when the mptissuance doesn't exist yet
            mptAlice.set(
                {.id = makeMptID(env.seq(alice), alice),
                 .flags = tfMPTLock,
                 .err = tecOBJECT_NOT_FOUND});
 
            // create a mptokenissuance with locking
            mptAlice.create({.ownerCount = 1, .flags = tfMPTCanLock});
 
            // a non-issuer acct tries to set the mptissuance
            mptAlice.set(
                {.account = bob, .flags = tfMPTLock, .err = tecNO_PERMISSION});
 
            // trying to set a holder who doesn't have a mptoken
            mptAlice.set(
                {.holder = bob,
                 .flags = tfMPTLock,
                 .err = tecOBJECT_NOT_FOUND});
 
            // trying to set a holder who doesn't exist
            mptAlice.set(
                {.holder = cindy, .flags = tfMPTLock, .err = tecNO_DST});
        }
 
        if (features[featureSingleAssetVault] &&
            features[featurePermissionedDomains])
        {
            // Add permissioned domain
            Account const credIssuer1{"credIssuer1"};
            std::string const credType = "credential";
 
            pdomain::Credentials const credentials1{
                {.issuer = credIssuer1, .credType = credType}};
 
            {
                Env env{*this, features};
 
                MPTTester mptAlice(env, alice);
                mptAlice.create({});
 
                // Trying to set DomainID on a public MPTokenIssuance
                mptAlice.set(
                    {.domainID = uint256(42), .err = tecNO_PERMISSION});
 
                mptAlice.set(
                    {.domainID = beast::zero, .err = tecNO_PERMISSION});
            }
 
            {
                Env env{*this, features};
 
                MPTTester mptAlice(env, alice);
                mptAlice.create({.flags = tfMPTRequireAuth});
 
                // Trying to set non-existing DomainID
                mptAlice.set(
                    {.domainID = uint256(42), .err = tecOBJECT_NOT_FOUND});
 
                // Trying to lock but locking is disabled
                mptAlice.set(
                    {.flags = tfMPTUnlock,
                     .domainID = uint256(42),
                     .err = tecNO_PERMISSION});
 
                mptAlice.set(
                    {.flags = tfMPTUnlock,
                     .domainID = beast::zero,
                     .err = tecNO_PERMISSION});
            }
        }
    }
 
    void
    testSetEnabled(FeatureBitset features)
    {
        testcase("Enabled set transaction");
 
        using namespace test::jtx;
        Account const alice("alice");  // issuer
        Account const bob("bob");      // holder
 
        {
            // Test locking and unlocking
            Env env{*this, features};
 
            MPTTester mptAlice(env, alice, {.holders = {bob}});
 
            // create a mptokenissuance with locking
            mptAlice.create(
                {.ownerCount = 1, .holderCount = 0, .flags = tfMPTCanLock});
 
            mptAlice.authorize({.account = bob, .holderCount = 1});
 
            // locks bob's mptoken
            mptAlice.set({.account = alice, .holder = bob, .flags = tfMPTLock});
 
            // trying to lock bob's mptoken again will still succeed
            // but no changes to the objects
            mptAlice.set({.account = alice, .holder = bob, .flags = tfMPTLock});
 
            // alice locks the mptissuance
            mptAlice.set({.account = alice, .flags = tfMPTLock});
 
            // alice tries to lock up both mptissuance and mptoken again
            // it will not change the flags and both will remain locked.
            mptAlice.set({.account = alice, .flags = tfMPTLock});
            mptAlice.set({.account = alice, .holder = bob, .flags = tfMPTLock});
 
            // alice unlocks bob's mptoken
            mptAlice.set(
                {.account = alice, .holder = bob, .flags = tfMPTUnlock});
 
            // locks up bob's mptoken again
            mptAlice.set({.account = alice, .holder = bob, .flags = tfMPTLock});
            if (!features[featureSingleAssetVault])
            {
                // Delete bobs' mptoken even though it is locked
                mptAlice.authorize({.account = bob, .flags = tfMPTUnauthorize});
 
                mptAlice.set(
                    {.account = alice,
                     .holder = bob,
                     .flags = tfMPTUnlock,
                     .err = tecOBJECT_NOT_FOUND});
 
                return;
            }
 
            // Cannot delete locked MPToken
            mptAlice.authorize(
                {.account = bob,
                 .flags = tfMPTUnauthorize,
                 .err = tecNO_PERMISSION});
 
            // alice unlocks mptissuance
            mptAlice.set({.account = alice, .flags = tfMPTUnlock});
 
            // alice unlocks bob's mptoken
            mptAlice.set(
                {.account = alice, .holder = bob, .flags = tfMPTUnlock});
 
            // alice unlocks mptissuance and bob's mptoken again despite that
            // they are already unlocked. Make sure this will not change the
            // flags
            mptAlice.set(
                {.account = alice, .holder = bob, .flags = tfMPTUnlock});
            mptAlice.set({.account = alice, .flags = tfMPTUnlock});
        }
 
        if (features[featureSingleAssetVault])
        {
            // Add permissioned domain
            std::string const credType = "credential";
 
            // Test setting and resetting domain ID
            Env env{*this, features};
 
            auto const domainId1 = [&]() {
                Account const credIssuer1{"credIssuer1"};
                env.fund(XRP(1000), credIssuer1);
 
                pdomain::Credentials const credentials1{
                    {.issuer = credIssuer1, .credType = credType}};
 
                env(pdomain::setTx(credIssuer1, credentials1));
                return [&]() {
                    auto tx = env.tx()->getJson(JsonOptions::none);
                    return pdomain::getNewDomain(env.meta());
                }();
            }();
 
            auto const domainId2 = [&]() {
                Account const credIssuer2{"credIssuer2"};
                env.fund(XRP(1000), credIssuer2);
 
                pdomain::Credentials const credentials2{
                    {.issuer = credIssuer2, .credType = credType}};
 
                env(pdomain::setTx(credIssuer2, credentials2));
                return [&]() {
                    auto tx = env.tx()->getJson(JsonOptions::none);
                    return pdomain::getNewDomain(env.meta());
                }();
            }();
 
            MPTTester mptAlice(env, alice, {.holders = {bob}});
 
            // create a mptokenissuance with auth.
            mptAlice.create(
                {.ownerCount = 1, .holderCount = 0, .flags = tfMPTRequireAuth});
            BEAST_EXPECT(mptAlice.checkDomainID(std::nullopt));
 
            // reset "domain not set" to "domain not set", i.e. no change
            mptAlice.set({.domainID = beast::zero});
            BEAST_EXPECT(mptAlice.checkDomainID(std::nullopt));
 
            // reset "domain not set" to domain1
            mptAlice.set({.domainID = domainId1});
            BEAST_EXPECT(mptAlice.checkDomainID(domainId1));
 
            // reset domain1 to domain2
            mptAlice.set({.domainID = domainId2});
            BEAST_EXPECT(mptAlice.checkDomainID(domainId2));
 
            // reset domain to "domain not set"
            mptAlice.set({.domainID = beast::zero});
            BEAST_EXPECT(mptAlice.checkDomainID(std::nullopt));
        }
    }
 
    void
    testPayment(FeatureBitset features)
    {
        testcase("Payment");
 
        using namespace test::jtx;
        Account const alice("alice");  // issuer
        Account const bob("bob");      // holder
        Account const carol("carol");  // holder
 
        // preflight validation
 
        // MPT is disabled
        {
            Env env{*this, features - featureMPTokensV1};
            Account const alice("alice");
            Account const bob("bob");
 
            env.fund(XRP(1'000), alice);
            env.fund(XRP(1'000), bob);
            STAmount mpt{MPTIssue{makeMptID(1, alice)}, UINT64_C(100)};
 
            env(pay(alice, bob, mpt), ter(temDISABLED));
        }
 
        // MPT is disabled, unsigned request
        {
            Env env{*this, features - featureMPTokensV1};
            Account const alice("alice");  // issuer
            Account const carol("carol");
            auto const USD = alice["USD"];
 
            env.fund(XRP(1'000), alice);
            env.fund(XRP(1'000), carol);
            STAmount mpt{MPTIssue{makeMptID(1, alice)}, UINT64_C(100)};
 
            Json::Value jv;
            jv[jss::secret] = alice.name();
            jv[jss::tx_json] = pay(alice, carol, mpt);
            jv[jss::tx_json][jss::Fee] = to_string(env.current()->fees().base);
            auto const jrr = env.rpc("json", "submit", to_string(jv));
            BEAST_EXPECT(jrr[jss::result][jss::engine_result] == "temDISABLED");
        }
 
        // Invalid flag
        {
            Env env{*this, features};
 
            MPTTester mptAlice(env, alice, {.holders = {bob}});
 
            mptAlice.create({.ownerCount = 1, .holderCount = 0});
            auto const MPT = mptAlice["MPT"];
 
            mptAlice.authorize({.account = bob});
 
            for (auto flags : {tfNoRippleDirect, tfLimitQuality})
                env(pay(alice, bob, MPT(10)),
                    txflags(flags),
                    ter(temINVALID_FLAG));
        }
 
        // Invalid combination of send, sendMax, deliverMin, paths
        {
            Env env{*this, features};
            Account const alice("alice");
            Account const carol("carol");
 
            MPTTester mptAlice(env, alice, {.holders = {carol}});
 
            mptAlice.create({.ownerCount = 1, .holderCount = 0});
 
            mptAlice.authorize({.account = carol});
 
            // sendMax and DeliverMin are valid XRP amount,
            // but is invalid combination with MPT amount
            auto const MPT = mptAlice["MPT"];
            env(pay(alice, carol, MPT(100)),
                sendmax(XRP(100)),
                ter(temMALFORMED));
            env(pay(alice, carol, MPT(100)),
                delivermin(XRP(100)),
                ter(temBAD_AMOUNT));
            // sendMax MPT is invalid with IOU or XRP
            auto const USD = alice["USD"];
            env(pay(alice, carol, USD(100)),
                sendmax(MPT(100)),
                ter(temMALFORMED));
            env(pay(alice, carol, XRP(100)),
                sendmax(MPT(100)),
                ter(temMALFORMED));
            env(pay(alice, carol, USD(100)),
                delivermin(MPT(100)),
                ter(temBAD_AMOUNT));
            env(pay(alice, carol, XRP(100)),
                delivermin(MPT(100)),
                ter(temBAD_AMOUNT));
            // sendmax and amount are different MPT issue
            test::jtx::MPT const MPT1(
                "MPT", makeMptID(env.seq(alice) + 10, alice));
            env(pay(alice, carol, MPT1(100)),
                sendmax(MPT(100)),
                ter(temMALFORMED));
            // paths is invalid
            env(pay(alice, carol, MPT(100)), path(~USD), ter(temMALFORMED));
        }
 
        // build_path is invalid if MPT
        {
            Env env{*this, features};
            Account const alice("alice");
            Account const carol("carol");
 
            MPTTester mptAlice(env, alice, {.holders = {bob, carol}});
 
            mptAlice.create({.ownerCount = 1, .holderCount = 0});
            auto const MPT = mptAlice["MPT"];
 
            mptAlice.authorize({.account = carol});
 
            Json::Value payment;
            payment[jss::secret] = alice.name();
            payment[jss::tx_json] = pay(alice, carol, MPT(100));
 
            payment[jss::build_path] = true;
            auto jrr = env.rpc("json", "submit", to_string(payment));
            BEAST_EXPECT(jrr[jss::result][jss::error] == "invalidParams");
            BEAST_EXPECT(
                jrr[jss::result][jss::error_message] ==
                "Field 'build_path' not allowed in this context.");
        }
 
        // Can't pay negative amount
        {
            Env env{*this, features};
 
            MPTTester mptAlice(env, alice, {.holders = {bob, carol}});
 
            mptAlice.create({.ownerCount = 1, .holderCount = 0});
            auto const MPT = mptAlice["MPT"];
 
            mptAlice.authorize({.account = bob});
            mptAlice.authorize({.account = carol});
 
            mptAlice.pay(alice, bob, -1, temBAD_AMOUNT);
 
            mptAlice.pay(bob, carol, -1, temBAD_AMOUNT);
 
            mptAlice.pay(bob, alice, -1, temBAD_AMOUNT);
 
            env(pay(alice, bob, MPT(10)), sendmax(MPT(-1)), ter(temBAD_AMOUNT));
        }
 
        // Pay to self
        {
            Env env{*this, features};
 
            MPTTester mptAlice(env, alice, {.holders = {bob}});
 
            mptAlice.create({.ownerCount = 1, .holderCount = 0});
 
            mptAlice.authorize({.account = bob});
 
            mptAlice.pay(bob, bob, 10, temREDUNDANT);
        }
 
        // preclaim validation
 
        // Destination doesn't exist
        {
            Env env{*this, features};
 
            MPTTester mptAlice(env, alice, {.holders = {bob}});
 
            mptAlice.create({.ownerCount = 1, .holderCount = 0});
 
            mptAlice.authorize({.account = bob});
 
            Account const bad{"bad"};
            env.memoize(bad);
 
            mptAlice.pay(bob, bad, 10, tecNO_DST);
        }
 
        // apply validation
 
        // If RequireAuth is enabled, Payment fails if the receiver is not
        // authorized
        {
            Env env{*this, features};
 
            MPTTester mptAlice(env, alice, {.holders = {bob}});
 
            mptAlice.create(
                {.ownerCount = 1,
                 .holderCount = 0,
                 .flags = tfMPTRequireAuth | tfMPTCanTransfer});
 
            mptAlice.authorize({.account = bob});
 
            mptAlice.pay(alice, bob, 100, tecNO_AUTH);
        }
 
        // If RequireAuth is enabled, Payment fails if the sender is not
        // authorized
        {
            Env env{*this, features};
 
            MPTTester mptAlice(env, alice, {.holders = {bob}});
 
            mptAlice.create(
                {.ownerCount = 1,
                 .holderCount = 0,
                 .flags = tfMPTRequireAuth | tfMPTCanTransfer});
 
            // bob creates an empty MPToken
            mptAlice.authorize({.account = bob});
 
            // alice authorizes bob to hold funds
            mptAlice.authorize({.account = alice, .holder = bob});
 
            // alice sends 100 MPT to bob
            mptAlice.pay(alice, bob, 100);
 
            // alice UNAUTHORIZES bob
            mptAlice.authorize(
                {.account = alice, .holder = bob, .flags = tfMPTUnauthorize});
 
            // bob fails to send back to alice because he is no longer
            // authorize to move his funds!
            mptAlice.pay(bob, alice, 100, tecNO_AUTH);
        }
 
        if (features[featureSingleAssetVault] &&
            features[featurePermissionedDomains])
        {
            // If RequireAuth is enabled and domain is a match, payment succeeds
            {
                Env env{*this, features};
                std::string const credType = "credential";
                Account const credIssuer1{"credIssuer1"};
                env.fund(XRP(1000), credIssuer1, bob);
 
                auto const domainId1 = [&]() {
                    pdomain::Credentials const credentials1{
                        {.issuer = credIssuer1, .credType = credType}};
 
                    env(pdomain::setTx(credIssuer1, credentials1));
                    return [&]() {
                        auto tx = env.tx()->getJson(JsonOptions::none);
                        return pdomain::getNewDomain(env.meta());
                    }();
                }();
                // bob is authorized via domain
                env(credentials::create(bob, credIssuer1, credType));
                env(credentials::accept(bob, credIssuer1, credType));
                env.close();
 
                MPTTester mptAlice(env, alice, {});
                env.close();
 
                mptAlice.create({
                    .ownerCount = 1,
                    .holderCount = 0,
                    .flags = tfMPTRequireAuth | tfMPTCanTransfer,
                    .domainID = domainId1,
                });
 
                mptAlice.authorize({.account = bob});
                env.close();
 
                // bob is authorized via domain
                mptAlice.pay(alice, bob, 100);
                mptAlice.set({.domainID = beast::zero});
 
                // bob is no longer authorized
                mptAlice.pay(alice, bob, 100, tecNO_AUTH);
            }
 
            {
                Env env{*this, features};
                std::string const credType = "credential";
                Account const credIssuer1{"credIssuer1"};
                env.fund(XRP(1000), credIssuer1, bob);
 
                auto const domainId1 = [&]() {
                    pdomain::Credentials const credentials1{
                        {.issuer = credIssuer1, .credType = credType}};
 
                    env(pdomain::setTx(credIssuer1, credentials1));
                    return [&]() {
                        auto tx = env.tx()->getJson(JsonOptions::none);
                        return pdomain::getNewDomain(env.meta());
                    }();
                }();
                // bob is authorized via domain
                env(credentials::create(bob, credIssuer1, credType));
                env(credentials::accept(bob, credIssuer1, credType));
                env.close();
 
                MPTTester mptAlice(env, alice, {});
                env.close();
 
                mptAlice.create({
                    .ownerCount = 1,
                    .holderCount = 0,
                    .flags = tfMPTRequireAuth | tfMPTCanTransfer,
                    .domainID = domainId1,
                });
 
                // bob creates an empty MPToken
                mptAlice.authorize({.account = bob});
 
                // alice authorizes bob to hold funds
                mptAlice.authorize({.account = alice, .holder = bob});
 
                // alice sends 100 MPT to bob
                mptAlice.pay(alice, bob, 100);
 
                // alice UNAUTHORIZES bob
                mptAlice.authorize(
                    {.account = alice,
                     .holder = bob,
                     .flags = tfMPTUnauthorize});
 
                // bob is still authorized, via domain
                mptAlice.pay(bob, alice, 10);
 
                mptAlice.set({.domainID = beast::zero});
 
                // bob fails to send back to alice because he is no longer
                // authorize to move his funds!
                mptAlice.pay(bob, alice, 10, tecNO_AUTH);
            }
 
            {
                Env env{*this, features};
                std::string const credType = "credential";
                // credIssuer1 is the owner of domainId1 and a credential issuer
                Account const credIssuer1{"credIssuer1"};
                // credIssuer2 is the owner of domainId2 and a credential issuer
                // Note, domainId2 also lists credentials issued by credIssuer1
                Account const credIssuer2{"credIssuer2"};
                env.fund(XRP(1000), credIssuer1, credIssuer2, bob, carol);
 
                auto const domainId1 = [&]() {
                    pdomain::Credentials const credentials{
                        {.issuer = credIssuer1, .credType = credType}};
 
                    env(pdomain::setTx(credIssuer1, credentials));
                    return [&]() {
                        auto tx = env.tx()->getJson(JsonOptions::none);
                        return pdomain::getNewDomain(env.meta());
                    }();
                }();
 
                auto const domainId2 = [&]() {
                    pdomain::Credentials const credentials{
                        {.issuer = credIssuer1, .credType = credType},
                        {.issuer = credIssuer2, .credType = credType}};
 
                    env(pdomain::setTx(credIssuer2, credentials));
                    return [&]() {
                        auto tx = env.tx()->getJson(JsonOptions::none);
                        return pdomain::getNewDomain(env.meta());
                    }();
                }();
 
                // bob is authorized via credIssuer1 which is recognized by both
                // domainId1 and domainId2
                env(credentials::create(bob, credIssuer1, credType));
                env(credentials::accept(bob, credIssuer1, credType));
                env.close();
 
                // carol is authorized via credIssuer2, only recognized by
                // domainId2
                env(credentials::create(carol, credIssuer2, credType));
                env(credentials::accept(carol, credIssuer2, credType));
                env.close();
 
                MPTTester mptAlice(env, alice, {});
                env.close();
 
                mptAlice.create({
                    .ownerCount = 1,
                    .holderCount = 0,
                    .flags = tfMPTRequireAuth | tfMPTCanTransfer,
                    .domainID = domainId1,
                });
 
                // bob and carol create an empty MPToken
                mptAlice.authorize({.account = bob});
                mptAlice.authorize({.account = carol});
                env.close();
 
                // alice sends 50 MPT to bob but cannot send to carol
                mptAlice.pay(alice, bob, 50);
                mptAlice.pay(alice, carol, 50, tecNO_AUTH);
                env.close();
 
                // bob cannot send to carol because they are not on the same
                // domain (since credIssuer2 is not recognized by domainId1)
                mptAlice.pay(bob, carol, 10, tecNO_AUTH);
                env.close();
 
                // alice updates domainID to domainId2 which recognizes both
                // credIssuer1 and credIssuer2
                mptAlice.set({.domainID = domainId2});
                // alice can now send to carol
                mptAlice.pay(alice, carol, 10);
                env.close();
 
                // bob can now send to carol because both are in the same
                // domain
                mptAlice.pay(bob, carol, 10);
                env.close();
 
                // bob loses his authorization and can no longer send MPT
                env(credentials::deleteCred(
                    credIssuer1, bob, credIssuer1, credType));
                env.close();
 
                mptAlice.pay(bob, carol, 10, tecNO_AUTH);
                mptAlice.pay(bob, alice, 10, tecNO_AUTH);
            }
        }
 
        // Non-issuer cannot send to each other if MPTCanTransfer isn't set
        {
            Env env(*this, features);
            Account const alice{"alice"};
            Account const bob{"bob"};
            Account const cindy{"cindy"};
 
            MPTTester mptAlice(env, alice, {.holders = {bob, cindy}});
 
            // alice creates issuance without MPTCanTransfer
            mptAlice.create({.ownerCount = 1, .holderCount = 0});
 
            // bob creates a MPToken
            mptAlice.authorize({.account = bob});
 
            // cindy creates a MPToken
            mptAlice.authorize({.account = cindy});
 
            // alice pays bob 100 tokens
            mptAlice.pay(alice, bob, 100);
 
            // bob tries to send cindy 10 tokens, but fails because canTransfer
            // is off
            mptAlice.pay(bob, cindy, 10, tecNO_AUTH);
 
            // bob can send back to alice(issuer) just fine
            mptAlice.pay(bob, alice, 10);
        }
 
        // Holder is not authorized
        {
            Env env{*this, features};
 
            MPTTester mptAlice(env, alice, {.holders = {bob, carol}});
 
            mptAlice.create(
                {.ownerCount = 1, .holderCount = 0, .flags = tfMPTCanTransfer});
 
            // issuer to holder
            mptAlice.pay(alice, bob, 100, tecNO_AUTH);
 
            // holder to issuer
            mptAlice.pay(bob, alice, 100, tecNO_AUTH);
 
            // holder to holder
            mptAlice.pay(bob, carol, 50, tecNO_AUTH);
        }
 
        // Payer doesn't have enough funds
        {
            Env env{*this, features};
 
            MPTTester mptAlice(env, alice, {.holders = {bob, carol}});
 
            mptAlice.create({.ownerCount = 1, .flags = tfMPTCanTransfer});
 
            mptAlice.authorize({.account = bob});
            mptAlice.authorize({.account = carol});
 
            mptAlice.pay(alice, bob, 100);
 
            // Pay to another holder
            mptAlice.pay(bob, carol, 101, tecPATH_PARTIAL);
 
            // Pay to the issuer
            mptAlice.pay(bob, alice, 101, tecPATH_PARTIAL);
        }
 
        // MPT is locked
        {
            Env env{*this, features};
 
            MPTTester mptAlice(env, alice, {.holders = {bob, carol}});
 
            mptAlice.create(
                {.ownerCount = 1, .flags = tfMPTCanLock | tfMPTCanTransfer});
 
            mptAlice.authorize({.account = bob});
            mptAlice.authorize({.account = carol});
 
            mptAlice.pay(alice, bob, 100);
            mptAlice.pay(alice, carol, 100);
 
            // Global lock
            mptAlice.set({.account = alice, .flags = tfMPTLock});
            // Can't send between holders
            mptAlice.pay(bob, carol, 1, tecLOCKED);
            mptAlice.pay(carol, bob, 2, tecLOCKED);
            // Issuer can send
            mptAlice.pay(alice, bob, 3);
            // Holder can send back to issuer
            mptAlice.pay(bob, alice, 4);
 
            // Global unlock
            mptAlice.set({.account = alice, .flags = tfMPTUnlock});
            // Individual lock
            mptAlice.set({.account = alice, .holder = bob, .flags = tfMPTLock});
            // Can't send between holders
            mptAlice.pay(bob, carol, 5, tecLOCKED);
            mptAlice.pay(carol, bob, 6, tecLOCKED);
            // Issuer can send
            mptAlice.pay(alice, bob, 7);
            // Holder can send back to issuer
            mptAlice.pay(bob, alice, 8);
        }
 
        // Transfer fee
        {
            Env env{*this, features};
 
            MPTTester mptAlice(env, alice, {.holders = {bob, carol}});
 
            // Transfer fee is 10%
            mptAlice.create(
                {.transferFee = 10'000,
                 .ownerCount = 1,
                 .holderCount = 0,
                 .flags = tfMPTCanTransfer});
 
            // Holders create MPToken
            mptAlice.authorize({.account = bob});
            mptAlice.authorize({.account = carol});
 
            // Payment between the issuer and the holder, no transfer fee.
            mptAlice.pay(alice, bob, 2'000);
 
            // Payment between the holder and the issuer, no transfer fee.
            mptAlice.pay(bob, alice, 1'000);
            BEAST_EXPECT(mptAlice.checkMPTokenAmount(bob, 1'000));
 
            // Payment between the holders. The sender doesn't have
            // enough funds to cover the transfer fee.
            mptAlice.pay(bob, carol, 1'000, tecPATH_PARTIAL);
 
            // Payment between the holders. The sender has enough funds
            // but SendMax is not included.
            mptAlice.pay(bob, carol, 100, tecPATH_PARTIAL);
 
            auto const MPT = mptAlice["MPT"];
            // SendMax doesn't cover the fee
            env(pay(bob, carol, MPT(100)),
                sendmax(MPT(109)),
                ter(tecPATH_PARTIAL));
 
            // Payment succeeds if sufficient SendMax is included.
            // 100 to carol, 10 to issuer
            env(pay(bob, carol, MPT(100)), sendmax(MPT(110)));
            // 100 to carol, 10 to issuer
            env(pay(bob, carol, MPT(100)), sendmax(MPT(115)));
            BEAST_EXPECT(mptAlice.checkMPTokenAmount(bob, 780));
            BEAST_EXPECT(mptAlice.checkMPTokenAmount(carol, 200));
            // Payment succeeds if partial payment even if
            // SendMax is less than deliver amount
            env(pay(bob, carol, MPT(100)),
                sendmax(MPT(90)),
                txflags(tfPartialPayment));
            // 82 to carol, 8 to issuer (90 / 1.1 ~ 81.81 (rounded to nearest) =
            // 82)
            BEAST_EXPECT(mptAlice.checkMPTokenAmount(bob, 690));
            BEAST_EXPECT(mptAlice.checkMPTokenAmount(carol, 282));
        }
 
        // Insufficient SendMax with no transfer fee
        {
            Env env{*this, features};
 
            MPTTester mptAlice(env, alice, {.holders = {bob, carol}});
 
            mptAlice.create(
                {.ownerCount = 1, .holderCount = 0, .flags = tfMPTCanTransfer});
 
            // Holders create MPToken
            mptAlice.authorize({.account = bob});
            mptAlice.authorize({.account = carol});
            mptAlice.pay(alice, bob, 1'000);
 
            auto const MPT = mptAlice["MPT"];
            // SendMax is less than the amount
            env(pay(bob, carol, MPT(100)),
                sendmax(MPT(99)),
                ter(tecPATH_PARTIAL));
            env(pay(bob, alice, MPT(100)),
                sendmax(MPT(99)),
                ter(tecPATH_PARTIAL));
 
            // Payment succeeds if sufficient SendMax is included.
            env(pay(bob, carol, MPT(100)), sendmax(MPT(100)));
            BEAST_EXPECT(mptAlice.checkMPTokenAmount(carol, 100));
            // Payment succeeds if partial payment
            env(pay(bob, carol, MPT(100)),
                sendmax(MPT(99)),
                txflags(tfPartialPayment));
            BEAST_EXPECT(mptAlice.checkMPTokenAmount(carol, 199));
        }
 
        // DeliverMin
        {
            Env env{*this, features};
 
            MPTTester mptAlice(env, alice, {.holders = {bob, carol}});
 
            mptAlice.create(
                {.ownerCount = 1, .holderCount = 0, .flags = tfMPTCanTransfer});
 
            // Holders create MPToken
            mptAlice.authorize({.account = bob});
            mptAlice.authorize({.account = carol});
            mptAlice.pay(alice, bob, 1'000);
 
            auto const MPT = mptAlice["MPT"];
            // Fails even with the partial payment because
            // deliver amount < deliverMin
            env(pay(bob, alice, MPT(100)),
                sendmax(MPT(99)),
                delivermin(MPT(100)),
                txflags(tfPartialPayment),
                ter(tecPATH_PARTIAL));
            // Payment succeeds if deliver amount >= deliverMin
            env(pay(bob, alice, MPT(100)),
                sendmax(MPT(99)),
                delivermin(MPT(99)),
                txflags(tfPartialPayment));
        }
 
        // Issuer fails trying to send more than the maximum amount allowed
        {
            Env env{*this, features};
 
            MPTTester mptAlice(env, alice, {.holders = {bob}});
 
            mptAlice.create(
                {.maxAmt = 100,
                 .ownerCount = 1,
                 .holderCount = 0,
                 .flags = tfMPTCanTransfer});
 
            mptAlice.authorize({.account = bob});
 
            // issuer sends holder the max amount allowed
            mptAlice.pay(alice, bob, 100);
 
            // issuer tries to exceed max amount
            mptAlice.pay(alice, bob, 1, tecPATH_PARTIAL);
        }
 
        // Issuer fails trying to send more than the default maximum
        // amount allowed
        {
            Env env{*this, features};
 
            MPTTester mptAlice(env, alice, {.holders = {bob}});
 
            mptAlice.create({.ownerCount = 1, .holderCount = 0});
 
            mptAlice.authorize({.account = bob});
 
            // issuer sends holder the default max amount allowed
            mptAlice.pay(alice, bob, maxMPTokenAmount);
 
            // issuer tries to exceed max amount
            mptAlice.pay(alice, bob, 1, tecPATH_PARTIAL);
        }
 
        // Pay more than max amount fails in the json parser before
        // transactor is called
        {
            Env env{*this, features};
            env.fund(XRP(1'000), alice, bob);
            STAmount mpt{MPTIssue{makeMptID(1, alice)}, UINT64_C(100)};
            Json::Value jv;
            jv[jss::secret] = alice.name();
            jv[jss::tx_json] = pay(alice, bob, mpt);
            jv[jss::tx_json][jss::Amount][jss::value] =
                to_string(maxMPTokenAmount + 1);
            auto const jrr = env.rpc("json", "submit", to_string(jv));
            BEAST_EXPECT(jrr[jss::result][jss::error] == "invalidParams");
        }
 
        // Pay maximum amount with the transfer fee, SendMax, and
        // partial payment
        {
            Env env{*this, features};
 
            MPTTester mptAlice(env, alice, {.holders = {bob, carol}});
 
            mptAlice.create(
                {.maxAmt = 10'000,
                 .transferFee = 100,
                 .ownerCount = 1,
                 .holderCount = 0,
                 .flags = tfMPTCanTransfer});
            auto const MPT = mptAlice["MPT"];
 
            mptAlice.authorize({.account = bob});
            mptAlice.authorize({.account = carol});
 
            // issuer sends holder the max amount allowed
            mptAlice.pay(alice, bob, 10'000);
 
            // payment between the holders
            env(pay(bob, carol, MPT(10'000)),
                sendmax(MPT(10'000)),
                txflags(tfPartialPayment));
            // Verify the metadata
            auto const meta = env.meta()->getJson(
                JsonOptions::none)[sfAffectedNodes.fieldName];
            // Issuer got 10 in the transfer fees
            BEAST_EXPECT(
                meta[0u][sfModifiedNode.fieldName][sfFinalFields.fieldName]
                    [sfOutstandingAmount.fieldName] == "9990");
            // Destination account got 9'990
            BEAST_EXPECT(
                meta[1u][sfModifiedNode.fieldName][sfFinalFields.fieldName]
                    [sfMPTAmount.fieldName] == "9990");
            // Source account spent 10'000
            BEAST_EXPECT(
                meta[2u][sfModifiedNode.fieldName][sfPreviousFields.fieldName]
                    [sfMPTAmount.fieldName] == "10000");
            BEAST_EXPECT(
                !meta[2u][sfModifiedNode.fieldName][sfFinalFields.fieldName]
                     .isMember(sfMPTAmount.fieldName));
 
            // payment between the holders fails without
            // partial payment
            env(pay(bob, carol, MPT(10'000)),
                sendmax(MPT(10'000)),
                ter(tecPATH_PARTIAL));
        }
 
        // Pay maximum allowed amount
        {
            Env env{*this, features};
 
            MPTTester mptAlice(env, alice, {.holders = {bob, carol}});
 
            mptAlice.create(
                {.maxAmt = maxMPTokenAmount,
                 .ownerCount = 1,
                 .holderCount = 0,
                 .flags = tfMPTCanTransfer});
            auto const MPT = mptAlice["MPT"];
 
            mptAlice.authorize({.account = bob});
            mptAlice.authorize({.account = carol});
 
            // issuer sends holder the max amount allowed
            mptAlice.pay(alice, bob, maxMPTokenAmount);
            BEAST_EXPECT(
                mptAlice.checkMPTokenOutstandingAmount(maxMPTokenAmount));
 
            // payment between the holders
            mptAlice.pay(bob, carol, maxMPTokenAmount);
            BEAST_EXPECT(
                mptAlice.checkMPTokenOutstandingAmount(maxMPTokenAmount));
            // holder pays back to the issuer
            mptAlice.pay(carol, alice, maxMPTokenAmount);
            BEAST_EXPECT(mptAlice.checkMPTokenOutstandingAmount(0));
        }
 
        // Issuer fails trying to send fund after issuance was destroyed
        {
            Env env{*this, features};
 
            MPTTester mptAlice(env, alice, {.holders = {bob}});
 
            mptAlice.create({.ownerCount = 1, .holderCount = 0});
 
            mptAlice.authorize({.account = bob});
 
            // alice destroys issuance
            mptAlice.destroy({.ownerCount = 0});
 
            // alice tries to send bob fund after issuance is destroyed, should
            // fail.
            mptAlice.pay(alice, bob, 100, tecOBJECT_NOT_FOUND);
        }
 
        // Non-existent issuance
        {
            Env env{*this, features};
 
            env.fund(XRP(1'000), alice, bob);
 
            STAmount const mpt{MPTID{0}, 100};
            env(pay(alice, bob, mpt), ter(tecOBJECT_NOT_FOUND));
        }
 
        // Issuer fails trying to send to an account, which doesn't own MPT for
        // an issuance that was destroyed
        {
            Env env{*this, features};
 
            MPTTester mptAlice(env, alice, {.holders = {bob}});
 
            mptAlice.create({.ownerCount = 1, .holderCount = 0});
 
            // alice destroys issuance
            mptAlice.destroy({.ownerCount = 0});
 
            // alice tries to send bob who doesn't own the MPT after issuance is
            // destroyed, it should fail
            mptAlice.pay(alice, bob, 100, tecOBJECT_NOT_FOUND);
        }
 
        // Issuers issues maximum amount of MPT to a holder, the holder should
        // be able to transfer the max amount to someone else
        {
            Env env{*this, features};
            Account const alice("alice");
            Account const carol("bob");
            Account const bob("carol");
 
            MPTTester mptAlice(env, alice, {.holders = {bob, carol}});
 
            mptAlice.create(
                {.maxAmt = 100, .ownerCount = 1, .flags = tfMPTCanTransfer});
 
            mptAlice.authorize({.account = bob});
            mptAlice.authorize({.account = carol});
 
            mptAlice.pay(alice, bob, 100);
 
            // transfer max amount to another holder
            mptAlice.pay(bob, carol, 100);
        }
 
        // Simple payment
        {
            Env env{*this, features};
 
            MPTTester mptAlice(env, alice, {.holders = {bob, carol}});
 
            mptAlice.create(
                {.ownerCount = 1, .holderCount = 0, .flags = tfMPTCanTransfer});
 
            mptAlice.authorize({.account = bob});
            mptAlice.authorize({.account = carol});
 
            // issuer to holder
            mptAlice.pay(alice, bob, 100);
 
            // holder to issuer
            mptAlice.pay(bob, alice, 100);
 
            // holder to holder
            mptAlice.pay(alice, bob, 100);
            mptAlice.pay(bob, carol, 50);
        }
    }
 
    void
    testDepositPreauth(FeatureBitset features)
    {
        using namespace test::jtx;
        Account const alice("alice");  // issuer
        Account const bob("bob");      // holder
        Account const diana("diana");
        Account const dpIssuer("dpIssuer");  // holder
 
        char const credType[] = "abcde";
 
        if (features[featureCredentials])
        {
            testcase("DepositPreauth");
 
            Env env(*this, features);
 
            env.fund(XRP(50000), diana, dpIssuer);
            env.close();
 
            MPTTester mptAlice(env, alice, {.holders = {bob}});
            mptAlice.create(
                {.ownerCount = 1,
                 .holderCount = 0,
                 .flags = tfMPTRequireAuth | tfMPTCanTransfer});
 
            env(pay(diana, bob, XRP(500)));
            env.close();
 
            // bob creates an empty MPToken
            mptAlice.authorize({.account = bob});
            // alice authorizes bob to hold funds
            mptAlice.authorize({.account = alice, .holder = bob});
 
            // Bob require preauthorization
            env(fset(bob, asfDepositAuth));
            env.close();
 
            // alice try to send 100 MPT to bob, not authorized
            mptAlice.pay(alice, bob, 100, tecNO_PERMISSION);
            env.close();
 
            // Bob authorize alice
            env(deposit::auth(bob, alice));
            env.close();
 
            // alice sends 100 MPT to bob
            mptAlice.pay(alice, bob, 100);
            env.close();
 
            // Create credentials
            env(credentials::create(alice, dpIssuer, credType));
            env.close();
            env(credentials::accept(alice, dpIssuer, credType));
            env.close();
            auto const jv =
                credentials::ledgerEntry(env, alice, dpIssuer, credType);
            std::string const credIdx = jv[jss::result][jss::index].asString();
 
            // alice sends 100 MPT to bob with credentials which aren't required
            mptAlice.pay(alice, bob, 100, tesSUCCESS, {{credIdx}});
            env.close();
 
            // Bob revoke authorization
            env(deposit::unauth(bob, alice));
            env.close();
 
            // alice try to send 100 MPT to bob, not authorized
            mptAlice.pay(alice, bob, 100, tecNO_PERMISSION);
            env.close();
 
            // alice sends 100 MPT to bob with credentials, not authorized
            mptAlice.pay(alice, bob, 100, tecNO_PERMISSION, {{credIdx}});
            env.close();
 
            // Bob authorize credentials
            env(deposit::authCredentials(bob, {{dpIssuer, credType}}));
            env.close();
 
            // alice try to send 100 MPT to bob, not authorized
            mptAlice.pay(alice, bob, 100, tecNO_PERMISSION);
            env.close();
 
            // alice sends 100 MPT to bob with credentials
            mptAlice.pay(alice, bob, 100, tesSUCCESS, {{credIdx}});
            env.close();
        }
 
        testcase("DepositPreauth disabled featureCredentials");
        {
            Env env(*this, testable_amendments() - featureCredentials);
 
            std::string const credIdx =
                "D007AE4B6E1274B4AF872588267B810C2F82716726351D1C7D38D3E5499FC6"
                "E2";
 
            env.fund(XRP(50000), diana, dpIssuer);
            env.close();
 
            MPTTester mptAlice(env, alice, {.holders = {bob}});
            mptAlice.create(
                {.ownerCount = 1,
                 .holderCount = 0,
                 .flags = tfMPTRequireAuth | tfMPTCanTransfer});
 
            env(pay(diana, bob, XRP(500)));
            env.close();
 
            // bob creates an empty MPToken
            mptAlice.authorize({.account = bob});
            // alice authorizes bob to hold funds
            mptAlice.authorize({.account = alice, .holder = bob});
 
            // Bob require preauthorization
            env(fset(bob, asfDepositAuth));
            env.close();
 
            // alice try to send 100 MPT to bob, not authorized
            mptAlice.pay(alice, bob, 100, tecNO_PERMISSION);
            env.close();
 
            // alice try to send 100 MPT to bob with credentials, amendment
            // disabled
            mptAlice.pay(alice, bob, 100, temDISABLED, {{credIdx}});
            env.close();
 
            // Bob authorize alice
            env(deposit::auth(bob, alice));
            env.close();
 
            // alice sends 100 MPT to bob
            mptAlice.pay(alice, bob, 100);
            env.close();
 
            // alice sends 100 MPT to bob with credentials, amendment disabled
            mptAlice.pay(alice, bob, 100, temDISABLED, {{credIdx}});
            env.close();
 
            // Bob revoke authorization
            env(deposit::unauth(bob, alice));
            env.close();
 
            // alice try to send 100 MPT to bob
            mptAlice.pay(alice, bob, 100, tecNO_PERMISSION);
            env.close();
 
            // alice sends 100 MPT to bob with credentials, amendment disabled
            mptAlice.pay(alice, bob, 100, temDISABLED, {{credIdx}});
            env.close();
        }
    }
 
    void
    testMPTInvalidInTx(FeatureBitset features)
    {
        testcase("MPT Issue Invalid in Transaction");
        using namespace test::jtx;
 
        // Validate that every transaction with an amount/issue field,
        // which doesn't support MPT, fails.
 
        // keyed by transaction + amount/issue field
        std::set<std::string> txWithAmounts;
        for (auto const& format : TxFormats::getInstance())
        {
            for (auto const& e : format.getSOTemplate())
            {
                // Transaction has amount/issue fields.
                // Exclude pseudo-transaction SetFee. Don't consider
                // the Fee field since it's included in every transaction.
                if (e.supportMPT() == soeMPTNotSupported &&
                    e.sField().getName() != jss::Fee &&
                    format.getName() != jss::SetFee)
                {
                    txWithAmounts.insert(
                        format.getName() + e.sField().fieldName);
                    break;
                }
            }
        }
 
        Account const alice("alice");
        auto const USD = alice["USD"];
        Account const carol("carol");
        MPTIssue issue(makeMptID(1, alice));
        STAmount mpt{issue, UINT64_C(100)};
        auto const jvb = bridge(alice, USD, alice, USD);
        for (auto const& feature : {features, features - featureMPTokensV1})
        {
            Env env{*this, feature};
            env.fund(XRP(1'000), alice);
            env.fund(XRP(1'000), carol);
            auto test = [&](Json::Value const& jv,
                            std::string const& mptField) {
                txWithAmounts.erase(
                    jv[jss::TransactionType].asString() + mptField);
 
                // tx is signed
                auto jtx = env.jt(jv);
                Serializer s;
                jtx.stx->add(s);
                auto jrr = env.rpc("submit", strHex(s.slice()));
                BEAST_EXPECT(
                    jrr[jss::result][jss::error] == "invalidTransaction");
 
                // tx is unsigned
                Json::Value jv1;
                jv1[jss::secret] = alice.name();
                jv1[jss::tx_json] = jv;
                jrr = env.rpc("json", "submit", to_string(jv1));
                BEAST_EXPECT(jrr[jss::result][jss::error] == "invalidParams");
 
                jrr = env.rpc("json", "sign", to_string(jv1));
                BEAST_EXPECT(jrr[jss::result][jss::error] == "invalidParams");
            };
            auto toSFieldRef = [](SField const& field) {
                return std::ref(field);
            };
            auto setMPTFields = [&](SField const& field,
                                    Json::Value& jv,
                                    bool withAmount = true) {
                jv[jss::Asset] = to_json(xrpIssue());
                jv[jss::Asset2] = to_json(USD.issue());
                if (withAmount)
                    jv[field.fieldName] =
                        USD(10).value().getJson(JsonOptions::none);
                if (field == sfAsset)
                    jv[jss::Asset] = to_json(mpt.get<MPTIssue>());
                else if (field == sfAsset2)
                    jv[jss::Asset2] = to_json(mpt.get<MPTIssue>());
                else
                    jv[field.fieldName] = mpt.getJson(JsonOptions::none);
            };
            // All transactions with sfAmount, which don't support MPT.
            // Transactions with amount fields, which can't be MPT.
            // Transactions with issue fields, which can't be MPT.
 
            // AMMCreate
            auto ammCreate = [&](SField const& field) {
                Json::Value jv;
                jv[jss::TransactionType] = jss::AMMCreate;
                jv[jss::Account] = alice.human();
                jv[jss::Amount] = (field.fieldName == sfAmount.fieldName)
                    ? mpt.getJson(JsonOptions::none)
                    : "100000000";
                jv[jss::Amount2] = (field.fieldName == sfAmount2.fieldName)
                    ? mpt.getJson(JsonOptions::none)
                    : "100000000";
                jv[jss::TradingFee] = 0;
                test(jv, field.fieldName);
            };
            ammCreate(sfAmount);
            ammCreate(sfAmount2);
            // AMMDeposit
            auto ammDeposit = [&](SField const& field) {
                Json::Value jv;
                jv[jss::TransactionType] = jss::AMMDeposit;
                jv[jss::Account] = alice.human();
                jv[jss::Flags] = tfSingleAsset;
                setMPTFields(field, jv);
                test(jv, field.fieldName);
            };
            for (SField const& field :
                 {toSFieldRef(sfAmount),
                  toSFieldRef(sfAmount2),
                  toSFieldRef(sfEPrice),
                  toSFieldRef(sfLPTokenOut),
                  toSFieldRef(sfAsset),
                  toSFieldRef(sfAsset2)})
                ammDeposit(field);
            // AMMWithdraw
            auto ammWithdraw = [&](SField const& field) {
                Json::Value jv;
                jv[jss::TransactionType] = jss::AMMWithdraw;
                jv[jss::Account] = alice.human();
                jv[jss::Flags] = tfSingleAsset;
                setMPTFields(field, jv);
                test(jv, field.fieldName);
            };
            ammWithdraw(sfAmount);
            for (SField const& field :
                 {toSFieldRef(sfAmount2),
                  toSFieldRef(sfEPrice),
                  toSFieldRef(sfLPTokenIn),
                  toSFieldRef(sfAsset),
                  toSFieldRef(sfAsset2)})
                ammWithdraw(field);
            // AMMBid
            auto ammBid = [&](SField const& field) {
                Json::Value jv;
                jv[jss::TransactionType] = jss::AMMBid;
                jv[jss::Account] = alice.human();
                setMPTFields(field, jv);
                test(jv, field.fieldName);
            };
            for (SField const& field :
                 {toSFieldRef(sfBidMin),
                  toSFieldRef(sfBidMax),
                  toSFieldRef(sfAsset),
                  toSFieldRef(sfAsset2)})
                ammBid(field);
            // AMMClawback
            auto ammClawback = [&](SField const& field) {
                Json::Value jv;
                jv[jss::TransactionType] = jss::AMMClawback;
                jv[jss::Account] = alice.human();
                jv[jss::Holder] = carol.human();
                setMPTFields(field, jv);
                test(jv, field.fieldName);
            };
            for (SField const& field :
                 {toSFieldRef(sfAmount),
                  toSFieldRef(sfAsset),
                  toSFieldRef(sfAsset2)})
                ammClawback(field);
            // AMMDelete
            auto ammDelete = [&](SField const& field) {
                Json::Value jv;
                jv[jss::TransactionType] = jss::AMMDelete;
                jv[jss::Account] = alice.human();
                setMPTFields(field, jv, false);
                test(jv, field.fieldName);
            };
            ammDelete(sfAsset);
            ammDelete(sfAsset2);
            // AMMVote
            auto ammVote = [&](SField const& field) {
                Json::Value jv;
                jv[jss::TransactionType] = jss::AMMVote;
                jv[jss::Account] = alice.human();
                jv[jss::TradingFee] = 100;
                setMPTFields(field, jv, false);
                test(jv, field.fieldName);
            };
            ammVote(sfAsset);
            ammVote(sfAsset2);
            // CheckCash
            auto checkCash = [&](SField const& field) {
                Json::Value jv;
                jv[jss::TransactionType] = jss::CheckCash;
                jv[jss::Account] = alice.human();
                jv[sfCheckID.fieldName] = to_string(uint256{1});
                jv[field.fieldName] = mpt.getJson(JsonOptions::none);
                test(jv, field.fieldName);
            };
            checkCash(sfAmount);
            checkCash(sfDeliverMin);
            // CheckCreate
            {
                Json::Value jv;
                jv[jss::TransactionType] = jss::CheckCreate;
                jv[jss::Account] = alice.human();
                jv[jss::Destination] = carol.human();
                jv[jss::SendMax] = mpt.getJson(JsonOptions::none);
                test(jv, jss::SendMax.c_str());
            }
            // OfferCreate
            {
                Json::Value jv = offer(alice, USD(100), mpt);
                test(jv, jss::TakerPays.c_str());
                jv = offer(alice, mpt, USD(100));
                test(jv, jss::TakerGets.c_str());
            }
            // PaymentChannelCreate
            {
                Json::Value jv;
                jv[jss::TransactionType] = jss::PaymentChannelCreate;
                jv[jss::Account] = alice.human();
                jv[jss::Destination] = carol.human();
                jv[jss::SettleDelay] = 1;
                jv[sfPublicKey.fieldName] = strHex(alice.pk().slice());
                jv[jss::Amount] = mpt.getJson(JsonOptions::none);
                test(jv, jss::Amount.c_str());
            }
            // PaymentChannelFund
            {
                Json::Value jv;
                jv[jss::TransactionType] = jss::PaymentChannelFund;
                jv[jss::Account] = alice.human();
                jv[sfChannel.fieldName] = to_string(uint256{1});
                jv[jss::Amount] = mpt.getJson(JsonOptions::none);
                test(jv, jss::Amount.c_str());
            }
            // PaymentChannelClaim
            {
                Json::Value jv;
                jv[jss::TransactionType] = jss::PaymentChannelClaim;
                jv[jss::Account] = alice.human();
                jv[sfChannel.fieldName] = to_string(uint256{1});
                jv[jss::Amount] = mpt.getJson(JsonOptions::none);
                test(jv, jss::Amount.c_str());
            }
            // NFTokenCreateOffer
            {
                Json::Value jv;
                jv[jss::TransactionType] = jss::NFTokenCreateOffer;
                jv[jss::Account] = alice.human();
                jv[sfNFTokenID.fieldName] = to_string(uint256{1});
                jv[jss::Amount] = mpt.getJson(JsonOptions::none);
                test(jv, jss::Amount.c_str());
            }
            // NFTokenAcceptOffer
            {
                Json::Value jv;
                jv[jss::TransactionType] = jss::NFTokenAcceptOffer;
                jv[jss::Account] = alice.human();
                jv[sfNFTokenBrokerFee.fieldName] =
                    mpt.getJson(JsonOptions::none);
                test(jv, sfNFTokenBrokerFee.fieldName);
            }
            // NFTokenMint
            {
                Json::Value jv;
                jv[jss::TransactionType] = jss::NFTokenMint;
                jv[jss::Account] = alice.human();
                jv[sfNFTokenTaxon.fieldName] = 1;
                jv[jss::Amount] = mpt.getJson(JsonOptions::none);
                test(jv, jss::Amount.c_str());
            }
            // TrustSet
            auto trustSet = [&](SField const& field) {
                Json::Value jv;
                jv[jss::TransactionType] = jss::TrustSet;
                jv[jss::Account] = alice.human();
                jv[jss::Flags] = 0;
                jv[field.fieldName] = mpt.getJson(JsonOptions::none);
                test(jv, field.fieldName);
            };
            trustSet(sfLimitAmount);
            trustSet(sfFee);
            // XChainCommit
            {
                Json::Value const jv = xchain_commit(alice, jvb, 1, mpt);
                test(jv, jss::Amount.c_str());
            }
            // XChainClaim
            {
                Json::Value const jv = xchain_claim(alice, jvb, 1, mpt, alice);
                test(jv, jss::Amount.c_str());
            }
            // XChainCreateClaimID
            {
                Json::Value const jv =
                    xchain_create_claim_id(alice, jvb, mpt, alice);
                test(jv, sfSignatureReward.fieldName);
            }
            // XChainAddClaimAttestation
            {
                Json::Value const jv = claim_attestation(
                    alice,
                    jvb,
                    alice,
                    mpt,
                    alice,
                    true,
                    1,
                    alice,
                    signer(alice));
                test(jv, jss::Amount.c_str());
            }
            // XChainAddAccountCreateAttestation
            {
                Json::Value jv = create_account_attestation(
                    alice,
                    jvb,
                    alice,
                    mpt,
                    XRP(10),
                    alice,
                    false,
                    1,
                    alice,
                    signer(alice));
                for (auto const& field :
                     {sfAmount.fieldName, sfSignatureReward.fieldName})
                {
                    jv[field] = mpt.getJson(JsonOptions::none);
                    test(jv, field);
                }
            }
            // XChainAccountCreateCommit
            {
                Json::Value jv = sidechain_xchain_account_create(
                    alice, jvb, alice, mpt, XRP(10));
                for (auto const& field :
                     {sfAmount.fieldName, sfSignatureReward.fieldName})
                {
                    jv[field] = mpt.getJson(JsonOptions::none);
                    test(jv, field);
                }
            }
            // XChain[Create|Modify]Bridge
            auto bridgeTx = [&](Json::StaticString const& tt,
                                STAmount const& rewardAmount,
                                STAmount const& minAccountAmount,
                                std::string const& field) {
                Json::Value jv;
                jv[jss::TransactionType] = tt;
                jv[jss::Account] = alice.human();
                jv[sfXChainBridge.fieldName] = jvb;
                jv[sfSignatureReward.fieldName] =
                    rewardAmount.getJson(JsonOptions::none);
                jv[sfMinAccountCreateAmount.fieldName] =
                    minAccountAmount.getJson(JsonOptions::none);
                test(jv, field);
            };
            auto reward = STAmount{sfSignatureReward, mpt};
            auto minAmount = STAmount{sfMinAccountCreateAmount, USD(10)};
            for (SField const& field :
                 {std::ref(sfSignatureReward),
                  std::ref(sfMinAccountCreateAmount)})
            {
                bridgeTx(
                    jss::XChainCreateBridge,
                    reward,
                    minAmount,
                    field.fieldName);
                bridgeTx(
                    jss::XChainModifyBridge,
                    reward,
                    minAmount,
                    field.fieldName);
                reward = STAmount{sfSignatureReward, USD(10)};
                minAmount = STAmount{sfMinAccountCreateAmount, mpt};
            }
        }
        BEAST_EXPECT(txWithAmounts.empty());
    }
 
    void
    testTxJsonMetaFields(FeatureBitset features)
    {
        // checks synthetically injected mptissuanceid from  `tx` response
        testcase("Test synthetic fields from tx response");
 
        using namespace test::jtx;
 
        Account const alice{"alice"};
 
        auto cfg = envconfig();
        cfg->FEES.reference_fee = 10;
        Env env{*this, std::move(cfg), features};
        MPTTester mptAlice(env, alice);
 
        mptAlice.create();
 
        std::string const txHash{
            env.tx()->getJson(JsonOptions::none)[jss::hash].asString()};
        BEAST_EXPECTS(
            txHash ==
                "E11F0E0CA14219922B7881F060B9CEE67CFBC87E4049A441ED2AE348FF8FAC"
                "0E",
            txHash);
        Json::Value const meta = env.rpc("tx", txHash)[jss::result][jss::meta];
        auto const id = meta[jss::mpt_issuance_id].asString();
        // Expect mpt_issuance_id field
        BEAST_EXPECT(meta.isMember(jss::mpt_issuance_id));
        BEAST_EXPECT(id == to_string(mptAlice.issuanceID()));
        BEAST_EXPECTS(
            id == "00000004AE123A8556F3CF91154711376AFB0F894F832B3D", id);
    }
 
    void
    testClawbackValidation(FeatureBitset features)
    {
        testcase("MPT clawback validations");
        using namespace test::jtx;
 
        // Make sure clawback cannot work when featureMPTokensV1 is disabled
        {
            Env env(*this, features - featureMPTokensV1);
            Account const alice{"alice"};
            Account const bob{"bob"};
 
            env.fund(XRP(1000), alice, bob);
            env.close();
 
            auto const USD = alice["USD"];
            auto const mpt = ripple::test::jtx::MPT(
                alice.name(), makeMptID(env.seq(alice), alice));
 
            env(claw(alice, bob["USD"](5), bob), ter(temMALFORMED));
            env.close();
 
            env(claw(alice, mpt(5)), ter(temDISABLED));
            env.close();
 
            env(claw(alice, mpt(5), bob), ter(temDISABLED));
            env.close();
        }
 
        // Test preflight
        {
            Env env(*this, features);
            Account const alice{"alice"};
            Account const bob{"bob"};
 
            env.fund(XRP(1000), alice, bob);
            env.close();
 
            auto const USD = alice["USD"];
            auto const mpt = ripple::test::jtx::MPT(
                alice.name(), makeMptID(env.seq(alice), alice));
 
            // clawing back IOU from a MPT holder fails
            env(claw(alice, bob["USD"](5), bob), ter(temMALFORMED));
            env.close();
 
            // clawing back MPT without specifying a holder fails
            env(claw(alice, mpt(5)), ter(temMALFORMED));
            env.close();
 
            // clawing back zero amount fails
            env(claw(alice, mpt(0), bob), ter(temBAD_AMOUNT));
            env.close();
 
            // alice can't claw back from herself
            env(claw(alice, mpt(5), alice), ter(temMALFORMED));
            env.close();
 
            // can't clawback negative amount
            env(claw(alice, mpt(-1), bob), ter(temBAD_AMOUNT));
            env.close();
        }
 
        // Preclaim - clawback fails when MPTCanClawback is disabled on issuance
        {
            Env env(*this, features);
            Account const alice{"alice"};
            Account const bob{"bob"};
 
            MPTTester mptAlice(env, alice, {.holders = {bob}});
 
            // enable asfAllowTrustLineClawback for alice
            env(fset(alice, asfAllowTrustLineClawback));
            env.close();
            env.require(flags(alice, asfAllowTrustLineClawback));
 
            // Create issuance without enabling clawback
            mptAlice.create({.ownerCount = 1, .holderCount = 0});
 
            mptAlice.authorize({.account = bob});
 
            mptAlice.pay(alice, bob, 100);
 
            // alice cannot clawback before she didn't enable MPTCanClawback
            // asfAllowTrustLineClawback has no effect
            mptAlice.claw(alice, bob, 1, tecNO_PERMISSION);
        }
 
        // Preclaim - test various scenarios
        {
            Env env(*this, features);
            Account const alice{"alice"};
            Account const bob{"bob"};
            Account const carol{"carol"};
            env.fund(XRP(1000), carol);
            env.close();
            MPTTester mptAlice(env, alice, {.holders = {bob}});
 
            auto const fakeMpt = ripple::test::jtx::MPT(
                alice.name(), makeMptID(env.seq(alice), alice));
 
            // issuer tries to clawback MPT where issuance doesn't exist
            env(claw(alice, fakeMpt(5), bob), ter(tecOBJECT_NOT_FOUND));
            env.close();
 
            // alice creates issuance
            mptAlice.create(
                {.ownerCount = 1, .holderCount = 0, .flags = tfMPTCanClawback});
 
            // alice tries to clawback from someone who doesn't have MPToken
            mptAlice.claw(alice, bob, 1, tecOBJECT_NOT_FOUND);
 
            // bob creates a MPToken
            mptAlice.authorize({.account = bob});
 
            // clawback fails because bob currently has a balance of zero
            mptAlice.claw(alice, bob, 1, tecINSUFFICIENT_FUNDS);
 
            // alice pays bob 100 tokens
            mptAlice.pay(alice, bob, 100);
 
            // carol fails tries to clawback from bob because he is not the
            // issuer
            mptAlice.claw(carol, bob, 1, tecNO_PERMISSION);
        }
 
        // clawback more than max amount
        // fails in the json parser before
        // transactor is called
        {
            Env env(*this, features);
            Account const alice{"alice"};
            Account const bob{"bob"};
 
            env.fund(XRP(1000), alice, bob);
            env.close();
 
            auto const mpt = ripple::test::jtx::MPT(
                alice.name(), makeMptID(env.seq(alice), alice));
 
            Json::Value jv = claw(alice, mpt(1), bob);
            jv[jss::Amount][jss::value] = to_string(maxMPTokenAmount + 1);
            Json::Value jv1;
            jv1[jss::secret] = alice.name();
            jv1[jss::tx_json] = jv;
            auto const jrr = env.rpc("json", "submit", to_string(jv1));
            BEAST_EXPECT(jrr[jss::result][jss::error] == "invalidParams");
        }
    }
 
    void
    testClawback(FeatureBitset features)
    {
        testcase("MPT Clawback");
        using namespace test::jtx;
 
        {
            Env env(*this, features);
            Account const alice{"alice"};
            Account const bob{"bob"};
 
            MPTTester mptAlice(env, alice, {.holders = {bob}});
 
            // alice creates issuance
            mptAlice.create(
                {.ownerCount = 1, .holderCount = 0, .flags = tfMPTCanClawback});
 
            // bob creates a MPToken
            mptAlice.authorize({.account = bob});
 
            // alice pays bob 100 tokens
            mptAlice.pay(alice, bob, 100);
 
            mptAlice.claw(alice, bob, 1);
 
            mptAlice.claw(alice, bob, 1000);
 
            // clawback fails because bob currently has a balance of zero
            mptAlice.claw(alice, bob, 1, tecINSUFFICIENT_FUNDS);
        }
 
        // Test that globally locked funds can be clawed
        {
            Env env(*this, features);
            Account const alice{"alice"};
            Account const bob{"bob"};
 
            MPTTester mptAlice(env, alice, {.holders = {bob}});
 
            // alice creates issuance
            mptAlice.create(
                {.ownerCount = 1,
                 .holderCount = 0,
                 .flags = tfMPTCanLock | tfMPTCanClawback});
 
            // bob creates a MPToken
            mptAlice.authorize({.account = bob});
 
            // alice pays bob 100 tokens
            mptAlice.pay(alice, bob, 100);
 
            mptAlice.set({.account = alice, .flags = tfMPTLock});
 
            mptAlice.claw(alice, bob, 100);
        }
 
        // Test that individually locked funds can be clawed
        {
            Env env(*this, features);
            Account const alice{"alice"};
            Account const bob{"bob"};
 
            MPTTester mptAlice(env, alice, {.holders = {bob}});
 
            // alice creates issuance
            mptAlice.create(
                {.ownerCount = 1,
                 .holderCount = 0,
                 .flags = tfMPTCanLock | tfMPTCanClawback});
 
            // bob creates a MPToken
            mptAlice.authorize({.account = bob});
 
            // alice pays bob 100 tokens
            mptAlice.pay(alice, bob, 100);
 
            mptAlice.set({.account = alice, .holder = bob, .flags = tfMPTLock});
 
            mptAlice.claw(alice, bob, 100);
        }
 
        // Test that unauthorized funds can be clawed back
        {
            Env env(*this, features);
            Account const alice{"alice"};
            Account const bob{"bob"};
 
            MPTTester mptAlice(env, alice, {.holders = {bob}});
 
            // alice creates issuance
            mptAlice.create(
                {.ownerCount = 1,
                 .holderCount = 0,
                 .flags = tfMPTCanClawback | tfMPTRequireAuth});
 
            // bob creates a MPToken
            mptAlice.authorize({.account = bob});
 
            // alice authorizes bob
            mptAlice.authorize({.account = alice, .holder = bob});
 
            // alice pays bob 100 tokens
            mptAlice.pay(alice, bob, 100);
 
            // alice unauthorizes bob
            mptAlice.authorize(
                {.account = alice, .holder = bob, .flags = tfMPTUnauthorize});
 
            mptAlice.claw(alice, bob, 100);
        }
    }
 
    void
    testTokensEquality()
    {
        using namespace test::jtx;
        testcase("Tokens Equality");
        Currency const cur1{to_currency("CU1")};
        Currency const cur2{to_currency("CU2")};
        Account const gw1{"gw1"};
        Account const gw2{"gw2"};
        MPTID const mpt1 = makeMptID(1, gw1);
        MPTID const mpt1a = makeMptID(1, gw1);
        MPTID const mpt2 = makeMptID(1, gw2);
        MPTID const mpt3 = makeMptID(2, gw2);
        Asset const assetCur1Gw1{Issue{cur1, gw1}};
        Asset const assetCur1Gw1a{Issue{cur1, gw1}};
        Asset const assetCur2Gw1{Issue{cur2, gw1}};
        Asset const assetCur2Gw2{Issue{cur2, gw2}};
        Asset const assetMpt1Gw1{mpt1};
        Asset const assetMpt1Gw1a{mpt1a};
        Asset const assetMpt1Gw2{mpt2};
        Asset const assetMpt2Gw2{mpt3};
 
        // Assets holding Issue
        // Currencies are equal regardless of the issuer
        BEAST_EXPECT(equalTokens(assetCur1Gw1, assetCur1Gw1a));
        BEAST_EXPECT(equalTokens(assetCur2Gw1, assetCur2Gw2));
        // Currencies are different regardless of whether the issuers
        // are the same or not
        BEAST_EXPECT(!equalTokens(assetCur1Gw1, assetCur2Gw1));
        BEAST_EXPECT(!equalTokens(assetCur1Gw1, assetCur2Gw2));
 
        // Assets holding MPTIssue
        // MPTIDs are the same if the sequence and the issuer are the same
        BEAST_EXPECT(equalTokens(assetMpt1Gw1, assetMpt1Gw1a));
        // MPTIDs are different if sequence and the issuer don't match
        BEAST_EXPECT(!equalTokens(assetMpt1Gw1, assetMpt1Gw2));
        BEAST_EXPECT(!equalTokens(assetMpt1Gw2, assetMpt2Gw2));
 
        // Assets holding Issue and MPTIssue
        BEAST_EXPECT(!equalTokens(assetCur1Gw1, assetMpt1Gw1));
        BEAST_EXPECT(!equalTokens(assetMpt2Gw2, assetCur2Gw2));
    }
 
    void
    testHelperFunctions()
    {
        using namespace test::jtx;
        Account const gw{"gw"};
        Asset const asset1{makeMptID(1, gw)};
        Asset const asset2{makeMptID(2, gw)};
        Asset const asset3{makeMptID(3, gw)};
        STAmount const amt1{asset1, 100};
        STAmount const amt2{asset2, 100};
        STAmount const amt3{asset3, 10'000};
 
        {
            testcase("Test STAmount MPT arithmetics");
            using namespace std::string_literals;
            STAmount res = multiply(amt1, amt2, asset3);
            BEAST_EXPECT(res == amt3);
 
            res = mulRound(amt1, amt2, asset3, true);
            BEAST_EXPECT(res == amt3);
 
            res = mulRoundStrict(amt1, amt2, asset3, true);
            BEAST_EXPECT(res == amt3);
 
            // overflow, any value > 3037000499ull
            STAmount mptOverflow{asset2, UINT64_C(3037000500)};
            try
            {
                res = multiply(mptOverflow, mptOverflow, asset3);
                fail("should throw runtime exception 1");
            }
            catch (std::runtime_error const& e)
            {
                BEAST_EXPECTS(e.what() == "MPT value overflow"s, e.what());
            }
            // overflow, (v1 >> 32) * v2 > 2147483648ull
            mptOverflow = STAmount{asset2, UINT64_C(2147483648)};
            uint64_t const mantissa = (2ull << 32) + 2;
            try
            {
                res = multiply(STAmount{asset1, mantissa}, mptOverflow, asset3);
                fail("should throw runtime exception 2");
            }
            catch (std::runtime_error const& e)
            {
                BEAST_EXPECTS(e.what() == "MPT value overflow"s, e.what());
            }
        }
 
        {
            testcase("Test MPTAmount arithmetics");
            MPTAmount mptAmt1{100};
            MPTAmount const mptAmt2{100};
            BEAST_EXPECT((mptAmt1 += mptAmt2) == MPTAmount{200});
            BEAST_EXPECT(mptAmt1 == 200);
            BEAST_EXPECT((mptAmt1 -= mptAmt2) == mptAmt1);
            BEAST_EXPECT(mptAmt1 == mptAmt2);
            BEAST_EXPECT(mptAmt1 == 100);
            BEAST_EXPECT(MPTAmount::minPositiveAmount() == MPTAmount{1});
        }
 
        {
            testcase("Test MPTIssue from/to Json");
            MPTIssue const issue1{asset1.get<MPTIssue>()};
            Json::Value const jv = to_json(issue1);
            BEAST_EXPECT(
                jv[jss::mpt_issuance_id] == to_string(asset1.get<MPTIssue>()));
            BEAST_EXPECT(issue1 == mptIssueFromJson(jv));
        }
 
        {
            testcase("Test Asset from/to Json");
            Json::Value const jv = to_json(asset1);
            BEAST_EXPECT(
                jv[jss::mpt_issuance_id] == to_string(asset1.get<MPTIssue>()));
            BEAST_EXPECT(
                to_string(jv) ==
                "{\"mpt_issuance_id\":"
                "\"00000001A407AF5856CCF3C42619DAA925813FC955C72983\"}");
            BEAST_EXPECT(asset1 == assetFromJson(jv));
        }
    }
 
    void
    testInvalidCreateDynamic(FeatureBitset features)
    {
        testcase("invalid MPTokenIssuanceCreate for DynamicMPT");
 
        using namespace test::jtx;
        Account const alice("alice");
 
        // Can not provide MutableFlags when DynamicMPT amendment is not enabled
        {
            Env env{*this, features - featureDynamicMPT};
            MPTTester mptAlice(env, alice);
            mptAlice.create(
                {.ownerCount = 0, .mutableFlags = 2, .err = temDISABLED});
            mptAlice.create(
                {.ownerCount = 0, .mutableFlags = 0, .err = temDISABLED});
        }
 
        // MutableFlags contains invalid values
        {
            Env env{*this, features};
            MPTTester mptAlice(env, alice);
 
            // Value 1 is reserved for MPT lock.
            mptAlice.create(
                {.ownerCount = 0, .mutableFlags = 1, .err = temINVALID_FLAG});
            mptAlice.create(
                {.ownerCount = 0, .mutableFlags = 17, .err = temINVALID_FLAG});
            mptAlice.create(
                {.ownerCount = 0,
                 .mutableFlags = 65535,
                 .err = temINVALID_FLAG});
 
            // MutableFlags can not be 0
            mptAlice.create(
                {.ownerCount = 0, .mutableFlags = 0, .err = temINVALID_FLAG});
        }
    }
 
    void
    testInvalidSetDynamic(FeatureBitset features)
    {
        testcase("invalid MPTokenIssuanceSet for DynamicMPT");
 
        using namespace test::jtx;
        Account const alice("alice");
        Account const bob("bob");
 
        // Can not provide MutableFlags, MPTokenMetadata or TransferFee when
        // DynamicMPT amendment is not enabled
        {
            Env env{*this, features - featureDynamicMPT};
            MPTTester mptAlice(env, alice, {.holders = {bob}});
            auto const mptID = makeMptID(env.seq(alice), alice);
 
            // MutableFlags is not allowed when DynamicMPT is not enabled
            mptAlice.set(
                {.account = alice,
                 .id = mptID,
                 .mutableFlags = 2,
                 .err = temDISABLED});
            mptAlice.set(
                {.account = alice,
                 .id = mptID,
                 .mutableFlags = 0,
                 .err = temDISABLED});
 
            // MPTokenMetadata is not allowed when DynamicMPT is not enabled
            mptAlice.set(
                {.account = alice,
                 .id = mptID,
                 .metadata = "test",
                 .err = temDISABLED});
            mptAlice.set(
                {.account = alice,
                 .id = mptID,
                 .metadata = "",
                 .err = temDISABLED});
 
            // TransferFee is not allowed when DynamicMPT is not enabled
            mptAlice.set(
                {.account = alice,
                 .id = mptID,
                 .transferFee = 100,
                 .err = temDISABLED});
            mptAlice.set(
                {.account = alice,
                 .id = mptID,
                 .transferFee = 0,
                 .err = temDISABLED});
        }
 
        // Can not provide holder when MutableFlags, MPTokenMetadata or
        // TransferFee is present
        {
            Env env{*this, features};
            MPTTester mptAlice(env, alice, {.holders = {bob}});
            auto const mptID = makeMptID(env.seq(alice), alice);
 
            // Holder is not allowed when MutableFlags is present
            mptAlice.set(
                {.account = alice,
                 .holder = bob,
                 .id = mptID,
                 .mutableFlags = 2,
                 .err = temMALFORMED});
 
            // Holder is not allowed when MPTokenMetadata is present
            mptAlice.set(
                {.account = alice,
                 .holder = bob,
                 .id = mptID,
                 .metadata = "test",
                 .err = temMALFORMED});
 
            // Holder is not allowed when TransferFee is present
            mptAlice.set(
                {.account = alice,
                 .holder = bob,
                 .id = mptID,
                 .transferFee = 100,
                 .err = temMALFORMED});
        }
 
        // Can not set Flags when MutableFlags, MPTokenMetadata or
        // TransferFee is present
        {
            Env env{*this, features};
            MPTTester mptAlice(env, alice, {.holders = {bob}});
            mptAlice.create(
                {.ownerCount = 1,
                 .mutableFlags = tmfMPTCanMutateMetadata |
                     tmfMPTCanMutateCanLock | tmfMPTCanMutateTransferFee});
 
            // Setting flags is not allowed when MutableFlags is present
            mptAlice.set(
                {.account = alice,
                 .flags = tfMPTCanLock,
                 .mutableFlags = 2,
                 .err = temMALFORMED});
 
            // Setting flags is not allowed when MPTokenMetadata is present
            mptAlice.set(
                {.account = alice,
                 .flags = tfMPTCanLock,
                 .metadata = "test",
                 .err = temMALFORMED});
 
            // setting flags is not allowed when TransferFee is present
            mptAlice.set(
                {.account = alice,
                 .flags = tfMPTCanLock,
                 .transferFee = 100,
                 .err = temMALFORMED});
        }
 
        // Flags being 0 or tfFullyCanonicalSig is fine
        {
            Env env{*this, features};
            MPTTester mptAlice(env, alice, {.holders = {bob}});
 
            mptAlice.create(
                {.transferFee = 10,
                 .ownerCount = 1,
                 .flags = tfMPTCanTransfer,
                 .mutableFlags =
                     tmfMPTCanMutateTransferFee | tmfMPTCanMutateMetadata});
 
            mptAlice.set(
                {.account = alice,
                 .flags = 0,
                 .transferFee = 100,
                 .metadata = "test"});
            mptAlice.set(
                {.account = alice,
                 .flags = tfFullyCanonicalSig,
                 .transferFee = 200,
                 .metadata = "test2"});
        }
 
        // Invalid MutableFlags
        {
            Env env{*this, features};
            MPTTester mptAlice(env, alice, {.holders = {bob}});
            auto const mptID = makeMptID(env.seq(alice), alice);
 
            for (auto const flags : {10000, 0, 5000})
            {
                mptAlice.set(
                    {.account = alice,
                     .id = mptID,
                     .mutableFlags = flags,
                     .err = temINVALID_FLAG});
            }
        }
 
        // Can not set and clear the same mutable flag
        {
            Env env{*this, features};
            MPTTester mptAlice(env, alice, {.holders = {bob}});
            auto const mptID = makeMptID(env.seq(alice), alice);
 
            auto const flagCombinations = {
                tmfMPTSetCanLock | tmfMPTClearCanLock,
                tmfMPTSetRequireAuth | tmfMPTClearRequireAuth,
                tmfMPTSetCanEscrow | tmfMPTClearCanEscrow,
                tmfMPTSetCanTrade | tmfMPTClearCanTrade,
                tmfMPTSetCanTransfer | tmfMPTClearCanTransfer,
                tmfMPTSetCanClawback | tmfMPTClearCanClawback,
                tmfMPTSetCanLock | tmfMPTClearCanLock | tmfMPTClearCanTrade,
                tmfMPTSetCanTransfer | tmfMPTClearCanTransfer |
                    tmfMPTSetCanEscrow | tmfMPTClearCanClawback};
 
            for (auto const& mutableFlags : flagCombinations)
            {
                mptAlice.set(
                    {.account = alice,
                     .id = mptID,
                     .mutableFlags = mutableFlags,
                     .err = temINVALID_FLAG});
            }
        }
 
        // Can not mutate flag which is not mutable
        {
            Env env{*this, features};
            MPTTester mptAlice(env, alice, {.holders = {bob}});
 
            mptAlice.create({.ownerCount = 1});
 
            auto const mutableFlags = {
                tmfMPTSetCanLock,
                tmfMPTClearCanLock,
                tmfMPTSetRequireAuth,
                tmfMPTClearRequireAuth,
                tmfMPTSetCanEscrow,
                tmfMPTClearCanEscrow,
                tmfMPTSetCanTrade,
                tmfMPTClearCanTrade,
                tmfMPTSetCanTransfer,
                tmfMPTClearCanTransfer,
                tmfMPTSetCanClawback,
                tmfMPTClearCanClawback};
 
            for (auto const& mutableFlag : mutableFlags)
            {
                mptAlice.set(
                    {.account = alice,
                     .mutableFlags = mutableFlag,
                     .err = tecNO_PERMISSION});
            }
        }
 
        // Metadata exceeding max length
        {
            Env env{*this, features};
            MPTTester mptAlice(env, alice, {.holders = {bob}});
 
            mptAlice.create(
                {.ownerCount = 1, .mutableFlags = tmfMPTCanMutateMetadata});
 
            std::string metadata(maxMPTokenMetadataLength + 1, 'a');
            mptAlice.set(
                {.account = alice, .metadata = metadata, .err = temMALFORMED});
        }
 
        // Can not mutate metadata when it is not mutable
        {
            Env env{*this, features};
            MPTTester mptAlice(env, alice, {.holders = {bob}});
 
            mptAlice.create({.ownerCount = 1});
            mptAlice.set(
                {.account = alice,
                 .metadata = "test",
                 .err = tecNO_PERMISSION});
        }
 
        // Transfer fee exceeding the max value
        {
            Env env{*this, features};
            MPTTester mptAlice(env, alice, {.holders = {bob}});
            auto const mptID = makeMptID(env.seq(alice), alice);
 
            mptAlice.create(
                {.ownerCount = 1, .mutableFlags = tmfMPTCanMutateTransferFee});
 
            mptAlice.set(
                {.account = alice,
                 .id = mptID,
                 .transferFee = maxTransferFee + 1,
                 .err = temBAD_TRANSFER_FEE});
        }
 
        // Test setting non-zero transfer fee and clearing MPTCanTransfer at the
        // same time
        {
            Env env{*this, features};
            MPTTester mptAlice(env, alice, {.holders = {bob}});
 
            mptAlice.create(
                {.transferFee = 100,
                 .ownerCount = 1,
                 .flags = tfMPTCanTransfer,
                 .mutableFlags =
                     tmfMPTCanMutateTransferFee | tmfMPTCanMutateCanTransfer});
 
            // Can not set non-zero transfer fee and clear MPTCanTransfer at the
            // same time
            mptAlice.set(
                {.account = alice,
                 .mutableFlags = tmfMPTClearCanTransfer,
                 .transferFee = 1,
                 .err = temMALFORMED});
 
            // Can set transfer fee to zero and clear MPTCanTransfer at the same
            // time. tfMPTCanTransfer will be cleared and TransferFee field will
            // be removed.
            mptAlice.set(
                {.account = alice,
                 .mutableFlags = tmfMPTClearCanTransfer,
                 .transferFee = 0});
            BEAST_EXPECT(!mptAlice.isTransferFeePresent());
        }
 
        // Can not set non-zero transfer fee when MPTCanTransfer is not set
        {
            Env env{*this, features};
            MPTTester mptAlice(env, alice, {.holders = {bob}});
 
            mptAlice.create(
                {.ownerCount = 1,
                 .mutableFlags =
                     tmfMPTCanMutateTransferFee | tmfMPTCanMutateCanTransfer});
 
            mptAlice.set(
                {.account = alice,
                 .transferFee = 100,
                 .err = tecNO_PERMISSION});
 
            // Can not set transfer fee even when trying to set MPTCanTransfer
            // at the same time. MPTCanTransfer must be set first, then transfer
            // fee can be set in a separate transaction.
            mptAlice.set(
                {.account = alice,
                 .mutableFlags = tmfMPTSetCanTransfer,
                 .transferFee = 100,
                 .err = tecNO_PERMISSION});
        }
 
        // Can not mutate transfer fee when it is not mutable
        {
            Env env{*this, features};
            MPTTester mptAlice(env, alice, {.holders = {bob}});
 
            mptAlice.create(
                {.transferFee = 10,
                 .ownerCount = 1,
                 .flags = tfMPTCanTransfer});
 
            mptAlice.set(
                {.account = alice,
                 .transferFee = 100,
                 .err = tecNO_PERMISSION});
 
            mptAlice.set(
                {.account = alice, .transferFee = 0, .err = tecNO_PERMISSION});
        }
 
        // Set some flags mutable. Can not mutate the others
        {
            Env env{*this, features};
            MPTTester mptAlice(env, alice, {.holders = {bob}});
 
            mptAlice.create(
                {.ownerCount = 1,
                 .mutableFlags = tmfMPTCanMutateCanTrade |
                     tmfMPTCanMutateCanTransfer | tmfMPTCanMutateMetadata});
 
            // Can not mutate transfer fee
            mptAlice.set(
                {.account = alice,
                 .transferFee = 100,
                 .err = tecNO_PERMISSION});
 
            auto const invalidFlags = {
                tmfMPTSetCanLock,
                tmfMPTClearCanLock,
                tmfMPTSetRequireAuth,
                tmfMPTClearRequireAuth,
                tmfMPTSetCanEscrow,
                tmfMPTClearCanEscrow,
                tmfMPTSetCanClawback,
                tmfMPTClearCanClawback};
 
            // Can not mutate flags which are not mutable
            for (auto const& mutableFlag : invalidFlags)
            {
                mptAlice.set(
                    {.account = alice,
                     .mutableFlags = mutableFlag,
                     .err = tecNO_PERMISSION});
            }
 
            // Can mutate MPTCanTrade
            mptAlice.set({.account = alice, .mutableFlags = tmfMPTSetCanTrade});
            mptAlice.set(
                {.account = alice, .mutableFlags = tmfMPTClearCanTrade});
 
            // Can mutate MPTCanTransfer
            mptAlice.set(
                {.account = alice, .mutableFlags = tmfMPTSetCanTransfer});
            mptAlice.set(
                {.account = alice, .mutableFlags = tmfMPTClearCanTransfer});
 
            // Can mutate metadata
            mptAlice.set({.account = alice, .metadata = "test"});
            mptAlice.set({.account = alice, .metadata = ""});
        }
    }
 
    void
    testMutateMPT(FeatureBitset features)
    {
        testcase("Mutate MPT");
        using namespace test::jtx;
 
        Account const alice("alice");
 
        // Mutate metadata
        {
            Env env{*this, features};
            MPTTester mptAlice(env, alice);
            mptAlice.create(
                {.metadata = "test",
                 .ownerCount = 1,
                 .mutableFlags = tmfMPTCanMutateMetadata});
 
            std::vector<std::string> metadatas = {
                "mutate metadata",
                "mutate metadata 2",
                "mutate metadata 3",
                "mutate metadata 3",
                "test",
                "mutate metadata"};
 
            for (auto const& metadata : metadatas)
            {
                mptAlice.set({.account = alice, .metadata = metadata});
                BEAST_EXPECT(mptAlice.checkMetadata(metadata));
            }
 
            // Metadata being empty will remove the field
            mptAlice.set({.account = alice, .metadata = ""});
            BEAST_EXPECT(!mptAlice.isMetadataPresent());
        }
 
        // Mutate transfer fee
        {
            Env env{*this, features};
            MPTTester mptAlice(env, alice);
            mptAlice.create(
                {.transferFee = 100,
                 .metadata = "test",
                 .ownerCount = 1,
                 .flags = tfMPTCanTransfer,
                 .mutableFlags = tmfMPTCanMutateTransferFee});
 
            for (std::uint16_t const fee : std::initializer_list<std::uint16_t>{
                     1, 10, 100, 200, 500, 1000, maxTransferFee})
            {
                mptAlice.set({.account = alice, .transferFee = fee});
                BEAST_EXPECT(mptAlice.checkTransferFee(fee));
            }
 
            // Setting TransferFee to zero will remove the field
            mptAlice.set({.account = alice, .transferFee = 0});
            BEAST_EXPECT(!mptAlice.isTransferFeePresent());
 
            // Set transfer fee again
            mptAlice.set({.account = alice, .transferFee = 10});
            BEAST_EXPECT(mptAlice.checkTransferFee(10));
        }
 
        // Test flag toggling
        {
            auto testFlagToggle = [&](std::uint32_t createFlags,
                                      std::uint32_t setFlags,
                                      std::uint32_t clearFlags) {
                Env env{*this, features};
                MPTTester mptAlice(env, alice);
 
                // Create the MPT object with the specified initial flags
                mptAlice.create(
                    {.metadata = "test",
                     .ownerCount = 1,
                     .mutableFlags = createFlags});
 
                // Set and clear the flag multiple times
                mptAlice.set({.account = alice, .mutableFlags = setFlags});
                mptAlice.set({.account = alice, .mutableFlags = clearFlags});
                mptAlice.set({.account = alice, .mutableFlags = clearFlags});
                mptAlice.set({.account = alice, .mutableFlags = setFlags});
                mptAlice.set({.account = alice, .mutableFlags = setFlags});
                mptAlice.set({.account = alice, .mutableFlags = clearFlags});
                mptAlice.set({.account = alice, .mutableFlags = setFlags});
                mptAlice.set({.account = alice, .mutableFlags = clearFlags});
            };
 
            testFlagToggle(
                tmfMPTCanMutateCanLock, tfMPTCanLock, tmfMPTClearCanLock);
            testFlagToggle(
                tmfMPTCanMutateRequireAuth,
                tmfMPTSetRequireAuth,
                tmfMPTClearRequireAuth);
            testFlagToggle(
                tmfMPTCanMutateCanEscrow,
                tmfMPTSetCanEscrow,
                tmfMPTClearCanEscrow);
            testFlagToggle(
                tmfMPTCanMutateCanTrade,
                tmfMPTSetCanTrade,
                tmfMPTClearCanTrade);
            testFlagToggle(
                tmfMPTCanMutateCanTransfer,
                tmfMPTSetCanTransfer,
                tmfMPTClearCanTransfer);
            testFlagToggle(
                tmfMPTCanMutateCanClawback,
                tmfMPTSetCanClawback,
                tmfMPTClearCanClawback);
        }
    }
 
    void
    testMutateCanLock(FeatureBitset features)
    {
        testcase("Mutate MPTCanLock");
        using namespace test::jtx;
 
        Account const alice("alice");
        Account const bob("bob");
 
        // Individual lock
        {
            Env env{*this, features};
            MPTTester mptAlice(env, alice, {.holders = {bob}});
            mptAlice.create(
                {.ownerCount = 1,
                 .holderCount = 0,
                 .flags = tfMPTCanLock | tfMPTCanTransfer,
                 .mutableFlags = tmfMPTCanMutateCanLock |
                     tmfMPTCanMutateCanTrade | tmfMPTCanMutateTransferFee});
            mptAlice.authorize({.account = bob, .holderCount = 1});
 
            // Lock bob's mptoken
            mptAlice.set({.account = alice, .holder = bob, .flags = tfMPTLock});
 
            // Can mutate the mutable flags and fields
            mptAlice.set(
                {.account = alice, .mutableFlags = tmfMPTClearCanLock});
            mptAlice.set({.account = alice, .mutableFlags = tmfMPTSetCanLock});
            mptAlice.set(
                {.account = alice, .mutableFlags = tmfMPTClearCanLock});
            mptAlice.set({.account = alice, .mutableFlags = tmfMPTSetCanTrade});
            mptAlice.set(
                {.account = alice, .mutableFlags = tmfMPTClearCanTrade});
            mptAlice.set({.account = alice, .transferFee = 200});
        }
 
        // Global lock
        {
            Env env{*this, features};
            MPTTester mptAlice(env, alice, {.holders = {bob}});
            mptAlice.create(
                {.ownerCount = 1,
                 .holderCount = 0,
                 .flags = tfMPTCanLock,
                 .mutableFlags = tmfMPTCanMutateCanLock |
                     tmfMPTCanMutateCanClawback | tmfMPTCanMutateMetadata});
            mptAlice.authorize({.account = bob, .holderCount = 1});
 
            // Lock issuance
            mptAlice.set({.account = alice, .flags = tfMPTLock});
 
            // Can mutate the mutable flags and fields
            mptAlice.set(
                {.account = alice, .mutableFlags = tmfMPTClearCanLock});
            mptAlice.set({.account = alice, .mutableFlags = tmfMPTSetCanLock});
            mptAlice.set(
                {.account = alice, .mutableFlags = tmfMPTClearCanLock});
            mptAlice.set(
                {.account = alice, .mutableFlags = tmfMPTSetCanClawback});
            mptAlice.set(
                {.account = alice, .mutableFlags = tmfMPTClearCanClawback});
            mptAlice.set({.account = alice, .metadata = "mutate"});
        }
 
        // Test lock and unlock after mutating MPTCanLock
        {
            Env env{*this, features};
            MPTTester mptAlice(env, alice, {.holders = {bob}});
            mptAlice.create(
                {.ownerCount = 1,
                 .holderCount = 0,
                 .flags = tfMPTCanLock,
                 .mutableFlags = tmfMPTCanMutateCanLock |
                     tmfMPTCanMutateCanClawback | tmfMPTCanMutateMetadata});
            mptAlice.authorize({.account = bob, .holderCount = 1});
 
            // Can lock and unlock
            mptAlice.set({.account = alice, .flags = tfMPTLock});
            mptAlice.set({.account = alice, .holder = bob, .flags = tfMPTLock});
            mptAlice.set({.account = alice, .flags = tfMPTUnlock});
            mptAlice.set(
                {.account = alice, .holder = bob, .flags = tfMPTUnlock});
 
            // Clear lsfMPTCanLock
            mptAlice.set(
                {.account = alice, .mutableFlags = tmfMPTClearCanLock});
 
            // Can not lock or unlock
            mptAlice.set(
                {.account = alice,
                 .flags = tfMPTLock,
                 .err = tecNO_PERMISSION});
            mptAlice.set(
                {.account = alice,
                 .flags = tfMPTUnlock,
                 .err = tecNO_PERMISSION});
            mptAlice.set(
                {.account = alice,
                 .holder = bob,
                 .flags = tfMPTLock,
                 .err = tecNO_PERMISSION});
            mptAlice.set(
                {.account = alice,
                 .holder = bob,
                 .flags = tfMPTUnlock,
                 .err = tecNO_PERMISSION});
 
            // Set MPTCanLock again
            mptAlice.set({.account = alice, .mutableFlags = tmfMPTSetCanLock});
 
            // Can lock and unlock again
            mptAlice.set({.account = alice, .flags = tfMPTLock});
            mptAlice.set({.account = alice, .holder = bob, .flags = tfMPTLock});
            mptAlice.set({.account = alice, .flags = tfMPTUnlock});
            mptAlice.set(
                {.account = alice, .holder = bob, .flags = tfMPTUnlock});
        }
    }
 
    void
    testMutateRequireAuth(FeatureBitset features)
    {
        testcase("Mutate MPTRequireAuth");
        using namespace test::jtx;
 
        Env env{*this, features};
        Account const alice("alice");
        Account const bob("bob");
 
        MPTTester mptAlice(env, alice, {.holders = {bob}});
        mptAlice.create(
            {.ownerCount = 1,
             .flags = tfMPTRequireAuth,
             .mutableFlags = tmfMPTCanMutateRequireAuth});
 
        mptAlice.authorize({.account = bob});
        mptAlice.authorize({.account = alice, .holder = bob});
 
        // Pay to bob
        mptAlice.pay(alice, bob, 1000);
 
        // Unauthorize bob
        mptAlice.authorize(
            {.account = alice, .holder = bob, .flags = tfMPTUnauthorize});
 
        // Can not pay to bob
        mptAlice.pay(bob, alice, 100, tecNO_AUTH);
 
        // Clear RequireAuth
        mptAlice.set(
            {.account = alice, .mutableFlags = tmfMPTClearRequireAuth});
 
        // Can pay to bob
        mptAlice.pay(alice, bob, 1000);
 
        // Set RequireAuth again
        mptAlice.set({.account = alice, .mutableFlags = tmfMPTSetRequireAuth});
 
        // Can not pay to bob since he is not authorized
        mptAlice.pay(bob, alice, 100, tecNO_AUTH);
 
        // Authorize bob again
        mptAlice.authorize({.account = alice, .holder = bob});
 
        // Can pay to bob again
        mptAlice.pay(alice, bob, 100);
    }
 
    void
    testMutateCanEscrow(FeatureBitset features)
    {
        testcase("Mutate MPTCanEscrow");
        using namespace test::jtx;
        using namespace std::literals;
 
        Env env{*this, features};
        auto const baseFee = env.current()->fees().base;
        auto const alice = Account("alice");
        auto const bob = Account("bob");
        auto const carol = Account("carol");
 
        MPTTester mptAlice(env, alice, {.holders = {carol, bob}});
        mptAlice.create(
            {.ownerCount = 1,
             .holderCount = 0,
             .flags = tfMPTCanTransfer,
             .mutableFlags = tmfMPTCanMutateCanEscrow});
        mptAlice.authorize({.account = carol});
        mptAlice.authorize({.account = bob});
 
        auto const MPT = mptAlice["MPT"];
        env(pay(alice, carol, MPT(10'000)));
        env(pay(alice, bob, MPT(10'000)));
        env.close();
 
        // MPTCanEscrow is not enabled
        env(escrow::create(carol, bob, MPT(3)),
            escrow::condition(escrow::cb1),
            escrow::finish_time(env.now() + 1s),
            fee(baseFee * 150),
            ter(tecNO_PERMISSION));
 
        // MPTCanEscrow is enabled now
        mptAlice.set({.account = alice, .mutableFlags = tmfMPTSetCanEscrow});
        env(escrow::create(carol, bob, MPT(3)),
            escrow::condition(escrow::cb1),
            escrow::finish_time(env.now() + 1s),
            fee(baseFee * 150));
 
        // Clear MPTCanEscrow
        mptAlice.set({.account = alice, .mutableFlags = tmfMPTClearCanEscrow});
        env(escrow::create(carol, bob, MPT(3)),
            escrow::condition(escrow::cb1),
            escrow::finish_time(env.now() + 1s),
            fee(baseFee * 150),
            ter(tecNO_PERMISSION));
    }
 
    void
    testMutateCanTransfer(FeatureBitset features)
    {
        testcase("Mutate MPTCanTransfer");
 
        using namespace test::jtx;
        Account const alice("alice");
        Account const bob("bob");
        Account const carol("carol");
 
        {
            Env env{*this, features};
 
            MPTTester mptAlice(env, alice, {.holders = {bob, carol}});
            mptAlice.create(
                {.ownerCount = 1,
                 .mutableFlags =
                     tmfMPTCanMutateCanTransfer | tmfMPTCanMutateTransferFee});
 
            mptAlice.authorize({.account = bob});
            mptAlice.authorize({.account = carol});
 
            // Pay to bob
            mptAlice.pay(alice, bob, 1000);
 
            // Bob can not pay carol since MPTCanTransfer is not set
            mptAlice.pay(bob, carol, 50, tecNO_AUTH);
 
            // Can not set non-zero transfer fee when MPTCanTransfer is not set
            mptAlice.set(
                {.account = alice,
                 .transferFee = 100,
                 .err = tecNO_PERMISSION});
 
            // Can not set non-zero transfer fee even when trying to set
            // MPTCanTransfer at the same time
            mptAlice.set(
                {.account = alice,
                 .mutableFlags = tmfMPTSetCanTransfer,
                 .transferFee = 100,
                 .err = tecNO_PERMISSION});
 
            // Alice sets MPTCanTransfer
            mptAlice.set(
                {.account = alice, .mutableFlags = tmfMPTSetCanTransfer});
 
            // Can set transfer fee now
            BEAST_EXPECT(!mptAlice.isTransferFeePresent());
            mptAlice.set({.account = alice, .transferFee = 100});
            BEAST_EXPECT(mptAlice.isTransferFeePresent());
 
            // Bob can pay carol
            mptAlice.pay(bob, carol, 50);
 
            // Alice clears MPTCanTransfer
            mptAlice.set(
                {.account = alice, .mutableFlags = tmfMPTClearCanTransfer});
 
            // TransferFee field is removed when MPTCanTransfer is cleared
            BEAST_EXPECT(!mptAlice.isTransferFeePresent());
 
            // Bob can not pay
            mptAlice.pay(bob, carol, 50, tecNO_AUTH);
        }
 
        // Can set transfer fee to zero when MPTCanTransfer is not set, but
        // tmfMPTCanMutateTransferFee is set.
        {
            Env env{*this, features};
 
            MPTTester mptAlice(env, alice, {.holders = {bob, carol}});
            mptAlice.create(
                {.transferFee = 100,
                 .ownerCount = 1,
                 .flags = tfMPTCanTransfer,
                 .mutableFlags =
                     tmfMPTCanMutateTransferFee | tmfMPTCanMutateCanTransfer});
 
            BEAST_EXPECT(mptAlice.checkTransferFee(100));
 
            // Clear MPTCanTransfer and transfer fee is removed
            mptAlice.set(
                {.account = alice, .mutableFlags = tmfMPTClearCanTransfer});
            BEAST_EXPECT(!mptAlice.isTransferFeePresent());
 
            // Can still set transfer fee to zero, although it is already zero
            mptAlice.set({.account = alice, .transferFee = 0});
 
            // TransferFee field is still not present
            BEAST_EXPECT(!mptAlice.isTransferFeePresent());
        }
    }
 
    void
    testMutateCanClawback(FeatureBitset features)
    {
        testcase("Mutate MPTCanClawback");
 
        using namespace test::jtx;
        Env env(*this, features);
        Account const alice{"alice"};
        Account const bob{"bob"};
 
        MPTTester mptAlice(env, alice, {.holders = {bob}});
 
        mptAlice.create(
            {.ownerCount = 1,
             .holderCount = 0,
             .mutableFlags = tmfMPTCanMutateCanClawback});
 
        // Bob creates an MPToken
        mptAlice.authorize({.account = bob});
 
        // Alice pays bob 100 tokens
        mptAlice.pay(alice, bob, 100);
 
        // MPTCanClawback is not enabled
        mptAlice.claw(alice, bob, 1, tecNO_PERMISSION);
 
        // Enable MPTCanClawback
        mptAlice.set({.account = alice, .mutableFlags = tmfMPTSetCanClawback});
 
        // Can clawback now
        mptAlice.claw(alice, bob, 1);
 
        // Clear MPTCanClawback
        mptAlice.set(
            {.account = alice, .mutableFlags = tmfMPTClearCanClawback});
 
        // Can not clawback
        mptAlice.claw(alice, bob, 1, tecNO_PERMISSION);
    }
 
public:
    void
    run() override
    {
        using namespace test::jtx;
        FeatureBitset const all{testable_amendments()};
 
        // MPTokenIssuanceCreate
        testCreateValidation(all - featureSingleAssetVault);
        testCreateValidation(all - featurePermissionedDomains);
        testCreateValidation(all);
        testCreateEnabled(all - featureSingleAssetVault);
        testCreateEnabled(all);
 
        // MPTokenIssuanceDestroy
        testDestroyValidation(all - featureSingleAssetVault);
        testDestroyValidation(all);
        testDestroyEnabled(all - featureSingleAssetVault);
        testDestroyEnabled(all);
 
        // MPTokenAuthorize
        testAuthorizeValidation(all - featureSingleAssetVault);
        testAuthorizeValidation(all);
        testAuthorizeEnabled(all - featureSingleAssetVault);
        testAuthorizeEnabled(all);
 
        // MPTokenIssuanceSet
        testSetValidation(all - featureSingleAssetVault - featureDynamicMPT);
        testSetValidation(all - featureSingleAssetVault);
        testSetValidation(all - featureDynamicMPT);
        testSetValidation(all - featurePermissionedDomains);
        testSetValidation(all);
 
        testSetEnabled(all - featureSingleAssetVault);
        testSetEnabled(all);
 
        // MPT clawback
        testClawbackValidation(all);
        testClawback(all);
 
        // Test Direct Payment
        testPayment(all);
        testDepositPreauth(all);
        testDepositPreauth(all - featureCredentials);
 
        // Test MPT Amount is invalid in Tx, which don't support MPT
        testMPTInvalidInTx(all);
 
        // Test parsed MPTokenIssuanceID in API response metadata
        testTxJsonMetaFields(all);
 
        // Test tokens equality
        testTokensEquality();
 
        // Test helpers
        testHelperFunctions();
 
        // Dynamic MPT
        testInvalidCreateDynamic(all);
        testInvalidSetDynamic(all);
        testMutateMPT(all);
        testMutateCanLock(all);
        testMutateRequireAuth(all);
        testMutateCanEscrow(all);
        testMutateCanTransfer(all);
        testMutateCanClawback(all);
    }
};
 
BEAST_DEFINE_TESTSUITE_PRIO(MPToken, app, ripple, 2);
 
}  // namespace test
}  // namespace ripple