rippled/include/xrpl/protocol/detail/transactions.macro

#if !defined(TRANSACTION)
#error "undefined macro: TRANSACTION"
#endif

/**
 * TRANSACTION(tag, value, name, delegable, amendments, privileges, fields)
 *
 * To ease maintenance, you may replace any unneeded values with "..."
 * e.g. #define TRANSACTION(tag, value, name, ...)
 *
 * You must define a transactor class in the `xrpl` namespace named `name`,
 * and include its header alongside the TRANSACTOR definition using this
 * format:
 * #if TRANSACTION_INCLUDE
 * #   include <xrpl/tx/transactors/HEADER.h>
 * #endif
 *
 * The `privileges` parameter of the TRANSACTION macro is a bitfield
 * defining which operations the transaction can perform.
 * The values are defined and used in InvariantCheck.cpp
 */

/** This transaction type executes a payment. */
#if TRANSACTION_INCLUDE
#   include <xrpl/tx/transactors/payment/Payment.h>
#endif
TRANSACTION(ttPAYMENT, 0, Payment,
    Delegation::Delegable,
    uint256{},
    CreateAcct | MayCreateMpt,
    ({
    {sfDestination, SoeRequired},
    {sfAmount, SoeRequired, SoeMptSupported},
    {sfSendMax, SoeOptional, SoeMptSupported},
    {sfPaths, SoeDefault},
    {sfInvoiceID, SoeOptional},
    {sfDestinationTag, SoeOptional},
    {sfDeliverMin, SoeOptional, SoeMptSupported},
    {sfCredentialIDs, SoeOptional},
    {sfDomainID, SoeOptional},
}))

/** This transaction type creates an escrow object. */
#if TRANSACTION_INCLUDE
#   include <xrpl/tx/transactors/escrow/EscrowCreate.h>
#endif
TRANSACTION(ttESCROW_CREATE, 1, EscrowCreate,
    Delegation::Delegable,
    uint256{},
    NoPriv,
    ({
    {sfDestination, SoeRequired},
    {sfAmount, SoeRequired, SoeMptSupported},
    {sfCondition, SoeOptional},
    {sfCancelAfter, SoeOptional},
    {sfFinishAfter, SoeOptional},
    {sfDestinationTag, SoeOptional},
}))

/** This transaction type completes an existing escrow. */
#if TRANSACTION_INCLUDE
#   include <xrpl/tx/transactors/escrow/EscrowFinish.h>
#endif
TRANSACTION(ttESCROW_FINISH, 2, EscrowFinish,
    Delegation::Delegable,
    uint256{},
    NoPriv,
    ({
    {sfOwner, SoeRequired},
    {sfOfferSequence, SoeRequired},
    {sfFulfillment, SoeOptional},
    {sfCondition, SoeOptional},
    {sfCredentialIDs, SoeOptional},
}))


/** This transaction type adjusts various account settings. */
#if TRANSACTION_INCLUDE
#   include <xrpl/tx/transactors/account/AccountSet.h>
#endif
TRANSACTION(ttACCOUNT_SET, 3, AccountSet,
    Delegation::NotDelegable,
    uint256{},
    NoPriv,
    ({
    {sfEmailHash, SoeOptional},
    {sfWalletLocator, SoeOptional},
    {sfWalletSize, SoeOptional},
    {sfMessageKey, SoeOptional},
    {sfDomain, SoeOptional},
    {sfTransferRate, SoeOptional},
    {sfSetFlag, SoeOptional},
    {sfClearFlag, SoeOptional},
    {sfTickSize, SoeOptional},
    {sfNFTokenMinter, SoeOptional},
}))

/** This transaction type cancels an existing escrow. */
#if TRANSACTION_INCLUDE
#   include <xrpl/tx/transactors/escrow/EscrowCancel.h>
#endif
TRANSACTION(ttESCROW_CANCEL, 4, EscrowCancel,
    Delegation::Delegable,
    uint256{},
    NoPriv,
    ({
    {sfOwner, SoeRequired},
    {sfOfferSequence, SoeRequired},
}))

/** This transaction type sets or clears an account's "regular key". */
#if TRANSACTION_INCLUDE
#   include <xrpl/tx/transactors/account/SetRegularKey.h>
#endif
TRANSACTION(ttREGULAR_KEY_SET, 5, SetRegularKey,
    Delegation::NotDelegable,
    uint256{},
    NoPriv,
    ({
    {sfRegularKey, SoeOptional},
}))

// 6 deprecated

/** This transaction type creates an offer to trade one asset for another. */
#if TRANSACTION_INCLUDE
#   include <xrpl/tx/transactors/dex/OfferCreate.h>
#endif
TRANSACTION(ttOFFER_CREATE, 7, OfferCreate,
    Delegation::Delegable,
    uint256{},
    MayCreateMpt,
    ({
    {sfTakerPays, SoeRequired, SoeMptSupported},
    {sfTakerGets, SoeRequired, SoeMptSupported},
    {sfExpiration, SoeOptional},
    {sfOfferSequence, SoeOptional},
    {sfDomainID, SoeOptional},
}))

/** This transaction type cancels existing offers to trade one asset for another. */
#if TRANSACTION_INCLUDE
#   include <xrpl/tx/transactors/dex/OfferCancel.h>
#endif
TRANSACTION(ttOFFER_CANCEL, 8, OfferCancel,
    Delegation::Delegable,
    uint256{},
    NoPriv,
    ({
    {sfOfferSequence, SoeRequired},
}))

// 9 deprecated

/** This transaction type creates a new set of tickets. */
#if TRANSACTION_INCLUDE
#   include <xrpl/tx/transactors/system/TicketCreate.h>
#endif
TRANSACTION(ttTICKET_CREATE, 10, TicketCreate,
    Delegation::Delegable,
    uint256{},
    NoPriv,
    ({
    {sfTicketCount, SoeRequired},
}))

// 11 deprecated

/** This transaction type modifies the signer list associated with an account. */
// The SignerEntries are optional because a SignerList is deleted by
// setting the SignerQuorum to zero and omitting SignerEntries.
#if TRANSACTION_INCLUDE
#   include <xrpl/tx/transactors/account/SignerListSet.h>
#endif
TRANSACTION(ttSIGNER_LIST_SET, 12, SignerListSet,
    Delegation::NotDelegable,
    uint256{},
    NoPriv,
    ({
    {sfSignerQuorum, SoeRequired},
    {sfSignerEntries, SoeOptional},
}))

/** This transaction type creates a new unidirectional XRP payment channel. */
#if TRANSACTION_INCLUDE
#   include <xrpl/tx/transactors/payment_channel/PaymentChannelCreate.h>
#endif
TRANSACTION(ttPAYCHAN_CREATE, 13, PaymentChannelCreate,
    Delegation::Delegable,
    uint256{},
    NoPriv,
    ({
    {sfDestination, SoeRequired},
    {sfAmount, SoeRequired},
    {sfSettleDelay, SoeRequired},
    {sfPublicKey, SoeRequired},
    {sfCancelAfter, SoeOptional},
    {sfDestinationTag, SoeOptional},
}))

/** This transaction type funds an existing unidirectional XRP payment channel. */
#if TRANSACTION_INCLUDE
#   include <xrpl/tx/transactors/payment_channel/PaymentChannelFund.h>
#endif
TRANSACTION(ttPAYCHAN_FUND, 14, PaymentChannelFund,
    Delegation::Delegable,
    uint256{},
    NoPriv,
    ({
    {sfChannel, SoeRequired},
    {sfAmount, SoeRequired},
    {sfExpiration, SoeOptional},
}))

/** This transaction type submits a claim against an existing unidirectional payment channel. */
#if TRANSACTION_INCLUDE
#   include <xrpl/tx/transactors/payment_channel/PaymentChannelClaim.h>
#endif
TRANSACTION(ttPAYCHAN_CLAIM, 15, PaymentChannelClaim,
    Delegation::Delegable,
    uint256{},
    NoPriv,
    ({
    {sfChannel, SoeRequired},
    {sfAmount, SoeOptional},
    {sfBalance, SoeOptional},
    {sfSignature, SoeOptional},
    {sfPublicKey, SoeOptional},
    {sfCredentialIDs, SoeOptional},
}))

/** This transaction type creates a new check. */
#if TRANSACTION_INCLUDE
#   include <xrpl/tx/transactors/check/CheckCreate.h>
#endif
TRANSACTION(ttCHECK_CREATE, 16, CheckCreate,
    Delegation::Delegable,
    uint256{},
    NoPriv,
    ({
    {sfDestination, SoeRequired},
    {sfSendMax, SoeRequired, SoeMptSupported},
    {sfExpiration, SoeOptional},
    {sfDestinationTag, SoeOptional},
    {sfInvoiceID, SoeOptional},
}))

/** This transaction type cashes an existing check. */
#if TRANSACTION_INCLUDE
#   include <xrpl/tx/transactors/check/CheckCash.h>
#endif
TRANSACTION(ttCHECK_CASH, 17, CheckCash,
    Delegation::Delegable,
    uint256{},
    MayCreateMpt,
    ({
    {sfCheckID, SoeRequired},
    {sfAmount, SoeOptional, SoeMptSupported},
    {sfDeliverMin, SoeOptional, SoeMptSupported},
}))

/** This transaction type cancels an existing check. */
#if TRANSACTION_INCLUDE
#   include <xrpl/tx/transactors/check/CheckCancel.h>
#endif
TRANSACTION(ttCHECK_CANCEL, 18, CheckCancel,
    Delegation::Delegable,
    uint256{},
    NoPriv,
    ({
    {sfCheckID, SoeRequired},
}))

/** This transaction type grants or revokes authorization to transfer funds. */
#if TRANSACTION_INCLUDE
#   include <xrpl/tx/transactors/payment/DepositPreauth.h>
#endif
TRANSACTION(ttDEPOSIT_PREAUTH, 19, DepositPreauth,
    Delegation::Delegable,
    uint256{},
    NoPriv,
    ({
    {sfAuthorize, SoeOptional},
    {sfUnauthorize, SoeOptional},
    {sfAuthorizeCredentials, SoeOptional},
    {sfUnauthorizeCredentials, SoeOptional},
}))

/** This transaction type modifies a trustline between two accounts. */
#if TRANSACTION_INCLUDE
#   include <xrpl/tx/transactors/token/TrustSet.h>
#endif
TRANSACTION(ttTRUST_SET, 20, TrustSet,
    Delegation::Delegable,
    uint256{},
    NoPriv,
    ({
    {sfLimitAmount, SoeOptional},
    {sfQualityIn, SoeOptional},
    {sfQualityOut, SoeOptional},
}))

/** This transaction type deletes an existing account. */
#if TRANSACTION_INCLUDE
#   include <xrpl/tx/transactors/account/AccountDelete.h>
#endif
TRANSACTION(ttACCOUNT_DELETE, 21, AccountDelete,
    Delegation::NotDelegable,
    uint256{},
    MustDeleteAcct,
    ({
    {sfDestination, SoeRequired},
    {sfDestinationTag, SoeOptional},
    {sfCredentialIDs, SoeOptional},
}))

// 22 reserved

/** This transaction mints a new NFT. */
#if TRANSACTION_INCLUDE
#   include <xrpl/tx/transactors/nft/NFTokenMint.h>
#endif
TRANSACTION(ttNFTOKEN_MINT, 25, NFTokenMint,
    Delegation::Delegable,
    uint256{},
    ChangeNftCounts,
    ({
    {sfNFTokenTaxon, SoeRequired},
    {sfTransferFee, SoeOptional},
    {sfIssuer, SoeOptional},
    {sfURI, SoeOptional},
    {sfAmount, SoeOptional},
    {sfDestination, SoeOptional},
    {sfExpiration, SoeOptional},
}))

/** This transaction burns (i.e. destroys) an existing NFT. */
#if TRANSACTION_INCLUDE
#   include <xrpl/tx/transactors/nft/NFTokenBurn.h>
#endif
TRANSACTION(ttNFTOKEN_BURN, 26, NFTokenBurn,
    Delegation::Delegable,
    uint256{},
    ChangeNftCounts,
    ({
    {sfNFTokenID, SoeRequired},
    {sfOwner, SoeOptional},
}))

/** This transaction creates a new offer to buy or sell an NFT. */
#if TRANSACTION_INCLUDE
#   include <xrpl/tx/transactors/nft/NFTokenCreateOffer.h>
#endif
TRANSACTION(ttNFTOKEN_CREATE_OFFER, 27, NFTokenCreateOffer,
    Delegation::Delegable,
    uint256{},
    NoPriv,
    ({
    {sfNFTokenID, SoeRequired},
    {sfAmount, SoeRequired},
    {sfDestination, SoeOptional},
    {sfOwner, SoeOptional},
    {sfExpiration, SoeOptional},
}))

/** This transaction cancels an existing offer to buy or sell an existing NFT. */
#if TRANSACTION_INCLUDE
#   include <xrpl/tx/transactors/nft/NFTokenCancelOffer.h>
#endif
TRANSACTION(ttNFTOKEN_CANCEL_OFFER, 28, NFTokenCancelOffer,
    Delegation::Delegable,
    uint256{},
    NoPriv,
    ({
    {sfNFTokenOffers, SoeRequired},
}))

/** This transaction accepts an existing offer to buy or sell an existing  NFT. */
#if TRANSACTION_INCLUDE
#   include <xrpl/tx/transactors/nft/NFTokenAcceptOffer.h>
#endif
TRANSACTION(ttNFTOKEN_ACCEPT_OFFER, 29, NFTokenAcceptOffer,
    Delegation::Delegable,
    uint256{},
    NoPriv,
    ({
    {sfNFTokenBuyOffer, SoeOptional},
    {sfNFTokenSellOffer, SoeOptional},
    {sfNFTokenBrokerFee, SoeOptional},
}))

/** This transaction claws back issued tokens. */
#if TRANSACTION_INCLUDE
#   include <xrpl/tx/transactors/token/Clawback.h>
#endif
TRANSACTION(ttCLAWBACK, 30, Clawback,
    Delegation::Delegable,
    featureClawback,
    NoPriv,
    ({
    {sfAmount, SoeRequired, SoeMptSupported},
    {sfHolder, SoeOptional},
}))

/** This transaction claws back tokens from an AMM pool. */
#if TRANSACTION_INCLUDE
#   include <xrpl/tx/transactors/dex/AMMClawback.h>
#endif
TRANSACTION(ttAMM_CLAWBACK, 31, AMMClawback,
    Delegation::Delegable,
    featureAMMClawback,
    MayDeleteAcct | OverrideFreeze | MayAuthorizeMpt,
    ({
    {sfHolder, SoeRequired},
    {sfAsset, SoeRequired, SoeMptSupported},
    {sfAsset2, SoeRequired, SoeMptSupported},
    {sfAmount, SoeOptional, SoeMptSupported},
}))

/** This transaction type creates an AMM instance */
#if TRANSACTION_INCLUDE
#   include <xrpl/tx/transactors/dex/AMMCreate.h>
#endif
TRANSACTION(ttAMM_CREATE, 35, AMMCreate,
    Delegation::Delegable,
    featureAMM,
    CreatePseudoAcct | MayCreateMpt,
    ({
    {sfAmount, SoeRequired, SoeMptSupported},
    {sfAmount2, SoeRequired, SoeMptSupported},
    {sfTradingFee, SoeRequired},
}))

/** This transaction type deposits into an AMM instance */
#if TRANSACTION_INCLUDE
#   include <xrpl/tx/transactors/dex/AMMDeposit.h>
#endif
TRANSACTION(ttAMM_DEPOSIT, 36, AMMDeposit,
    Delegation::Delegable,
    featureAMM,
    NoPriv,
    ({
    {sfAsset, SoeRequired, SoeMptSupported},
    {sfAsset2, SoeRequired, SoeMptSupported},
    {sfAmount, SoeOptional, SoeMptSupported},
    {sfAmount2, SoeOptional, SoeMptSupported},
    {sfEPrice, SoeOptional},
    {sfLPTokenOut, SoeOptional},
    {sfTradingFee, SoeOptional},
}))

/** This transaction type withdraws from an AMM instance */
#if TRANSACTION_INCLUDE
#   include <xrpl/tx/transactors/dex/AMMWithdraw.h>
#endif
TRANSACTION(ttAMM_WITHDRAW, 37, AMMWithdraw,
    Delegation::Delegable,
    featureAMM,
    MayDeleteAcct | MayAuthorizeMpt,
    ({
    {sfAsset, SoeRequired, SoeMptSupported},
    {sfAsset2, SoeRequired, SoeMptSupported},
    {sfAmount, SoeOptional, SoeMptSupported},
    {sfAmount2, SoeOptional, SoeMptSupported},
    {sfEPrice, SoeOptional},
    {sfLPTokenIn, SoeOptional},
}))

/** This transaction type votes for the trading fee */
#if TRANSACTION_INCLUDE
#   include <xrpl/tx/transactors/dex/AMMVote.h>
#endif
TRANSACTION(ttAMM_VOTE, 38, AMMVote,
    Delegation::Delegable,
    featureAMM,
    NoPriv,
    ({
    {sfAsset, SoeRequired, SoeMptSupported},
    {sfAsset2, SoeRequired, SoeMptSupported},
    {sfTradingFee, SoeRequired},
}))

/** This transaction type bids for the auction slot */
#if TRANSACTION_INCLUDE
#   include <xrpl/tx/transactors/dex/AMMBid.h>
#endif
TRANSACTION(ttAMM_BID, 39, AMMBid,
    Delegation::Delegable,
    featureAMM,
    NoPriv,
    ({
    {sfAsset, SoeRequired, SoeMptSupported},
    {sfAsset2, SoeRequired, SoeMptSupported},
    {sfBidMin, SoeOptional},
    {sfBidMax, SoeOptional},
    {sfAuthAccounts, SoeOptional},
}))

/** This transaction type deletes AMM in the empty state */
#if TRANSACTION_INCLUDE
#   include <xrpl/tx/transactors/dex/AMMDelete.h>
#endif
TRANSACTION(ttAMM_DELETE, 40, AMMDelete,
    Delegation::Delegable,
    featureAMM,
    MustDeleteAcct | MayDeleteMpt,
    ({
    {sfAsset, SoeRequired, SoeMptSupported},
    {sfAsset2, SoeRequired, SoeMptSupported},
}))

/** This transactions creates a crosschain sequence number */
#if TRANSACTION_INCLUDE
#   include <xrpl/tx/transactors/bridge/XChainBridge.h>
#endif
TRANSACTION(ttXCHAIN_CREATE_CLAIM_ID, 41, XChainCreateClaimID,
    Delegation::Delegable,
    featureXChainBridge,
    NoPriv,
    ({
    {sfXChainBridge, SoeRequired},
    {sfSignatureReward, SoeRequired},
    {sfOtherChainSource, SoeRequired},
}))

/** This transactions initiates a crosschain transaction */
TRANSACTION(ttXCHAIN_COMMIT, 42, XChainCommit,
    Delegation::Delegable,
    featureXChainBridge,
    NoPriv,
    ({
    {sfXChainBridge, SoeRequired},
    {sfXChainClaimID, SoeRequired},
    {sfAmount, SoeRequired},
    {sfOtherChainDestination, SoeOptional},
}))

/** This transaction completes a crosschain transaction */
TRANSACTION(ttXCHAIN_CLAIM, 43, XChainClaim,
    Delegation::Delegable,
    featureXChainBridge,
    NoPriv,
    ({
    {sfXChainBridge, SoeRequired},
    {sfXChainClaimID, SoeRequired},
    {sfDestination, SoeRequired},
    {sfDestinationTag, SoeOptional},
    {sfAmount, SoeRequired},
}))

/** This transaction initiates a crosschain account create transaction */
TRANSACTION(ttXCHAIN_ACCOUNT_CREATE_COMMIT, 44, XChainAccountCreateCommit,
    Delegation::Delegable,
    featureXChainBridge,
    NoPriv,
    ({
    {sfXChainBridge, SoeRequired},
    {sfDestination, SoeRequired},
    {sfAmount, SoeRequired},
    {sfSignatureReward, SoeRequired},
}))

/** This transaction adds an attestation to a claim */
TRANSACTION(ttXCHAIN_ADD_CLAIM_ATTESTATION, 45, XChainAddClaimAttestation,
    Delegation::Delegable,
    featureXChainBridge,
    CreateAcct,
    ({
    {sfXChainBridge, SoeRequired},

    {sfAttestationSignerAccount, SoeRequired},
    {sfPublicKey, SoeRequired},
    {sfSignature, SoeRequired},
    {sfOtherChainSource, SoeRequired},
    {sfAmount, SoeRequired},
    {sfAttestationRewardAccount, SoeRequired},
    {sfWasLockingChainSend, SoeRequired},

    {sfXChainClaimID, SoeRequired},
    {sfDestination, SoeOptional},
}))

/** This transaction adds an attestation to an account */
TRANSACTION(ttXCHAIN_ADD_ACCOUNT_CREATE_ATTESTATION, 46,
    XChainAddAccountCreateAttestation,
    Delegation::Delegable,
    featureXChainBridge,
    CreateAcct,
    ({
    {sfXChainBridge, SoeRequired},

    {sfAttestationSignerAccount, SoeRequired},
    {sfPublicKey, SoeRequired},
    {sfSignature, SoeRequired},
    {sfOtherChainSource, SoeRequired},
    {sfAmount, SoeRequired},
    {sfAttestationRewardAccount, SoeRequired},
    {sfWasLockingChainSend, SoeRequired},

    {sfXChainAccountCreateCount, SoeRequired},
    {sfDestination, SoeRequired},
    {sfSignatureReward, SoeRequired},
}))

/** This transaction modifies a sidechain */
TRANSACTION(ttXCHAIN_MODIFY_BRIDGE, 47, XChainModifyBridge,
    Delegation::Delegable,
    featureXChainBridge,
    NoPriv,
    ({
    {sfXChainBridge, SoeRequired},
    {sfSignatureReward, SoeOptional},
    {sfMinAccountCreateAmount, SoeOptional},
}))

/** This transactions creates a sidechain */
TRANSACTION(ttXCHAIN_CREATE_BRIDGE, 48, XChainCreateBridge,
    Delegation::Delegable,
    featureXChainBridge,
    NoPriv,
    ({
    {sfXChainBridge, SoeRequired},
    {sfSignatureReward, SoeRequired},
    {sfMinAccountCreateAmount, SoeOptional},
}))

/** This transaction type creates or updates a DID */
#if TRANSACTION_INCLUDE
#   include <xrpl/tx/transactors/did/DIDSet.h>
#endif
TRANSACTION(ttDID_SET, 49, DIDSet,
    Delegation::Delegable,
    featureDID,
    NoPriv,
    ({
    {sfDIDDocument, SoeOptional},
    {sfURI, SoeOptional},
    {sfData, SoeOptional},
}))

/** This transaction type deletes a DID */
#if TRANSACTION_INCLUDE
#   include <xrpl/tx/transactors/did/DIDDelete.h>
#endif
TRANSACTION(ttDID_DELETE, 50, DIDDelete,
    Delegation::Delegable,
    featureDID,
    NoPriv,
    ({}))

/** This transaction type creates an Oracle instance */
#if TRANSACTION_INCLUDE
#   include <xrpl/tx/transactors/oracle/OracleSet.h>
#endif
TRANSACTION(ttORACLE_SET, 51, OracleSet,
    Delegation::Delegable,
    featurePriceOracle,
    NoPriv,
    ({
    {sfOracleDocumentID, SoeRequired},
    {sfProvider, SoeOptional},
    {sfURI, SoeOptional},
    {sfAssetClass, SoeOptional},
    {sfLastUpdateTime, SoeRequired},
    {sfPriceDataSeries, SoeRequired},
}))

/** This transaction type deletes an Oracle instance */
#if TRANSACTION_INCLUDE
#   include <xrpl/tx/transactors/oracle/OracleDelete.h>
#endif
TRANSACTION(ttORACLE_DELETE, 52, OracleDelete,
    Delegation::Delegable,
    featurePriceOracle,
    NoPriv,
    ({
    {sfOracleDocumentID, SoeRequired},
}))

/** This transaction type fixes a problem in the ledger state */
#if TRANSACTION_INCLUDE
#   include <xrpl/tx/transactors/system/LedgerStateFix.h>
#endif
TRANSACTION(ttLEDGER_STATE_FIX, 53, LedgerStateFix,
    Delegation::Delegable,
    fixNFTokenPageLinks,
    NoPriv,
    ({
    {sfLedgerFixType, SoeRequired},
    {sfOwner, SoeOptional},
    {sfBookDirectory, SoeOptional},
}))

/** This transaction type creates a MPTokensIssuance instance */
#if TRANSACTION_INCLUDE
#   include <xrpl/tx/transactors/token/MPTokenIssuanceCreate.h>
#endif
TRANSACTION(ttMPTOKEN_ISSUANCE_CREATE, 54, MPTokenIssuanceCreate,
    Delegation::Delegable,
    featureMPTokensV1,
    CreateMptIssuance,
    ({
    {sfAssetScale, SoeOptional},
    {sfTransferFee, SoeOptional},
    {sfMaximumAmount, SoeOptional},
    {sfMPTokenMetadata, SoeOptional},
    {sfDomainID, SoeOptional},
    {sfMutableFlags, SoeOptional},
}))

/** This transaction type destroys a MPTokensIssuance instance */
#if TRANSACTION_INCLUDE
#   include <xrpl/tx/transactors/token/MPTokenIssuanceDestroy.h>
#endif
TRANSACTION(ttMPTOKEN_ISSUANCE_DESTROY, 55, MPTokenIssuanceDestroy,
    Delegation::Delegable,
    featureMPTokensV1,
    DestroyMptIssuance,
    ({
    {sfMPTokenIssuanceID, SoeRequired},
}))

/** This transaction type sets flags on a MPTokensIssuance or MPToken instance */
#if TRANSACTION_INCLUDE
#   include <xrpl/tx/transactors/token/MPTokenIssuanceSet.h>
#endif
TRANSACTION(ttMPTOKEN_ISSUANCE_SET, 56, MPTokenIssuanceSet,
    Delegation::Delegable,
    featureMPTokensV1,
    NoPriv,
    ({
    {sfMPTokenIssuanceID, SoeRequired},
    {sfHolder, SoeOptional},
    {sfDomainID, SoeOptional},
    {sfMPTokenMetadata, SoeOptional},
    {sfTransferFee, SoeOptional},
    {sfMutableFlags, SoeOptional},
}))

/** This transaction type authorizes a MPToken instance */
#if TRANSACTION_INCLUDE
#   include <xrpl/tx/transactors/token/MPTokenAuthorize.h>
#endif
TRANSACTION(ttMPTOKEN_AUTHORIZE, 57, MPTokenAuthorize,
    Delegation::Delegable,
    featureMPTokensV1,
    MustAuthorizeMpt,
    ({
    {sfMPTokenIssuanceID, SoeRequired},
    {sfHolder, SoeOptional},
}))

/** This transaction type create an Credential instance */
#if TRANSACTION_INCLUDE
#   include <xrpl/tx/transactors/credentials/CredentialCreate.h>
#endif
TRANSACTION(ttCREDENTIAL_CREATE, 58, CredentialCreate,
    Delegation::Delegable,
    featureCredentials,
    NoPriv,
    ({
    {sfSubject, SoeRequired},
    {sfCredentialType, SoeRequired},
    {sfExpiration, SoeOptional},
    {sfURI, SoeOptional},
}))

/** This transaction type accept an Credential object */
#if TRANSACTION_INCLUDE
#   include <xrpl/tx/transactors/credentials/CredentialAccept.h>
#endif
TRANSACTION(ttCREDENTIAL_ACCEPT, 59, CredentialAccept,
    Delegation::Delegable,
    featureCredentials,
    NoPriv,
    ({
    {sfIssuer, SoeRequired},
    {sfCredentialType, SoeRequired},
}))

/** This transaction type delete an Credential object */
#if TRANSACTION_INCLUDE
#   include <xrpl/tx/transactors/credentials/CredentialDelete.h>
#endif
TRANSACTION(ttCREDENTIAL_DELETE, 60, CredentialDelete,
    Delegation::Delegable,
    featureCredentials,
    NoPriv,
    ({
    {sfSubject, SoeOptional},
    {sfIssuer, SoeOptional},
    {sfCredentialType, SoeRequired},
}))

/** This transaction type modify a NFToken */
#if TRANSACTION_INCLUDE
#   include <xrpl/tx/transactors/nft/NFTokenModify.h>
#endif
TRANSACTION(ttNFTOKEN_MODIFY, 61, NFTokenModify,
    Delegation::Delegable,
    featureDynamicNFT,
    NoPriv,
    ({
    {sfNFTokenID, SoeRequired},
    {sfOwner, SoeOptional},
    {sfURI, SoeOptional},
}))

/** This transaction type creates or modifies a Permissioned Domain */
#if TRANSACTION_INCLUDE
#   include <xrpl/tx/transactors/permissioned_domain/PermissionedDomainSet.h>
#endif
TRANSACTION(ttPERMISSIONED_DOMAIN_SET, 62, PermissionedDomainSet,
    Delegation::Delegable,
    featurePermissionedDomains,
    NoPriv,
    ({
    {sfDomainID, SoeOptional},
    {sfAcceptedCredentials, SoeRequired},
}))

/** This transaction type deletes a Permissioned Domain */
#if TRANSACTION_INCLUDE
#   include <xrpl/tx/transactors/permissioned_domain/PermissionedDomainDelete.h>
#endif
TRANSACTION(ttPERMISSIONED_DOMAIN_DELETE, 63, PermissionedDomainDelete,
    Delegation::Delegable,
    featurePermissionedDomains,
    NoPriv,
    ({
    {sfDomainID, SoeRequired},
}))

/** This transaction type delegates authorized account specified permissions */
#if TRANSACTION_INCLUDE
#   include <xrpl/tx/transactors/delegate/DelegateSet.h>
#endif
TRANSACTION(ttDELEGATE_SET, 64, DelegateSet,
    Delegation::NotDelegable,
    featurePermissionDelegationV1_1,
    NoPriv,
    ({
    {sfAuthorize, SoeRequired},
    {sfPermissions, SoeRequired},
}))

/** This transaction creates a single asset vault. */
#if TRANSACTION_INCLUDE
#   include <xrpl/tx/transactors/vault/VaultCreate.h>
#endif
TRANSACTION(ttVAULT_CREATE, 65, VaultCreate,
    Delegation::NotDelegable,
    featureSingleAssetVault,
    CreatePseudoAcct | CreateMptIssuance | MustModifyVault,
    ({
    {sfAsset, SoeRequired, SoeMptSupported},
    {sfAssetsMaximum, SoeOptional},
    {sfMPTokenMetadata, SoeOptional},
    {sfDomainID, SoeOptional},
    {sfWithdrawalPolicy, SoeOptional},
    {sfData, SoeOptional},
    {sfScale, SoeOptional},
}))

/** This transaction updates a single asset vault. */
#if TRANSACTION_INCLUDE
#   include <xrpl/tx/transactors/vault/VaultSet.h>
#endif
TRANSACTION(ttVAULT_SET, 66, VaultSet,
    Delegation::NotDelegable,
    featureSingleAssetVault,
    MustModifyVault,
    ({
    {sfVaultID, SoeRequired},
    {sfAssetsMaximum, SoeOptional},
    {sfDomainID, SoeOptional},
    {sfData, SoeOptional},
}))

/** This transaction deletes a single asset vault. */
#if TRANSACTION_INCLUDE
#   include <xrpl/tx/transactors/vault/VaultDelete.h>
#endif
TRANSACTION(ttVAULT_DELETE, 67, VaultDelete,
    Delegation::NotDelegable,
    featureSingleAssetVault,
    MustDeleteAcct | DestroyMptIssuance | MustModifyVault,
    ({
    {sfVaultID, SoeRequired},
}))

/** This transaction trades assets for shares with a vault. */
#if TRANSACTION_INCLUDE
#   include <xrpl/tx/transactors/vault/VaultDeposit.h>
#endif
TRANSACTION(ttVAULT_DEPOSIT, 68, VaultDeposit,
    Delegation::NotDelegable,
    featureSingleAssetVault,
    MayAuthorizeMpt | MustModifyVault,
    ({
    {sfVaultID, SoeRequired},
    {sfAmount, SoeRequired, SoeMptSupported},
}))

/** This transaction trades shares for assets with a vault. */
#if TRANSACTION_INCLUDE
#   include <xrpl/tx/transactors/vault/VaultWithdraw.h>
#endif
TRANSACTION(ttVAULT_WITHDRAW, 69, VaultWithdraw,
    Delegation::NotDelegable,
    featureSingleAssetVault,
    MayDeleteMpt | MayAuthorizeMpt | MustModifyVault,
    ({
    {sfVaultID, SoeRequired},
    {sfAmount, SoeRequired, SoeMptSupported},
    {sfDestination, SoeOptional},
    {sfDestinationTag, SoeOptional},
}))

/** This transaction claws back tokens from a vault. */
#if TRANSACTION_INCLUDE
#   include <xrpl/tx/transactors/vault/VaultClawback.h>
#endif
TRANSACTION(ttVAULT_CLAWBACK, 70, VaultClawback,
    Delegation::NotDelegable,
    featureSingleAssetVault,
    MayDeleteMpt | MustModifyVault,
    ({
    {sfVaultID, SoeRequired},
    {sfHolder, SoeRequired},
    {sfAmount, SoeOptional, SoeMptSupported},
}))

/** This transaction type batches together transactions. */
#if TRANSACTION_INCLUDE
#   include <xrpl/tx/transactors/system/Batch.h>
#endif
TRANSACTION(ttBATCH, 71, Batch,
    Delegation::NotDelegable,
    featureBatch,
    NoPriv,
    ({
    {sfRawTransactions, SoeRequired},
    {sfBatchSigners, SoeOptional},
}))

/** Reserve 72-73 for future Vault-related transactions */

/** This transaction creates and updates a Loan Broker */
#if TRANSACTION_INCLUDE
#   include <xrpl/tx/transactors/lending/LoanBrokerSet.h>
#endif
TRANSACTION(ttLOAN_BROKER_SET, 74, LoanBrokerSet,
    Delegation::NotDelegable,
    featureLendingProtocol,
    CreatePseudoAcct | MayAuthorizeMpt, ({
    {sfVaultID, SoeRequired},
    {sfLoanBrokerID, SoeOptional},
    {sfData, SoeOptional},
    {sfManagementFeeRate, SoeOptional},
    {sfDebtMaximum, SoeOptional},
    {sfCoverRateMinimum, SoeOptional},
    {sfCoverRateLiquidation, SoeOptional},
}))

/** This transaction deletes a Loan Broker */
#if TRANSACTION_INCLUDE
#   include <xrpl/tx/transactors/lending/LoanBrokerDelete.h>
#endif
TRANSACTION(ttLOAN_BROKER_DELETE, 75, LoanBrokerDelete,
    Delegation::NotDelegable,
    featureLendingProtocol,
    MustDeleteAcct | MayAuthorizeMpt, ({
    {sfLoanBrokerID, SoeRequired},
}))

/** This transaction deposits First Loss Capital into a Loan Broker */
#if TRANSACTION_INCLUDE
#   include <xrpl/tx/transactors/lending/LoanBrokerCoverDeposit.h>
#endif
TRANSACTION(ttLOAN_BROKER_COVER_DEPOSIT, 76, LoanBrokerCoverDeposit,
    Delegation::NotDelegable,
    featureLendingProtocol,
    NoPriv, ({
    {sfLoanBrokerID, SoeRequired},
    {sfAmount, SoeRequired, SoeMptSupported},
}))

/** This transaction withdraws First Loss Capital from a Loan Broker */
#if TRANSACTION_INCLUDE
#   include <xrpl/tx/transactors/lending/LoanBrokerCoverWithdraw.h>
#endif
TRANSACTION(ttLOAN_BROKER_COVER_WITHDRAW, 77, LoanBrokerCoverWithdraw,
    Delegation::NotDelegable,
    featureLendingProtocol,
    MayAuthorizeMpt, ({
    {sfLoanBrokerID, SoeRequired},
    {sfAmount, SoeRequired, SoeMptSupported},
    {sfDestination, SoeOptional},
    {sfDestinationTag, SoeOptional},
}))

/** This transaction claws back First Loss Capital from a Loan Broker to
    the issuer of the capital */
#if TRANSACTION_INCLUDE
#   include <xrpl/tx/transactors/lending/LoanBrokerCoverClawback.h>
#endif
TRANSACTION(ttLOAN_BROKER_COVER_CLAWBACK, 78, LoanBrokerCoverClawback,
    Delegation::NotDelegable,
    featureLendingProtocol,
    NoPriv, ({
    {sfLoanBrokerID, SoeOptional},
    {sfAmount, SoeOptional, SoeMptSupported},
}))

/** This transaction creates a Loan */
#if TRANSACTION_INCLUDE
#   include <xrpl/tx/transactors/lending/LoanSet.h>
#endif
TRANSACTION(ttLOAN_SET, 80, LoanSet,
    Delegation::NotDelegable,
    featureLendingProtocol,
    MayAuthorizeMpt | MustModifyVault, ({
    {sfLoanBrokerID, SoeRequired},
    {sfData, SoeOptional},
    {sfCounterparty, SoeOptional},
    {sfCounterpartySignature, SoeOptional},
    {sfLoanOriginationFee, SoeOptional},
    {sfLoanServiceFee, SoeOptional},
    {sfLatePaymentFee, SoeOptional},
    {sfClosePaymentFee, SoeOptional},
    {sfOverpaymentFee, SoeOptional},
    {sfInterestRate, SoeOptional},
    {sfLateInterestRate, SoeOptional},
    {sfCloseInterestRate, SoeOptional},
    {sfOverpaymentInterestRate, SoeOptional},
    {sfPrincipalRequested, SoeRequired},
    {sfPaymentTotal, SoeOptional},
    {sfPaymentInterval, SoeOptional},
    {sfGracePeriod, SoeOptional},
}))

/** This transaction deletes an existing Loan */
#if TRANSACTION_INCLUDE
#   include <xrpl/tx/transactors/lending/LoanDelete.h>
#endif
TRANSACTION(ttLOAN_DELETE, 81, LoanDelete,
    Delegation::NotDelegable,
    featureLendingProtocol,
    NoPriv, ({
    {sfLoanID, SoeRequired},
}))

/** This transaction is used to change the delinquency status of an existing Loan */
#if TRANSACTION_INCLUDE
#   include <xrpl/tx/transactors/lending/LoanManage.h>
#endif
TRANSACTION(ttLOAN_MANAGE, 82, LoanManage,
    Delegation::NotDelegable,
    featureLendingProtocol,
    // All of the LoanManage options will modify the vault, but the
    // transaction can succeed without options, essentially making it
    // a noop.
    MayModifyVault, ({
    {sfLoanID, SoeRequired},
}))

/** The Borrower uses this transaction to make a Payment on the Loan. */
#if TRANSACTION_INCLUDE
#   include <xrpl/tx/transactors/lending/LoanPay.h>
#endif
TRANSACTION(ttLOAN_PAY, 84, LoanPay,
    Delegation::NotDelegable,
    featureLendingProtocol,
    MayAuthorizeMpt | MustModifyVault, ({
    {sfLoanID, SoeRequired},
    {sfAmount, SoeRequired, SoeMptSupported},
}))

/** This system-generated transaction type is used to update the status of the various amendments.

    For details, see: https://xrpl.org/amendments.html
 */
#if TRANSACTION_INCLUDE
#   include <xrpl/tx/transactors/system/Change.h>
#endif
TRANSACTION(ttAMENDMENT, 100, EnableAmendment,
    Delegation::NotDelegable,
    uint256{},
    NoPriv,
    ({
    {sfLedgerSequence, SoeRequired},
    {sfAmendment, SoeRequired},
}))

/** This system-generated transaction type is used to update the network's fee settings.
    For details, see: https://xrpl.org/fee-voting.html
 */
TRANSACTION(ttFEE, 101, SetFee,
    Delegation::NotDelegable,
    uint256{},
    NoPriv,
    ({
    {sfLedgerSequence, SoeOptional},
    // Old version uses raw numbers
    {sfBaseFee, SoeOptional},
    {sfReferenceFeeUnits, SoeOptional},
    {sfReserveBase, SoeOptional},
    {sfReserveIncrement, SoeOptional},
    // New version uses Amounts
    {sfBaseFeeDrops, SoeOptional},
    {sfReserveBaseDrops, SoeOptional},
    {sfReserveIncrementDrops, SoeOptional},
}))

/** This system-generated transaction type is used to update the network's negative UNL

    For details, see: https://xrpl.org/negative-unl.html
 */
TRANSACTION(ttUNL_MODIFY, 102, UNLModify,
    Delegation::NotDelegable,
    uint256{},
    NoPriv,
    ({
    {sfUNLModifyDisabling, SoeRequired},
    {sfLedgerSequence, SoeRequired},
    {sfUNLModifyValidator, SoeRequired},
}))