mirror of
https://github.com/XRPLF/rippled.git
synced 2025-11-18 18:15:50 +00:00
80d82c5b2b
This change adds support for `DomainID` to existing transactions `MPTokenIssuanceCreate` and `MPTokenIssuanceSet`. In #5224 `DomainID` was added as an access control mechanism for `SingleAssetVault`. The actual implementation of this feature lies in `MPToken` and `MPTokenIssuance`, hence it makes sense to enable the use of `DomainID` also in `MPTokenIssuanceCreate` and `MPTokenIssuanceSet`, following same rules as in Vault: * `MPTokenIssuanceCreate` and `MPTokenIssuanceSet` can only set `DomainID` if flag `MPTRequireAuth` is set. * `MPTokenIssuanceCreate` requires that `DomainID` be a non-zero, uint256 number. * `MPTokenIssuanceSet` allows `DomainID` to be zero (or empty) in which case it will remove `DomainID` from the `MPTokenIssuance` object. The change is amendment-gated by `SingleAssetVault`. This is a non-breaking change because `SingleAssetVault` amendment is `Supported::no`, i.e. at this moment considered a work in progress, which cannot be enabled on the network.
561 lines
19 KiB
Plaintext
561 lines
19 KiB
Plaintext
//------------------------------------------------------------------------------
|
|
/*
|
|
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.
|
|
*/
|
|
//==============================================================================
|
|
|
|
#if !defined(TRANSACTION)
|
|
#error "undefined macro: TRANSACTION"
|
|
#endif
|
|
|
|
/**
|
|
* TRANSACTION(tag, value, name, delegatable, fields)
|
|
*
|
|
* You must define a transactor class in the `ripple` namespace named `name`,
|
|
* and include its header in `src/xrpld/app/tx/detail/applySteps.cpp`.
|
|
*/
|
|
|
|
/** This transaction type executes a payment. */
|
|
TRANSACTION(ttPAYMENT, 0, Payment, Delegation::delegatable, ({
|
|
{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. */
|
|
TRANSACTION(ttESCROW_CREATE, 1, EscrowCreate, Delegation::delegatable, ({
|
|
{sfDestination, soeREQUIRED},
|
|
{sfAmount, soeREQUIRED, soeMPTSupported},
|
|
{sfCondition, soeOPTIONAL},
|
|
{sfCancelAfter, soeOPTIONAL},
|
|
{sfFinishAfter, soeOPTIONAL},
|
|
{sfDestinationTag, soeOPTIONAL},
|
|
}))
|
|
|
|
/** This transaction type completes an existing escrow. */
|
|
TRANSACTION(ttESCROW_FINISH, 2, EscrowFinish, Delegation::delegatable, ({
|
|
{sfOwner, soeREQUIRED},
|
|
{sfOfferSequence, soeREQUIRED},
|
|
{sfFulfillment, soeOPTIONAL},
|
|
{sfCondition, soeOPTIONAL},
|
|
{sfCredentialIDs, soeOPTIONAL},
|
|
}))
|
|
|
|
|
|
/** This transaction type adjusts various account settings. */
|
|
TRANSACTION(ttACCOUNT_SET, 3, AccountSet, Delegation::notDelegatable, ({
|
|
{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. */
|
|
TRANSACTION(ttESCROW_CANCEL, 4, EscrowCancel, Delegation::delegatable, ({
|
|
{sfOwner, soeREQUIRED},
|
|
{sfOfferSequence, soeREQUIRED},
|
|
}))
|
|
|
|
/** This transaction type sets or clears an account's "regular key". */
|
|
TRANSACTION(ttREGULAR_KEY_SET, 5, SetRegularKey, Delegation::notDelegatable, ({
|
|
{sfRegularKey, soeOPTIONAL},
|
|
}))
|
|
|
|
// 6 deprecated
|
|
|
|
/** This transaction type creates an offer to trade one asset for another. */
|
|
TRANSACTION(ttOFFER_CREATE, 7, OfferCreate, Delegation::delegatable, ({
|
|
{sfTakerPays, soeREQUIRED},
|
|
{sfTakerGets, soeREQUIRED},
|
|
{sfExpiration, soeOPTIONAL},
|
|
{sfOfferSequence, soeOPTIONAL},
|
|
{sfDomainID, soeOPTIONAL},
|
|
}))
|
|
|
|
/** This transaction type cancels existing offers to trade one asset for another. */
|
|
TRANSACTION(ttOFFER_CANCEL, 8, OfferCancel, Delegation::delegatable, ({
|
|
{sfOfferSequence, soeREQUIRED},
|
|
}))
|
|
|
|
// 9 deprecated
|
|
|
|
/** This transaction type creates a new set of tickets. */
|
|
TRANSACTION(ttTICKET_CREATE, 10, TicketCreate, Delegation::delegatable, ({
|
|
{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.
|
|
TRANSACTION(ttSIGNER_LIST_SET, 12, SignerListSet, Delegation::notDelegatable, ({
|
|
{sfSignerQuorum, soeREQUIRED},
|
|
{sfSignerEntries, soeOPTIONAL},
|
|
}))
|
|
|
|
/** This transaction type creates a new unidirectional XRP payment channel. */
|
|
TRANSACTION(ttPAYCHAN_CREATE, 13, PaymentChannelCreate, Delegation::delegatable, ({
|
|
{sfDestination, soeREQUIRED},
|
|
{sfAmount, soeREQUIRED},
|
|
{sfSettleDelay, soeREQUIRED},
|
|
{sfPublicKey, soeREQUIRED},
|
|
{sfCancelAfter, soeOPTIONAL},
|
|
{sfDestinationTag, soeOPTIONAL},
|
|
}))
|
|
|
|
/** This transaction type funds an existing unidirectional XRP payment channel. */
|
|
TRANSACTION(ttPAYCHAN_FUND, 14, PaymentChannelFund, Delegation::delegatable, ({
|
|
{sfChannel, soeREQUIRED},
|
|
{sfAmount, soeREQUIRED},
|
|
{sfExpiration, soeOPTIONAL},
|
|
}))
|
|
|
|
/** This transaction type submits a claim against an existing unidirectional payment channel. */
|
|
TRANSACTION(ttPAYCHAN_CLAIM, 15, PaymentChannelClaim, Delegation::delegatable, ({
|
|
{sfChannel, soeREQUIRED},
|
|
{sfAmount, soeOPTIONAL},
|
|
{sfBalance, soeOPTIONAL},
|
|
{sfSignature, soeOPTIONAL},
|
|
{sfPublicKey, soeOPTIONAL},
|
|
{sfCredentialIDs, soeOPTIONAL},
|
|
}))
|
|
|
|
/** This transaction type creates a new check. */
|
|
TRANSACTION(ttCHECK_CREATE, 16, CheckCreate, Delegation::delegatable, ({
|
|
{sfDestination, soeREQUIRED},
|
|
{sfSendMax, soeREQUIRED},
|
|
{sfExpiration, soeOPTIONAL},
|
|
{sfDestinationTag, soeOPTIONAL},
|
|
{sfInvoiceID, soeOPTIONAL},
|
|
}))
|
|
|
|
/** This transaction type cashes an existing check. */
|
|
TRANSACTION(ttCHECK_CASH, 17, CheckCash, Delegation::delegatable, ({
|
|
{sfCheckID, soeREQUIRED},
|
|
{sfAmount, soeOPTIONAL},
|
|
{sfDeliverMin, soeOPTIONAL},
|
|
}))
|
|
|
|
/** This transaction type cancels an existing check. */
|
|
TRANSACTION(ttCHECK_CANCEL, 18, CheckCancel, Delegation::delegatable, ({
|
|
{sfCheckID, soeREQUIRED},
|
|
}))
|
|
|
|
/** This transaction type grants or revokes authorization to transfer funds. */
|
|
TRANSACTION(ttDEPOSIT_PREAUTH, 19, DepositPreauth, Delegation::delegatable, ({
|
|
{sfAuthorize, soeOPTIONAL},
|
|
{sfUnauthorize, soeOPTIONAL},
|
|
{sfAuthorizeCredentials, soeOPTIONAL},
|
|
{sfUnauthorizeCredentials, soeOPTIONAL},
|
|
}))
|
|
|
|
/** This transaction type modifies a trustline between two accounts. */
|
|
TRANSACTION(ttTRUST_SET, 20, TrustSet, Delegation::delegatable, ({
|
|
{sfLimitAmount, soeOPTIONAL},
|
|
{sfQualityIn, soeOPTIONAL},
|
|
{sfQualityOut, soeOPTIONAL},
|
|
}))
|
|
|
|
/** This transaction type deletes an existing account. */
|
|
TRANSACTION(ttACCOUNT_DELETE, 21, AccountDelete, Delegation::notDelegatable, ({
|
|
{sfDestination, soeREQUIRED},
|
|
{sfDestinationTag, soeOPTIONAL},
|
|
{sfCredentialIDs, soeOPTIONAL},
|
|
}))
|
|
|
|
// 22 reserved
|
|
|
|
/** This transaction mints a new NFT. */
|
|
TRANSACTION(ttNFTOKEN_MINT, 25, NFTokenMint, Delegation::delegatable, ({
|
|
{sfNFTokenTaxon, soeREQUIRED},
|
|
{sfTransferFee, soeOPTIONAL},
|
|
{sfIssuer, soeOPTIONAL},
|
|
{sfURI, soeOPTIONAL},
|
|
{sfAmount, soeOPTIONAL},
|
|
{sfDestination, soeOPTIONAL},
|
|
{sfExpiration, soeOPTIONAL},
|
|
}))
|
|
|
|
/** This transaction burns (i.e. destroys) an existing NFT. */
|
|
TRANSACTION(ttNFTOKEN_BURN, 26, NFTokenBurn, Delegation::delegatable, ({
|
|
{sfNFTokenID, soeREQUIRED},
|
|
{sfOwner, soeOPTIONAL},
|
|
}))
|
|
|
|
/** This transaction creates a new offer to buy or sell an NFT. */
|
|
TRANSACTION(ttNFTOKEN_CREATE_OFFER, 27, NFTokenCreateOffer, Delegation::delegatable, ({
|
|
{sfNFTokenID, soeREQUIRED},
|
|
{sfAmount, soeREQUIRED},
|
|
{sfDestination, soeOPTIONAL},
|
|
{sfOwner, soeOPTIONAL},
|
|
{sfExpiration, soeOPTIONAL},
|
|
}))
|
|
|
|
/** This transaction cancels an existing offer to buy or sell an existing NFT. */
|
|
TRANSACTION(ttNFTOKEN_CANCEL_OFFER, 28, NFTokenCancelOffer, Delegation::delegatable, ({
|
|
{sfNFTokenOffers, soeREQUIRED},
|
|
}))
|
|
|
|
/** This transaction accepts an existing offer to buy or sell an existing NFT. */
|
|
TRANSACTION(ttNFTOKEN_ACCEPT_OFFER, 29, NFTokenAcceptOffer, Delegation::delegatable, ({
|
|
{sfNFTokenBuyOffer, soeOPTIONAL},
|
|
{sfNFTokenSellOffer, soeOPTIONAL},
|
|
{sfNFTokenBrokerFee, soeOPTIONAL},
|
|
}))
|
|
|
|
/** This transaction claws back issued tokens. */
|
|
TRANSACTION(ttCLAWBACK, 30, Clawback, Delegation::delegatable, ({
|
|
{sfAmount, soeREQUIRED, soeMPTSupported},
|
|
{sfHolder, soeOPTIONAL},
|
|
}))
|
|
|
|
/** This transaction claws back tokens from an AMM pool. */
|
|
TRANSACTION(ttAMM_CLAWBACK, 31, AMMClawback, Delegation::delegatable, ({
|
|
{sfHolder, soeREQUIRED},
|
|
{sfAsset, soeREQUIRED},
|
|
{sfAsset2, soeREQUIRED},
|
|
{sfAmount, soeOPTIONAL},
|
|
}))
|
|
|
|
/** This transaction type creates an AMM instance */
|
|
TRANSACTION(ttAMM_CREATE, 35, AMMCreate, Delegation::delegatable, ({
|
|
{sfAmount, soeREQUIRED},
|
|
{sfAmount2, soeREQUIRED},
|
|
{sfTradingFee, soeREQUIRED},
|
|
}))
|
|
|
|
/** This transaction type deposits into an AMM instance */
|
|
TRANSACTION(ttAMM_DEPOSIT, 36, AMMDeposit, Delegation::delegatable, ({
|
|
{sfAsset, soeREQUIRED},
|
|
{sfAsset2, soeREQUIRED},
|
|
{sfAmount, soeOPTIONAL},
|
|
{sfAmount2, soeOPTIONAL},
|
|
{sfEPrice, soeOPTIONAL},
|
|
{sfLPTokenOut, soeOPTIONAL},
|
|
{sfTradingFee, soeOPTIONAL},
|
|
}))
|
|
|
|
/** This transaction type withdraws from an AMM instance */
|
|
TRANSACTION(ttAMM_WITHDRAW, 37, AMMWithdraw, Delegation::delegatable, ({
|
|
{sfAsset, soeREQUIRED},
|
|
{sfAsset2, soeREQUIRED},
|
|
{sfAmount, soeOPTIONAL},
|
|
{sfAmount2, soeOPTIONAL},
|
|
{sfEPrice, soeOPTIONAL},
|
|
{sfLPTokenIn, soeOPTIONAL},
|
|
}))
|
|
|
|
/** This transaction type votes for the trading fee */
|
|
TRANSACTION(ttAMM_VOTE, 38, AMMVote, Delegation::delegatable, ({
|
|
{sfAsset, soeREQUIRED},
|
|
{sfAsset2, soeREQUIRED},
|
|
{sfTradingFee, soeREQUIRED},
|
|
}))
|
|
|
|
/** This transaction type bids for the auction slot */
|
|
TRANSACTION(ttAMM_BID, 39, AMMBid, Delegation::delegatable, ({
|
|
{sfAsset, soeREQUIRED},
|
|
{sfAsset2, soeREQUIRED},
|
|
{sfBidMin, soeOPTIONAL},
|
|
{sfBidMax, soeOPTIONAL},
|
|
{sfAuthAccounts, soeOPTIONAL},
|
|
}))
|
|
|
|
/** This transaction type deletes AMM in the empty state */
|
|
TRANSACTION(ttAMM_DELETE, 40, AMMDelete, Delegation::delegatable, ({
|
|
{sfAsset, soeREQUIRED},
|
|
{sfAsset2, soeREQUIRED},
|
|
}))
|
|
|
|
/** This transactions creates a crosschain sequence number */
|
|
TRANSACTION(ttXCHAIN_CREATE_CLAIM_ID, 41, XChainCreateClaimID, Delegation::delegatable, ({
|
|
{sfXChainBridge, soeREQUIRED},
|
|
{sfSignatureReward, soeREQUIRED},
|
|
{sfOtherChainSource, soeREQUIRED},
|
|
}))
|
|
|
|
/** This transactions initiates a crosschain transaction */
|
|
TRANSACTION(ttXCHAIN_COMMIT, 42, XChainCommit, Delegation::delegatable, ({
|
|
{sfXChainBridge, soeREQUIRED},
|
|
{sfXChainClaimID, soeREQUIRED},
|
|
{sfAmount, soeREQUIRED},
|
|
{sfOtherChainDestination, soeOPTIONAL},
|
|
}))
|
|
|
|
/** This transaction completes a crosschain transaction */
|
|
TRANSACTION(ttXCHAIN_CLAIM, 43, XChainClaim, Delegation::delegatable, ({
|
|
{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::delegatable, ({
|
|
{sfXChainBridge, soeREQUIRED},
|
|
{sfDestination, soeREQUIRED},
|
|
{sfAmount, soeREQUIRED},
|
|
{sfSignatureReward, soeREQUIRED},
|
|
}))
|
|
|
|
/** This transaction adds an attestation to a claim */
|
|
TRANSACTION(ttXCHAIN_ADD_CLAIM_ATTESTATION, 45, XChainAddClaimAttestation, Delegation::delegatable, ({
|
|
{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::delegatable, ({
|
|
{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::delegatable, ({
|
|
{sfXChainBridge, soeREQUIRED},
|
|
{sfSignatureReward, soeOPTIONAL},
|
|
{sfMinAccountCreateAmount, soeOPTIONAL},
|
|
}))
|
|
|
|
/** This transactions creates a sidechain */
|
|
TRANSACTION(ttXCHAIN_CREATE_BRIDGE, 48, XChainCreateBridge, Delegation::delegatable, ({
|
|
{sfXChainBridge, soeREQUIRED},
|
|
{sfSignatureReward, soeREQUIRED},
|
|
{sfMinAccountCreateAmount, soeOPTIONAL},
|
|
}))
|
|
|
|
/** This transaction type creates or updates a DID */
|
|
TRANSACTION(ttDID_SET, 49, DIDSet, Delegation::delegatable, ({
|
|
{sfDIDDocument, soeOPTIONAL},
|
|
{sfURI, soeOPTIONAL},
|
|
{sfData, soeOPTIONAL},
|
|
}))
|
|
|
|
/** This transaction type deletes a DID */
|
|
TRANSACTION(ttDID_DELETE, 50, DIDDelete, Delegation::delegatable, ({}))
|
|
|
|
/** This transaction type creates an Oracle instance */
|
|
TRANSACTION(ttORACLE_SET, 51, OracleSet, Delegation::delegatable, ({
|
|
{sfOracleDocumentID, soeREQUIRED},
|
|
{sfProvider, soeOPTIONAL},
|
|
{sfURI, soeOPTIONAL},
|
|
{sfAssetClass, soeOPTIONAL},
|
|
{sfLastUpdateTime, soeREQUIRED},
|
|
{sfPriceDataSeries, soeREQUIRED},
|
|
}))
|
|
|
|
/** This transaction type deletes an Oracle instance */
|
|
TRANSACTION(ttORACLE_DELETE, 52, OracleDelete, Delegation::delegatable, ({
|
|
{sfOracleDocumentID, soeREQUIRED},
|
|
}))
|
|
|
|
/** This transaction type fixes a problem in the ledger state */
|
|
TRANSACTION(ttLEDGER_STATE_FIX, 53, LedgerStateFix, Delegation::delegatable, ({
|
|
{sfLedgerFixType, soeREQUIRED},
|
|
{sfOwner, soeOPTIONAL},
|
|
}))
|
|
|
|
/** This transaction type creates a MPTokensIssuance instance */
|
|
TRANSACTION(ttMPTOKEN_ISSUANCE_CREATE, 54, MPTokenIssuanceCreate, Delegation::delegatable, ({
|
|
{sfAssetScale, soeOPTIONAL},
|
|
{sfTransferFee, soeOPTIONAL},
|
|
{sfMaximumAmount, soeOPTIONAL},
|
|
{sfMPTokenMetadata, soeOPTIONAL},
|
|
{sfDomainID, soeOPTIONAL},
|
|
}))
|
|
|
|
/** This transaction type destroys a MPTokensIssuance instance */
|
|
TRANSACTION(ttMPTOKEN_ISSUANCE_DESTROY, 55, MPTokenIssuanceDestroy, Delegation::delegatable, ({
|
|
{sfMPTokenIssuanceID, soeREQUIRED},
|
|
}))
|
|
|
|
/** This transaction type sets flags on a MPTokensIssuance or MPToken instance */
|
|
TRANSACTION(ttMPTOKEN_ISSUANCE_SET, 56, MPTokenIssuanceSet, Delegation::delegatable, ({
|
|
{sfMPTokenIssuanceID, soeREQUIRED},
|
|
{sfHolder, soeOPTIONAL},
|
|
{sfDomainID, soeOPTIONAL},
|
|
}))
|
|
|
|
/** This transaction type authorizes a MPToken instance */
|
|
TRANSACTION(ttMPTOKEN_AUTHORIZE, 57, MPTokenAuthorize, Delegation::delegatable, ({
|
|
{sfMPTokenIssuanceID, soeREQUIRED},
|
|
{sfHolder, soeOPTIONAL},
|
|
}))
|
|
|
|
/** This transaction type create an Credential instance */
|
|
TRANSACTION(ttCREDENTIAL_CREATE, 58, CredentialCreate, Delegation::delegatable, ({
|
|
{sfSubject, soeREQUIRED},
|
|
{sfCredentialType, soeREQUIRED},
|
|
{sfExpiration, soeOPTIONAL},
|
|
{sfURI, soeOPTIONAL},
|
|
}))
|
|
|
|
/** This transaction type accept an Credential object */
|
|
TRANSACTION(ttCREDENTIAL_ACCEPT, 59, CredentialAccept, Delegation::delegatable, ({
|
|
{sfIssuer, soeREQUIRED},
|
|
{sfCredentialType, soeREQUIRED},
|
|
}))
|
|
|
|
/** This transaction type delete an Credential object */
|
|
TRANSACTION(ttCREDENTIAL_DELETE, 60, CredentialDelete, Delegation::delegatable, ({
|
|
{sfSubject, soeOPTIONAL},
|
|
{sfIssuer, soeOPTIONAL},
|
|
{sfCredentialType, soeREQUIRED},
|
|
}))
|
|
|
|
/** This transaction type modify a NFToken */
|
|
TRANSACTION(ttNFTOKEN_MODIFY, 61, NFTokenModify, Delegation::delegatable, ({
|
|
{sfNFTokenID, soeREQUIRED},
|
|
{sfOwner, soeOPTIONAL},
|
|
{sfURI, soeOPTIONAL},
|
|
}))
|
|
|
|
/** This transaction type creates or modifies a Permissioned Domain */
|
|
TRANSACTION(ttPERMISSIONED_DOMAIN_SET, 62, PermissionedDomainSet, Delegation::delegatable, ({
|
|
{sfDomainID, soeOPTIONAL},
|
|
{sfAcceptedCredentials, soeREQUIRED},
|
|
}))
|
|
|
|
/** This transaction type deletes a Permissioned Domain */
|
|
TRANSACTION(ttPERMISSIONED_DOMAIN_DELETE, 63, PermissionedDomainDelete, Delegation::delegatable, ({
|
|
{sfDomainID, soeREQUIRED},
|
|
}))
|
|
|
|
/** This transaction type delegates authorized account specified permissions */
|
|
TRANSACTION(ttDELEGATE_SET, 64, DelegateSet, Delegation::notDelegatable, ({
|
|
{sfAuthorize, soeREQUIRED},
|
|
{sfPermissions, soeREQUIRED},
|
|
}))
|
|
|
|
/** This transaction creates a single asset vault. */
|
|
TRANSACTION(ttVAULT_CREATE, 65, VaultCreate, Delegation::delegatable, ({
|
|
{sfAsset, soeREQUIRED, soeMPTSupported},
|
|
{sfAssetsMaximum, soeOPTIONAL},
|
|
{sfMPTokenMetadata, soeOPTIONAL},
|
|
{sfDomainID, soeOPTIONAL},
|
|
{sfWithdrawalPolicy, soeOPTIONAL},
|
|
{sfData, soeOPTIONAL},
|
|
}))
|
|
|
|
/** This transaction updates a single asset vault. */
|
|
TRANSACTION(ttVAULT_SET, 66, VaultSet, Delegation::delegatable, ({
|
|
{sfVaultID, soeREQUIRED},
|
|
{sfAssetsMaximum, soeOPTIONAL},
|
|
{sfDomainID, soeOPTIONAL},
|
|
{sfData, soeOPTIONAL},
|
|
}))
|
|
|
|
/** This transaction deletes a single asset vault. */
|
|
TRANSACTION(ttVAULT_DELETE, 67, VaultDelete, Delegation::delegatable, ({
|
|
{sfVaultID, soeREQUIRED},
|
|
}))
|
|
|
|
/** This transaction trades assets for shares with a vault. */
|
|
TRANSACTION(ttVAULT_DEPOSIT, 68, VaultDeposit, Delegation::delegatable, ({
|
|
{sfVaultID, soeREQUIRED},
|
|
{sfAmount, soeREQUIRED, soeMPTSupported},
|
|
}))
|
|
|
|
/** This transaction trades shares for assets with a vault. */
|
|
TRANSACTION(ttVAULT_WITHDRAW, 69, VaultWithdraw, Delegation::delegatable, ({
|
|
{sfVaultID, soeREQUIRED},
|
|
{sfAmount, soeREQUIRED, soeMPTSupported},
|
|
{sfDestination, soeOPTIONAL},
|
|
}))
|
|
|
|
/** This transaction claws back tokens from a vault. */
|
|
TRANSACTION(ttVAULT_CLAWBACK, 70, VaultClawback, Delegation::delegatable, ({
|
|
{sfVaultID, soeREQUIRED},
|
|
{sfHolder, soeREQUIRED},
|
|
{sfAmount, soeOPTIONAL, soeMPTSupported},
|
|
}))
|
|
|
|
/** This transaction type batches together transactions. */
|
|
TRANSACTION(ttBATCH, 71, Batch, Delegation::notDelegatable, ({
|
|
{sfRawTransactions, soeREQUIRED},
|
|
{sfBatchSigners, soeOPTIONAL},
|
|
}))
|
|
|
|
/** This system-generated transaction type is used to update the status of the various amendments.
|
|
|
|
For details, see: https://xrpl.org/amendments.html
|
|
*/
|
|
TRANSACTION(ttAMENDMENT, 100, EnableAmendment, Delegation::notDelegatable, ({
|
|
{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::notDelegatable, ({
|
|
{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::notDelegatable, ({
|
|
{sfUNLModifyDisabling, soeREQUIRED},
|
|
{sfLedgerSequence, soeREQUIRED},
|
|
{sfUNLModifyValidator, soeREQUIRED},
|
|
}))
|