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