xrpld
Loading...
Searching...
No Matches
TxFlags.h
1#pragma once
2
3// NOLINTBEGIN(readability-identifier-naming)
4
5#include <xrpl/protocol/LedgerFormats.h>
6
7#include <cstdint>
8#include <map>
9#include <string>
10#include <utility>
11#include <vector>
12
13namespace xrpl {
14
39
40using FlagValue = std::uint32_t;
41
42// Universal Transaction flags:
43inline constexpr FlagValue tfFullyCanonicalSig = 0x80000000;
44inline constexpr FlagValue tfInnerBatchTxn = 0x40000000;
45inline constexpr FlagValue tfUniversal = tfFullyCanonicalSig | tfInnerBatchTxn;
46inline constexpr FlagValue tfUniversalMask = ~tfUniversal;
47
48#pragma push_macro("XMACRO")
49#pragma push_macro("TO_VALUE")
50#pragma push_macro("VALUE_TO_MAP")
51#pragma push_macro("NULL_NAME")
52#pragma push_macro("NULL_OUTPUT")
53#pragma push_macro("TO_MAP")
54#pragma push_macro("TO_MASK")
55#pragma push_macro("VALUE_TO_MASK")
56#pragma push_macro("ALL_TX_FLAGS")
57#pragma push_macro("NULL_MASK_ADJ")
58#pragma push_macro("MASK_ADJ_TO_MASK")
59
60#undef XMACRO
61#undef TO_VALUE
62#undef VALUE_TO_MAP
63#undef NULL_NAME
64#undef NULL_OUTPUT
65#undef TO_MAP
66#undef TO_MASK
67#undef VALUE_TO_MASK
68#undef NULL_MASK_ADJ
69#undef MASK_ADJ_TO_MASK
70
71// clang-format off
72#undef ALL_TX_FLAGS
73
74// XMACRO parameters:
75// - TRANSACTION: handles the transaction name, its flags, and mask adjustment
76// - TF_FLAG: defines a new flag constant
77// - TF_FLAG2: references an existing flag constant (no new definition)
78// - MASK_ADJ: specifies flags to add back to the mask (making them invalid for this tx type)
79//
80// Note: MASK_ADJ is used when a universal flag should be invalid for a specific transaction.
81// For example, Batch uses MASK_ADJ(tfInnerBatchTxn) because the outer Batch transaction
82// must not have tfInnerBatchTxn set (only inner transactions should have it).
83//
84// TODO: Consider rewriting this using reflection in C++26 or later. Alternatively this could be a DSL processed by a script at build time.
85#define XMACRO(TRANSACTION, TF_FLAG, TF_FLAG2, MASK_ADJ) \
86 TRANSACTION(AccountSet, \
87 TF_FLAG(tfRequireDestTag, 0x00010000) \
88 TF_FLAG(tfOptionalDestTag, 0x00020000) \
89 TF_FLAG(tfRequireAuth, 0x00040000) \
90 TF_FLAG(tfOptionalAuth, 0x00080000) \
91 TF_FLAG(tfDisallowXRP, 0x00100000) \
92 TF_FLAG(tfAllowXRP, 0x00200000), \
93 MASK_ADJ(0)) \
94 \
95 TRANSACTION(OfferCreate, \
96 TF_FLAG(tfPassive, 0x00010000) \
97 TF_FLAG(tfImmediateOrCancel, 0x00020000) \
98 TF_FLAG(tfFillOrKill, 0x00040000) \
99 TF_FLAG(tfSell, 0x00080000) \
100 TF_FLAG(tfHybrid, 0x00100000), \
101 MASK_ADJ(0)) \
102 \
103 TRANSACTION(Payment, \
104 TF_FLAG(tfNoRippleDirect, 0x00010000) \
105 TF_FLAG(tfPartialPayment, 0x00020000) \
106 TF_FLAG(tfLimitQuality, 0x00040000) \
107 TF_FLAG(tfSponsorCreatedAccount, 0x00080000), \
108 MASK_ADJ(0)) \
109 \
110 TRANSACTION(TrustSet, \
111 TF_FLAG(tfSetfAuth, 0x00010000) \
112 TF_FLAG(tfSetNoRipple, 0x00020000) \
113 TF_FLAG(tfClearNoRipple, 0x00040000) \
114 TF_FLAG(tfSetFreeze, 0x00100000) \
115 TF_FLAG(tfClearFreeze, 0x00200000) \
116 TF_FLAG(tfSetDeepFreeze, 0x00400000) \
117 TF_FLAG(tfClearDeepFreeze, 0x00800000), \
118 MASK_ADJ(0)) \
119 \
120 TRANSACTION(EnableAmendment, \
121 TF_FLAG(tfGotMajority, 0x00010000) \
122 TF_FLAG(tfLostMajority, 0x00020000), \
123 MASK_ADJ(0)) \
124 \
125 TRANSACTION(PaymentChannelClaim, \
126 TF_FLAG(tfRenew, 0x00010000) \
127 TF_FLAG(tfClose, 0x00020000), \
128 MASK_ADJ(0)) \
129 \
130 TRANSACTION(NFTokenMint, \
131 TF_FLAG(tfBurnable, 0x00000001) \
132 TF_FLAG(tfOnlyXRP, 0x00000002) \
133 /* deprecated TF_FLAG(tfTrustLine, 0x00000004) */ \
134 TF_FLAG(tfTransferable, 0x00000008) \
135 TF_FLAG(tfMutable, 0x00000010), \
136 MASK_ADJ(0)) \
137 \
138 TRANSACTION(MPTokenIssuanceCreate, \
139 /* Note: tf/lsfMPTLocked is intentionally omitted since this transaction is not allowed to modify it. */ \
140 TF_FLAG(tfMPTCanLock, lsfMPTCanLock) \
141 TF_FLAG(tfMPTRequireAuth, lsfMPTRequireAuth) \
142 TF_FLAG(tfMPTCanEscrow, lsfMPTCanEscrow) \
143 TF_FLAG(tfMPTCanTrade, lsfMPTCanTrade) \
144 TF_FLAG(tfMPTCanTransfer, lsfMPTCanTransfer) \
145 TF_FLAG(tfMPTCanClawback, lsfMPTCanClawback) \
146 TF_FLAG(tfMPTCanHoldConfidentialBalance, lsfMPTCanHoldConfidentialBalance), \
147 MASK_ADJ(0)) \
148 \
149 TRANSACTION(MPTokenAuthorize, \
150 TF_FLAG(tfMPTUnauthorize, 0x00000001), \
151 MASK_ADJ(0)) \
152 \
153 TRANSACTION(MPTokenIssuanceSet, \
154 TF_FLAG(tfMPTLock, 0x00000001) \
155 TF_FLAG(tfMPTUnlock, 0x00000002) \
156 TF_FLAG(tfMPTSetCanLock, 0x00000004) \
157 TF_FLAG(tfMPTSetRequireAuth, 0x00000008) \
158 TF_FLAG(tfMPTSetCanEscrow, 0x00000010) \
159 TF_FLAG(tfMPTSetCanTrade, 0x00000020) \
160 TF_FLAG(tfMPTSetCanTransfer, 0x00000040) \
161 TF_FLAG(tfMPTSetCanClawback, 0x00000080) \
162 TF_FLAG(tfMPTSetCanHoldConfidentialBalance, 0x00000100), \
163 MASK_ADJ(0)) \
164 \
165 TRANSACTION(NFTokenCreateOffer, \
166 TF_FLAG(tfSellNFToken, 0x00000001), \
167 MASK_ADJ(0)) \
168 \
169 TRANSACTION(AMMDeposit, \
170 TF_FLAG(tfLPToken, 0x00010000) \
171 TF_FLAG(tfSingleAsset, 0x00080000) \
172 TF_FLAG(tfTwoAsset, 0x00100000) \
173 TF_FLAG(tfOneAssetLPToken, 0x00200000) \
174 TF_FLAG(tfLimitLPToken, 0x00400000) \
175 TF_FLAG(tfTwoAssetIfEmpty, 0x00800000), \
176 MASK_ADJ(0)) \
177 \
178 TRANSACTION(AMMWithdraw, \
179 TF_FLAG2(tfLPToken, 0x00010000) \
180 TF_FLAG(tfWithdrawAll, 0x00020000) \
181 TF_FLAG(tfOneAssetWithdrawAll, 0x00040000) \
182 TF_FLAG2(tfSingleAsset, 0x00080000) \
183 TF_FLAG2(tfTwoAsset, 0x00100000) \
184 TF_FLAG2(tfOneAssetLPToken, 0x00200000) \
185 TF_FLAG2(tfLimitLPToken, 0x00400000), \
186 MASK_ADJ(0)) \
187 \
188 TRANSACTION(AMMClawback, \
189 TF_FLAG(tfClawTwoAssets, 0x00000001), \
190 MASK_ADJ(0)) \
191 \
192 TRANSACTION(XChainModifyBridge, \
193 TF_FLAG(tfClearAccountCreateAmount, 0x00010000), \
194 MASK_ADJ(0)) \
195 \
196 TRANSACTION(VaultCreate, \
197 TF_FLAG(tfVaultPrivate, lsfVaultPrivate) \
198 TF_FLAG(tfVaultShareNonTransferable, 0x00020000), \
199 MASK_ADJ(0)) \
200 \
201 TRANSACTION(Batch, \
202 TF_FLAG(tfAllOrNothing, 0x00010000) \
203 TF_FLAG(tfOnlyOne, 0x00020000) \
204 TF_FLAG(tfUntilFailure, 0x00040000) \
205 TF_FLAG(tfIndependent, 0x00080000), \
206 MASK_ADJ(tfInnerBatchTxn)) /* Batch must reject tfInnerBatchTxn - only inner transactions should have this flag */ \
207 \
208 TRANSACTION(LoanSet, /* True indicates the loan supports overpayments */ \
209 TF_FLAG(tfLoanOverpayment, 0x00010000), \
210 MASK_ADJ(0)) \
211 \
212 TRANSACTION(LoanPay, /* True indicates any excess in this payment can be used as an overpayment. */ \
213 /* False: no overpayments will be taken. */ \
214 TF_FLAG2(tfLoanOverpayment, 0x00010000) \
215 TF_FLAG(tfLoanFullPayment, 0x00020000) /* True indicates that the payment is an early full payment. */ \
216 /* It must pay the entire loan including close interest and fees, or it will fail. */ \
217 /* False: Not a full payment. */ \
218 TF_FLAG(tfLoanLatePayment, 0x00040000), /* True indicates that the payment is late, and includes late interest and fees. */ \
219 /* If the loan is not late, it will fail. */ \
220 /* False: not a late payment. If the current payment is overdue, the transaction will fail.*/ \
221 MASK_ADJ(0)) \
222 \
223 TRANSACTION(LoanManage, \
224 TF_FLAG(tfLoanDefault, 0x00010000) \
225 TF_FLAG(tfLoanImpair, 0x00020000) \
226 TF_FLAG(tfLoanUnimpair, 0x00040000), \
227 MASK_ADJ(0)) \
228 \
229 TRANSACTION(SponsorshipSet, \
230 TF_FLAG(tfSponsorshipSetRequireSignForFee, 0x00010000) \
231 TF_FLAG(tfSponsorshipClearRequireSignForFee, 0x00020000) \
232 TF_FLAG(tfSponsorshipSetRequireSignForReserve, 0x00040000) \
233 TF_FLAG(tfSponsorshipClearRequireSignForReserve, 0x00080000) \
234 TF_FLAG(tfDeleteObject, 0x00100000), \
235 MASK_ADJ(0)) \
236 \
237 TRANSACTION(SponsorshipTransfer, \
238 TF_FLAG(tfSponsorshipEnd, 0x00010000) \
239 TF_FLAG(tfSponsorshipCreate, 0x00020000) \
240 TF_FLAG(tfSponsorshipReassign, 0x00040000), \
241 MASK_ADJ(0)) \
242 \
243 TRANSACTION(ConfidentialMPTHolderKeyUpdate, \
244 TF_FLAG(tfHolderKeyRotation, 0x00010000) \
245 TF_FLAG(tfHolderKeyRecovery, 0x00020000) \
246 TF_FLAG(tfCancelRecovery, 0x00040000), \
247 MASK_ADJ(0))
248
249// clang-format on
250
251// Create all the flag values.
252//
253// example:
254// inline constexpr FlagValue tfAccountSetRequireDestTag = 0x00010000;
255#define TO_VALUE(name, value) inline constexpr FlagValue name = value;
256#define NULL_NAME(name, values, maskAdj) values
257#define NULL_OUTPUT(name, value)
258#define NULL_MASK_ADJ(value)
259XMACRO(NULL_NAME, TO_VALUE, NULL_OUTPUT, NULL_MASK_ADJ)
260
261// Create masks for each transaction type that has flags.
262//
263// example:
264// inline constexpr FlagValue tfAccountSetMask = ~(tfUniversal | tfRequireDestTag |
265// tfOptionalDestTag | tfRequireAuth | tfOptionalAuth | tfDisallowXRP | tfAllowXRP);
266//
267// The mask adjustment (maskAdj) allows adding flags back to the mask, making them invalid.
268// For example, Batch uses MASK_ADJ(tfInnerBatchTxn) to reject tfInnerBatchTxn on outer Batch.
269#define TO_MASK(name, values, maskAdj) \
270 inline constexpr FlagValue tf##name##Mask = ~(tfUniversal values) | (maskAdj);
271#define VALUE_TO_MASK(name, value) | name
272#define MASK_ADJ_TO_MASK(value) value
273XMACRO(TO_MASK, VALUE_TO_MASK, VALUE_TO_MASK, MASK_ADJ_TO_MASK)
274
275// Verify that tfBatchMask correctly rejects tfInnerBatchTxn.
276// The outer Batch transaction must NOT have tfInnerBatchTxn set; only inner transactions should
277// have it.
278static_assert(
279 (tfBatchMask & tfInnerBatchTxn) == tfInnerBatchTxn,
280 "tfBatchMask must include tfInnerBatchTxn to reject it on outer Batch");
281
282// Verify that other transaction masks correctly allow tfInnerBatchTxn.
283// Inner transactions need tfInnerBatchTxn to be valid, so these masks must not reject it.
284static_assert(
285 (tfPaymentMask & tfInnerBatchTxn) == 0,
286 "tfPaymentMask must not reject tfInnerBatchTxn");
287static_assert(
288 (tfAccountSetMask & tfInnerBatchTxn) == 0,
289 "tfAccountSetMask must not reject tfInnerBatchTxn");
290
291// Create getter functions for each set of flags using Meyer's singleton pattern.
292// This avoids static initialization order fiasco while still providing efficient access.
293// This is used below in `getAllTxFlags()` to generate the server_definitions RPC
294// output.
295//
296// example:
297// inline FlagMap const& getAccountSetFlags() {
298// static FlagMap const flags = {
299// {"tfRequireDestTag", 0x00010000},
300// {"tfOptionalDestTag", 0x00020000},
301// ...};
302// return flags;
303// }
304using FlagMap = std::map<std::string, FlagValue>;
305#define VALUE_TO_MAP(name, value) {#name, value},
306#define TO_MAP(name, values, maskAdj) \
307 inline FlagMap const& get##name##Flags() \
308 { \
309 static FlagMap const flags = {values}; \
310 return flags; \
311 }
312XMACRO(TO_MAP, VALUE_TO_MAP, VALUE_TO_MAP, NULL_MASK_ADJ)
313
314inline FlagMap const&
315getUniversalFlags()
316{
317 static FlagMap const flags = {
318 {"tfFullyCanonicalSig", tfFullyCanonicalSig}, {"tfInnerBatchTxn", tfInnerBatchTxn}};
319 return flags;
320}
321
322// Create a getter function for all transaction flag maps using Meyer's singleton pattern.
323// This is used to generate the server_definitions RPC output.
324//
325// example:
326// inline FlagMapPairList const& getAllTxFlags() {
327// static FlagMapPairList const flags = {
328// {"AccountSet", getAccountSetFlags()},
329// ...};
330// return flags;
331// }
332using FlagMapPairList = std::vector<std::pair<std::string, FlagMap>>;
333#define ALL_TX_FLAGS(name, values, maskAdj) {#name, get##name##Flags()},
334inline FlagMapPairList const&
335getAllTxFlags()
336{
337 static FlagMapPairList const flags = {
338 {"universal", getUniversalFlags()},
339 XMACRO(ALL_TX_FLAGS, NULL_OUTPUT, NULL_OUTPUT, NULL_MASK_ADJ)};
340 return flags;
341}
342
343#undef XMACRO
344#undef TO_VALUE
345#undef VALUE_TO_MAP
346#undef NULL_NAME
347#undef NULL_OUTPUT
348#undef TO_MAP
349#undef TO_MASK
350#undef VALUE_TO_MASK
351#undef ALL_TX_FLAGS
352#undef NULL_MASK_ADJ
353#undef MASK_ADJ_TO_MASK
354
355#pragma pop_macro("XMACRO")
356#pragma pop_macro("TO_VALUE")
357#pragma pop_macro("VALUE_TO_MAP")
358#pragma pop_macro("NULL_NAME")
359#pragma pop_macro("NULL_OUTPUT")
360#pragma pop_macro("TO_MAP")
361#pragma pop_macro("TO_MASK")
362#pragma pop_macro("VALUE_TO_MASK")
363#pragma pop_macro("ALL_TX_FLAGS")
364#pragma pop_macro("NULL_MASK_ADJ")
365#pragma pop_macro("MASK_ADJ_TO_MASK")
366
367// Additional transaction masks and combos
368inline constexpr FlagValue tfMPTPaymentMask = ~(tfUniversal | tfPartialPayment);
369inline constexpr FlagValue tfTrustSetPermissionMask =
370 ~(tfUniversal | tfSetfAuth | tfSetFreeze | tfClearFreeze);
371
372// MPTokenIssuanceCreate / MPTokenIssuanceSet ImmutableFlags:
373// Defines the immutable fields and flags specific to MPTokenIssuance.
374inline constexpr FlagValue tifMPTCanLock = lsifMPTCanLock;
375inline constexpr FlagValue tifMPTRequireAuth = lsifMPTRequireAuth;
376inline constexpr FlagValue tifMPTCanEscrow = lsifMPTCanEscrow;
377inline constexpr FlagValue tifMPTCanTrade = lsifMPTCanTrade;
378inline constexpr FlagValue tifMPTCanTransfer = lsifMPTCanTransfer;
379inline constexpr FlagValue tifMPTCanClawback = lsifMPTCanClawback;
380inline constexpr FlagValue tifMPTMetadata = lsifMPTMetadata;
381inline constexpr FlagValue tifMPTTransferFee = lsifMPTTransferFee;
382inline constexpr FlagValue tifMPTCanHoldConfidentialBalance = lsifMPTCanHoldConfidentialBalance;
383inline constexpr FlagValue tifMPTokenIssuanceImmutableMask =
384 ~(tifMPTCanLock | tifMPTRequireAuth | tifMPTCanEscrow | tifMPTCanTrade | tifMPTCanTransfer |
385 tifMPTCanClawback | tifMPTMetadata | tifMPTTransferFee | tifMPTCanHoldConfidentialBalance);
386
387// MPTokenIssuanceSet set of flags that is used to enable capabilities on an MPTokenIssuance.
388// Used as `txFlags & tfMPTokenIssuanceSetEnableFlagMask` to extract the capability-enabling bits.
389inline constexpr FlagValue tfMPTokenIssuanceSetEnableFlagMask = tfMPTSetCanLock |
390 tfMPTSetRequireAuth | tfMPTSetCanEscrow | tfMPTSetCanTrade | tfMPTSetCanTransfer |
391 tfMPTSetCanClawback | tfMPTSetCanHoldConfidentialBalance;
392
393// Prior to fixRemoveNFTokenAutoTrustLine, transfer of an NFToken between accounts allowed a
394// TrustLine to be added to the issuer of that token without explicit permission from that issuer.
395// This was enabled by minting the NFToken with the tfTrustLine flag set.
396//
397// That capability could be used to attack the NFToken issuer.
398// It would be possible for two accounts to trade the NFToken back and forth building up any number
399// of TrustLines on the issuer, increasing the issuer's reserve without bound.
400//
401// The fixRemoveNFTokenAutoTrustLine amendment disables minting with the tfTrustLine flag as a way
402// to prevent the attack. But until the amendment passes we still need to keep the old behavior
403// available.
404inline constexpr FlagValue tfTrustLine = 0x00000004; // needed for backwards compatibility
405inline constexpr FlagValue tfNFTokenMintMaskWithoutMutable =
406 ~(tfUniversal | tfBurnable | tfOnlyXRP | tfTransferable);
407
408inline constexpr FlagValue tfNFTokenMintOldMask = ~(~tfNFTokenMintMaskWithoutMutable | tfTrustLine);
409
410// if featureDynamicNFT enabled then new flag allowing mutable URI available.
411inline constexpr FlagValue tfNFTokenMintOldMaskWithMutable = ~(~tfNFTokenMintOldMask | tfMutable);
412
413inline constexpr FlagValue tfWithdrawSubTx = tfLPToken | tfSingleAsset | tfTwoAsset |
414 tfOneAssetLPToken | tfLimitLPToken | tfWithdrawAll | tfOneAssetWithdrawAll;
415inline constexpr FlagValue tfDepositSubTx =
416 tfLPToken | tfSingleAsset | tfTwoAsset | tfOneAssetLPToken | tfLimitLPToken | tfTwoAssetIfEmpty;
417
418#pragma push_macro("ACCOUNTSET_FLAGS")
419#pragma push_macro("ACCOUNTSET_FLAG_TO_VALUE")
420#pragma push_macro("ACCOUNTSET_FLAG_TO_MAP")
421
422// AccountSet SetFlag/ClearFlag values
423#define ACCOUNTSET_FLAGS(ASF_FLAG) \
424 ASF_FLAG(asfRequireDest, 1) \
425 ASF_FLAG(asfRequireAuth, 2) \
426 ASF_FLAG(asfDisallowXRP, 3) \
427 ASF_FLAG(asfDisableMaster, 4) \
428 ASF_FLAG(asfAccountTxnID, 5) \
429 ASF_FLAG(asfNoFreeze, 6) \
430 ASF_FLAG(asfGlobalFreeze, 7) \
431 ASF_FLAG(asfDefaultRipple, 8) \
432 ASF_FLAG(asfDepositAuth, 9) \
433 ASF_FLAG(asfAuthorizedNFTokenMinter, 10) \
434 /* 11 is unused */ \
435 ASF_FLAG(asfDisallowIncomingNFTokenOffer, 12) \
436 ASF_FLAG(asfDisallowIncomingCheck, 13) \
437 ASF_FLAG(asfDisallowIncomingPayChan, 14) \
438 ASF_FLAG(asfDisallowIncomingTrustline, 15) \
439 ASF_FLAG(asfAllowTrustLineClawback, 16) \
440 ASF_FLAG(asfAllowTrustLineLocking, 17)
441
442#define ACCOUNTSET_FLAG_TO_VALUE(name, value) inline constexpr FlagValue name = value;
443#define ACCOUNTSET_FLAG_TO_MAP(name, value) {#name, value},
444
445ACCOUNTSET_FLAGS(ACCOUNTSET_FLAG_TO_VALUE)
446
447inline std::map<std::string, FlagValue> const&
448getAsfFlagMap()
449{
450 static std::map<std::string, FlagValue> const flags = {
451 ACCOUNTSET_FLAGS(ACCOUNTSET_FLAG_TO_MAP)};
452 return flags;
453}
454
455#undef ACCOUNTSET_FLAG_TO_VALUE
456#undef ACCOUNTSET_FLAG_TO_MAP
457#undef ACCOUNTSET_FLAGS
458
459#pragma pop_macro("ACCOUNTSET_FLAG_TO_VALUE")
460#pragma pop_macro("ACCOUNTSET_FLAG_TO_MAP")
461#pragma pop_macro("ACCOUNTSET_FLAGS")
462
463// Sponsor flags (spf)
464
465inline constexpr FlagValue spfSponsorFee = 1;
466inline constexpr FlagValue spfSponsorReserve = 2;
467inline constexpr FlagValue spfSponsorFlagMask = ~(spfSponsorFee | spfSponsorReserve);
468
469} // namespace xrpl
470
471// NOLINTEND(readability-identifier-naming)
xrpl
Use hash_* containers for keys that do not need a cryptographically secure hashing algorithm.
Definition algorithm.h:5
xrpl::tifMPTMetadata
constexpr FlagValue tifMPTMetadata
Definition TxFlags.h:380
xrpl::spfSponsorFee
constexpr FlagValue spfSponsorFee
Definition TxFlags.h:465
xrpl::lsifMPTCanClawback
constexpr std::uint32_t lsifMPTCanClawback
Definition LedgerFormats.h:292
xrpl::tfInnerBatchTxn
constexpr FlagValue tfInnerBatchTxn
Definition TxFlags.h:44
xrpl::FlagValue
std::uint32_t FlagValue
Transaction flags.
Definition TxFlags.h:40
xrpl::lsifMPTCanHoldConfidentialBalance
constexpr std::uint32_t lsifMPTCanHoldConfidentialBalance
Definition LedgerFormats.h:293
xrpl::lsifMPTRequireAuth
constexpr std::uint32_t lsifMPTRequireAuth
Definition LedgerFormats.h:288
xrpl::tfDepositSubTx
constexpr FlagValue tfDepositSubTx
Definition TxFlags.h:415
xrpl::tfTrustLine
constexpr FlagValue tfTrustLine
Definition TxFlags.h:404
xrpl::tfNFTokenMintMaskWithoutMutable
constexpr FlagValue tfNFTokenMintMaskWithoutMutable
Definition TxFlags.h:405
xrpl::tfNFTokenMintOldMaskWithMutable
constexpr FlagValue tfNFTokenMintOldMaskWithMutable
Definition TxFlags.h:411
xrpl::tifMPTTransferFee
constexpr FlagValue tifMPTTransferFee
Definition TxFlags.h:381
xrpl::tfTrustSetPermissionMask
constexpr FlagValue tfTrustSetPermissionMask
Definition TxFlags.h:369
xrpl::lsifMPTCanEscrow
constexpr std::uint32_t lsifMPTCanEscrow
Definition LedgerFormats.h:289
xrpl::tifMPTCanEscrow
constexpr FlagValue tifMPTCanEscrow
Definition TxFlags.h:376
xrpl::FlagMapPairList
std::vector< std::pair< std::string, FlagMap > > FlagMapPairList
Definition TxFlags.h:332
xrpl::tfUniversal
constexpr FlagValue tfUniversal
Definition TxFlags.h:45
xrpl::tifMPTCanTransfer
constexpr FlagValue tifMPTCanTransfer
Definition TxFlags.h:378
xrpl::tfMPTokenIssuanceSetEnableFlagMask
constexpr FlagValue tfMPTokenIssuanceSetEnableFlagMask
Definition TxFlags.h:389
xrpl::tfMPTPaymentMask
constexpr FlagValue tfMPTPaymentMask
Definition TxFlags.h:368
xrpl::getUniversalFlags
FlagMap const & getUniversalFlags()
Definition TxFlags.h:315
xrpl::getAllTxFlags
FlagMapPairList const & getAllTxFlags()
Definition TxFlags.h:335
xrpl::tifMPTokenIssuanceImmutableMask
constexpr FlagValue tifMPTokenIssuanceImmutableMask
Definition TxFlags.h:383
xrpl::tfNFTokenMintOldMask
constexpr FlagValue tfNFTokenMintOldMask
Definition TxFlags.h:408
xrpl::lsifMPTCanTrade
constexpr std::uint32_t lsifMPTCanTrade
Definition LedgerFormats.h:290
xrpl::FlagMap
std::map< std::string, FlagValue > FlagMap
Definition TxFlags.h:304
xrpl::tifMPTCanHoldConfidentialBalance
constexpr FlagValue tifMPTCanHoldConfidentialBalance
Definition TxFlags.h:382
xrpl::lsifMPTMetadata
constexpr std::uint32_t lsifMPTMetadata
Definition LedgerFormats.h:294
xrpl::spfSponsorFlagMask
constexpr FlagValue spfSponsorFlagMask
Definition TxFlags.h:467
xrpl::tifMPTCanClawback
constexpr FlagValue tifMPTCanClawback
Definition TxFlags.h:379
xrpl::getAsfFlagMap
std::map< std::string, FlagValue > const & getAsfFlagMap()
Definition TxFlags.h:448
xrpl::tifMPTCanLock
constexpr FlagValue tifMPTCanLock
Definition TxFlags.h:374
xrpl::lsifMPTCanLock
constexpr std::uint32_t lsifMPTCanLock
Definition LedgerFormats.h:287
xrpl::tifMPTCanTrade
constexpr FlagValue tifMPTCanTrade
Definition TxFlags.h:377
xrpl::tfWithdrawSubTx
constexpr FlagValue tfWithdrawSubTx
Definition TxFlags.h:413
xrpl::tfUniversalMask
constexpr FlagValue tfUniversalMask
Definition TxFlags.h:46
xrpl::tifMPTRequireAuth
constexpr FlagValue tifMPTRequireAuth
Definition TxFlags.h:375
xrpl::spfSponsorReserve
constexpr FlagValue spfSponsorReserve
Definition TxFlags.h:466
xrpl::tfFullyCanonicalSig
constexpr FlagValue tfFullyCanonicalSig
Definition TxFlags.h:43
xrpl::lsifMPTTransferFee
constexpr std::uint32_t lsifMPTTransferFee
Definition LedgerFormats.h:295
xrpl::lsifMPTCanTransfer
constexpr std::uint32_t lsifMPTCanTransfer
Definition LedgerFormats.h:291
Generated by doxygen 1.17.0