From 9bca452e410779f1d4e6504830cdebd77fc8037d Mon Sep 17 00:00:00 2001 From: Bronek Date: Wed, 17 Sep 2025 13:46:10 -0700 Subject: [PATCH] deploy: 37b951859ccf490354a620b83637ed9cefa24f68 --- LedgerFormats_8h_source.html | 32 +- MPTokenIssuanceCreate_8cpp_source.html | 4 +- MPTokenIssuanceSet_8cpp_source.html | 680 +++++++------- MPTokenIssuanceSet_8h_source.html | 8 +- MPToken__test_8cpp_source.html | 1007 +++++++++++---------- TxFlags_8h_source.html | 114 +-- classripple_1_1MPTokenIssuanceSet.html | 8 +- classripple_1_1test_1_1MPToken__test.html | 12 +- mpt_8cpp_source.html | 48 +- namespacemembers_eval_l.html | 16 +- namespacemembers_l.html | 16 +- namespacemembers_t.html | 44 +- namespacemembers_vars_t.html | 44 +- namespaceripple.html | 328 +++---- search/all_13.js | 394 ++++---- search/all_1b.js | 380 ++++---- search/enumvalues_c.js | 88 +- search/variables_13.js | 228 ++--- 18 files changed, 1732 insertions(+), 1719 deletions(-) diff --git a/LedgerFormats_8h_source.html b/LedgerFormats_8h_source.html index df2d226a6c..22fb0b59d4 100644 --- a/LedgerFormats_8h_source.html +++ b/LedgerFormats_8h_source.html @@ -206,14 +206,14 @@ $(document).ready(function() { init_codefold(0); });
188 lsfMPTCanTransfer = 0x00000020,
189 lsfMPTCanClawback = 0x00000040,
190
-
191 lsfMPTCanMutateCanLock = 0x00000002,
-
192 lsfMPTCanMutateRequireAuth = 0x00000004,
-
193 lsfMPTCanMutateCanEscrow = 0x00000008,
-
194 lsfMPTCanMutateCanTrade = 0x00000010,
-
195 lsfMPTCanMutateCanTransfer = 0x00000020,
-
196 lsfMPTCanMutateCanClawback = 0x00000040,
-
197 lsfMPTCanMutateMetadata = 0x00010000,
-
198 lsfMPTCanMutateTransferFee = 0x00020000,
+
191 lmfMPTCanMutateCanLock = 0x00000002,
+
192 lmfMPTCanMutateRequireAuth = 0x00000004,
+
193 lmfMPTCanMutateCanEscrow = 0x00000008,
+
194 lmfMPTCanMutateCanTrade = 0x00000010,
+
195 lmfMPTCanMutateCanTransfer = 0x00000020,
+
196 lmfMPTCanMutateCanClawback = 0x00000040,
+
197 lmfMPTCanMutateMetadata = 0x00010000,
+
198 lmfMPTCanMutateTransferFee = 0x00020000,
199
200 // ltMPTOKEN
201 lsfMPTAuthorized = 0x00000002,
@@ -251,15 +251,12 @@ $(document).ready(function() { init_codefold(0); });
ripple
Use hash_* containers for keys that do not need a cryptographically secure hashing algorithm.
Definition algorithm.h:25
ripple::LedgerSpecificFlags
LedgerSpecificFlags
Definition LedgerFormats.h:123
ripple::lsfHighDeepFreeze
@ lsfHighDeepFreeze
Definition LedgerFormats.h:168
-
ripple::lsfMPTCanMutateCanLock
@ lsfMPTCanMutateCanLock
Definition LedgerFormats.h:191
-
ripple::lsfMPTCanMutateMetadata
@ lsfMPTCanMutateMetadata
Definition LedgerFormats.h:197
ripple::lsfMPTCanTransfer
@ lsfMPTCanTransfer
Definition LedgerFormats.h:188
ripple::lsfMPTCanTrade
@ lsfMPTCanTrade
Definition LedgerFormats.h:187
ripple::lsfRequireDestTag
@ lsfRequireDestTag
Definition LedgerFormats.h:126
ripple::lsfMPTCanEscrow
@ lsfMPTCanEscrow
Definition LedgerFormats.h:186
ripple::lsfOneOwnerCount
@ lsfOneOwnerCount
Definition LedgerFormats.h:173
ripple::lsfPasswordSpent
@ lsfPasswordSpent
Definition LedgerFormats.h:125
-
ripple::lsfMPTCanMutateCanClawback
@ lsfMPTCanMutateCanClawback
Definition LedgerFormats.h:196
ripple::lsfMPTCanLock
@ lsfMPTCanLock
Definition LedgerFormats.h:184
ripple::lsfDefaultRipple
@ lsfDefaultRipple
Definition LedgerFormats.h:134
ripple::lsfHighNoRipple
@ lsfHighNoRipple
Definition LedgerFormats.h:164
@@ -269,13 +266,17 @@ $(document).ready(function() { init_codefold(0); });
ripple::lsfAllowTrustLineClawback
@ lsfAllowTrustLineClawback
Definition LedgerFormats.h:150
ripple::lsfLowNoRipple
@ lsfLowNoRipple
Definition LedgerFormats.h:163
ripple::lsfNFTokenBuyOffers
@ lsfNFTokenBuyOffers
Definition LedgerFormats.h:176
+
ripple::lmfMPTCanMutateMetadata
@ lmfMPTCanMutateMetadata
Definition LedgerFormats.h:197
ripple::lsfMPTCanClawback
@ lsfMPTCanClawback
Definition LedgerFormats.h:189
+
ripple::lmfMPTCanMutateCanTransfer
@ lmfMPTCanMutateCanTransfer
Definition LedgerFormats.h:195
ripple::lsfNFTokenSellOffers
@ lsfNFTokenSellOffers
Definition LedgerFormats.h:177
+
ripple::lmfMPTCanMutateTransferFee
@ lmfMPTCanMutateTransferFee
Definition LedgerFormats.h:198
ripple::lsfDisableMaster
@ lsfDisableMaster
Definition LedgerFormats.h:131
ripple::lsfHighReserve
@ lsfHighReserve
Definition LedgerFormats.h:160
+
ripple::lmfMPTCanMutateCanClawback
@ lmfMPTCanMutateCanClawback
Definition LedgerFormats.h:196
ripple::lsfVaultPrivate
@ lsfVaultPrivate
Definition LedgerFormats.h:207
-
ripple::lsfMPTCanMutateCanTransfer
@ lsfMPTCanMutateCanTransfer
Definition LedgerFormats.h:195
ripple::lsfDepositAuth
@ lsfDepositAuth
Definition LedgerFormats.h:136
+
ripple::lmfMPTCanMutateRequireAuth
@ lmfMPTCanMutateRequireAuth
Definition LedgerFormats.h:192
ripple::lsfAMMNode
@ lsfAMMNode
Definition LedgerFormats.h:169
ripple::lsfDisallowIncomingPayChan
@ lsfDisallowIncomingPayChan
Definition LedgerFormats.h:144
ripple::lsfMPTRequireAuth
@ lsfMPTRequireAuth
Definition LedgerFormats.h:185
@@ -284,23 +285,22 @@ $(document).ready(function() { init_codefold(0); });
ripple::lsfDisallowIncomingNFTokenOffer
@ lsfDisallowIncomingNFTokenOffer
Definition LedgerFormats.h:140
ripple::lsfHybrid
@ lsfHybrid
Definition LedgerFormats.h:156
ripple::lsfMPTAuthorized
@ lsfMPTAuthorized
Definition LedgerFormats.h:201
+
ripple::lmfMPTCanMutateCanLock
@ lmfMPTCanMutateCanLock
Definition LedgerFormats.h:191
ripple::lsfSell
@ lsfSell
Definition LedgerFormats.h:155
ripple::lsfNoFreeze
@ lsfNoFreeze
Definition LedgerFormats.h:132
ripple::lsfGlobalFreeze
@ lsfGlobalFreeze
Definition LedgerFormats.h:133
ripple::lsfLowReserve
@ lsfLowReserve
Definition LedgerFormats.h:159
-
ripple::lsfMPTCanMutateCanEscrow
@ lsfMPTCanMutateCanEscrow
Definition LedgerFormats.h:193
-
ripple::lsfMPTCanMutateCanTrade
@ lsfMPTCanMutateCanTrade
Definition LedgerFormats.h:194
ripple::lsfLowFreeze
@ lsfLowFreeze
Definition LedgerFormats.h:165
ripple::lsfAccepted
@ lsfAccepted
Definition LedgerFormats.h:204
ripple::lsfMPTLocked
@ lsfMPTLocked
Definition LedgerFormats.h:183
-
ripple::lsfMPTCanMutateRequireAuth
@ lsfMPTCanMutateRequireAuth
Definition LedgerFormats.h:192
ripple::lsfLowDeepFreeze
@ lsfLowDeepFreeze
Definition LedgerFormats.h:167
+
ripple::lmfMPTCanMutateCanEscrow
@ lmfMPTCanMutateCanEscrow
Definition LedgerFormats.h:193
ripple::lsfHighAuth
@ lsfHighAuth
Definition LedgerFormats.h:162
+
ripple::lmfMPTCanMutateCanTrade
@ lmfMPTCanMutateCanTrade
Definition LedgerFormats.h:194
ripple::lsfSellNFToken
@ lsfSellNFToken
Definition LedgerFormats.h:180
ripple::lsfLowAuth
@ lsfLowAuth
Definition LedgerFormats.h:161
ripple::lsfPassive
@ lsfPassive
Definition LedgerFormats.h:154
ripple::lsfDisallowXRP
@ lsfDisallowXRP
Definition LedgerFormats.h:130
-
ripple::lsfMPTCanMutateTransferFee
@ lsfMPTCanMutateTransferFee
Definition LedgerFormats.h:198
ripple::LedgerEntryType
LedgerEntryType
Identifiers for on-ledger objects.
Definition LedgerFormats.h:54
ripple::ltNICKNAME
@ ltNICKNAME
A legacy, deprecated type.
Definition LedgerFormats.h:100
ripple::ltCONTRACT
@ ltCONTRACT
A legacy, deprecated type.
Definition LedgerFormats.h:108
diff --git a/MPTokenIssuanceCreate_8cpp_source.html b/MPTokenIssuanceCreate_8cpp_source.html index d1504e89aa..458dc54eca 100644 --- a/MPTokenIssuanceCreate_8cpp_source.html +++ b/MPTokenIssuanceCreate_8cpp_source.html @@ -128,7 +128,7 @@ $(document).ready(function() { init_codefold(0); });
44 return ret;
45
46 if (auto const mutableFlags = ctx.tx[~sfMutableFlags]; mutableFlags &&
-
47 (!*mutableFlags || *mutableFlags & tfMPTokenIssuanceCreateMutableMask))
+
47 (!*mutableFlags || *mutableFlags & tmfMPTokenIssuanceCreateMutableMask))
48 return temINVALID_FLAG;
49
50 if (ctx.tx.getFlags() & tfMPTokenIssuanceCreateMask)
@@ -295,6 +295,7 @@ $(document).ready(function() { init_codefold(0); });
ripple::maxMPTokenAmount
std::uint64_t constexpr maxMPTokenAmount
The maximum amount of MPTokenIssuance.
Definition Protocol.h:117
ripple::tfMPTokenIssuanceCreateMask
constexpr std::uint32_t const tfMPTokenIssuanceCreateMask
Definition TxFlags.h:151
ripple::maxTransferFee
std::uint16_t constexpr maxTransferFee
The maximum token transfer fee allowed.
Definition Protocol.h:83
+
ripple::tmfMPTokenIssuanceCreateMutableMask
constexpr std::uint32_t const tmfMPTokenIssuanceCreateMutableMask
Definition TxFlags.h:164
ripple::describeOwnerDir
std::function< void(SLE::ref)> describeOwnerDir(AccountID const &account)
Definition View.cpp:1048
ripple::preflight1
NotTEC preflight1(PreflightContext const &ctx)
Performs early sanity checks on the account and fee fields.
Definition Transactor.cpp:91
ripple::maxMPTokenMetadataLength
std::size_t constexpr maxMPTokenMetadataLength
The maximum length of MPTokenMetadata.
Definition Protocol.h:114
@@ -307,7 +308,6 @@ $(document).ready(function() { init_codefold(0); });
ripple::isTesSuccess
bool isTesSuccess(TER x) noexcept
Definition TER.h:674
ripple::makeMptID
MPTID makeMptID(std::uint32_t sequence, AccountID const &account)
Definition Indexes.cpp:170
ripple::tfMPTRequireAuth
constexpr std::uint32_t const tfMPTRequireAuth
Definition TxFlags.h:146
-
ripple::tfMPTokenIssuanceCreateMutableMask
constexpr std::uint32_t const tfMPTokenIssuanceCreateMutableMask
Definition TxFlags.h:164
ripple::NotTEC
TERSubset< CanCvtToNotTEC > NotTEC
Definition TER.h:605
ripple::temBAD_TRANSFER_FEE
@ temBAD_TRANSFER_FEE
Definition TER.h:142
ripple::temMALFORMED
@ temMALFORMED
Definition TER.h:87
diff --git a/MPTokenIssuanceSet_8cpp_source.html b/MPTokenIssuanceSet_8cpp_source.html index aa9b37140f..79ca805adb 100644 --- a/MPTokenIssuanceSet_8cpp_source.html +++ b/MPTokenIssuanceSet_8cpp_source.html @@ -123,338 +123,340 @@ $(document).ready(function() { init_codefold(0); });
38
39static constexpr std::array<MPTMutabilityFlags, 6> mptMutabilityFlags = {
-
40 {{tfMPTSetCanLock, tfMPTClearCanLock, lsfMPTCanMutateCanLock},
-
41 {tfMPTSetRequireAuth, tfMPTClearRequireAuth, lsfMPTCanMutateRequireAuth},
-
42 {tfMPTSetCanEscrow, tfMPTClearCanEscrow, lsfMPTCanMutateCanEscrow},
-
43 {tfMPTSetCanTrade, tfMPTClearCanTrade, lsfMPTCanMutateCanTrade},
-
44 {tfMPTSetCanTransfer, tfMPTClearCanTransfer, lsfMPTCanMutateCanTransfer},
-
45 {tfMPTSetCanClawback, tfMPTClearCanClawback, lsfMPTCanMutateCanClawback}}};
+
40 {{tmfMPTSetCanLock, tmfMPTClearCanLock, lmfMPTCanMutateCanLock},
+
41 {tmfMPTSetRequireAuth, tmfMPTClearRequireAuth, lmfMPTCanMutateRequireAuth},
+
42 {tmfMPTSetCanEscrow, tmfMPTClearCanEscrow, lmfMPTCanMutateCanEscrow},
+
43 {tmfMPTSetCanTrade, tmfMPTClearCanTrade, lmfMPTCanMutateCanTrade},
+
44 {tmfMPTSetCanTransfer, tmfMPTClearCanTransfer, lmfMPTCanMutateCanTransfer},
+
45 {tmfMPTSetCanClawback,
+
46 tmfMPTClearCanClawback,
+
47 lmfMPTCanMutateCanClawback}}};
-
46
-
47NotTEC
-
-
48MPTokenIssuanceSet::preflight(PreflightContext const& ctx)
-
49{
-
50 if (!ctx.rules.enabled(featureMPTokensV1))
-
51 return temDISABLED;
-
52
-
53 if (ctx.tx.isFieldPresent(sfDomainID) &&
-
54 !(ctx.rules.enabled(featurePermissionedDomains) &&
-
55 ctx.rules.enabled(featureSingleAssetVault)))
-
56 return temDISABLED;
-
57
-
58 auto const mutableFlags = ctx.tx[~sfMutableFlags];
-
59 auto const metadata = ctx.tx[~sfMPTokenMetadata];
-
60 auto const transferFee = ctx.tx[~sfTransferFee];
-
61 auto const isMutate = mutableFlags || metadata || transferFee;
-
62
-
63 if (isMutate && !ctx.rules.enabled(featureDynamicMPT))
-
64 return temDISABLED;
-
65
-
66 if (ctx.tx.isFieldPresent(sfDomainID) && ctx.tx.isFieldPresent(sfHolder))
-
67 return temMALFORMED;
-
68
-
69 if (auto const ret = preflight1(ctx); !isTesSuccess(ret))
-
70 return ret;
-
71
-
72 auto const txFlags = ctx.tx.getFlags();
+
48
+
49NotTEC
+
+
50MPTokenIssuanceSet::preflight(PreflightContext const& ctx)
+
51{
+
52 if (!ctx.rules.enabled(featureMPTokensV1))
+
53 return temDISABLED;
+
54
+
55 if (ctx.tx.isFieldPresent(sfDomainID) &&
+
56 !(ctx.rules.enabled(featurePermissionedDomains) &&
+
57 ctx.rules.enabled(featureSingleAssetVault)))
+
58 return temDISABLED;
+
59
+
60 auto const mutableFlags = ctx.tx[~sfMutableFlags];
+
61 auto const metadata = ctx.tx[~sfMPTokenMetadata];
+
62 auto const transferFee = ctx.tx[~sfTransferFee];
+
63 auto const isMutate = mutableFlags || metadata || transferFee;
+
64
+
65 if (isMutate && !ctx.rules.enabled(featureDynamicMPT))
+
66 return temDISABLED;
+
67
+
68 if (ctx.tx.isFieldPresent(sfDomainID) && ctx.tx.isFieldPresent(sfHolder))
+
69 return temMALFORMED;
+
70
+
71 if (auto const ret = preflight1(ctx); !isTesSuccess(ret))
+
72 return ret;
73
-
74 // check flags
-
75 if (txFlags & tfMPTokenIssuanceSetMask)
-
76 return temINVALID_FLAG;
-
77 // fails if both flags are set
-
78 else if ((txFlags & tfMPTLock) && (txFlags & tfMPTUnlock))
-
79 return temINVALID_FLAG;
-
80
-
81 auto const accountID = ctx.tx[sfAccount];
-
82 auto const holderID = ctx.tx[~sfHolder];
-
83 if (holderID && accountID == holderID)
-
84 return temMALFORMED;
-
85
-
86 if (ctx.rules.enabled(featureSingleAssetVault) ||
-
87 ctx.rules.enabled(featureDynamicMPT))
-
88 {
-
89 // Is this transaction actually changing anything ?
-
90 if (txFlags == 0 && !ctx.tx.isFieldPresent(sfDomainID) && !isMutate)
-
91 return temMALFORMED;
-
92 }
-
93
-
94 if (ctx.rules.enabled(featureDynamicMPT))
-
95 {
-
96 // Holder field is not allowed when mutating MPTokenIssuance
-
97 if (isMutate && holderID)
-
98 return temMALFORMED;
-
99
-
100 // Can not set flags when mutating MPTokenIssuance
-
101 if (isMutate && (txFlags & tfUniversalMask))
-
102 return temMALFORMED;
-
103
-
104 if (transferFee && *transferFee > maxTransferFee)
-
105 return temBAD_TRANSFER_FEE;
-
106
-
107 if (metadata && metadata->length() > maxMPTokenMetadataLength)
-
108 return temMALFORMED;
-
109
-
110 if (mutableFlags)
-
111 {
-
112 if (!*mutableFlags ||
-
113 (*mutableFlags & tfMPTokenIssuanceSetMutableMask))
-
114 return temINVALID_FLAG;
-
115
-
116 // Can not set and clear the same flag
-
117 if (std::any_of(
-
118 mptMutabilityFlags.begin(),
-
119 mptMutabilityFlags.end(),
-
120 [mutableFlags](auto const& f) {
-
121 return (*mutableFlags & f.setFlag) &&
-
122 (*mutableFlags & f.clearFlag);
-
123 }))
-
124 return temINVALID_FLAG;
-
125
-
126 // Trying to set a non-zero TransferFee and clear MPTCanTransfer
-
127 // in the same transaction is not allowed.
-
128 if (transferFee.value_or(0) &&
-
129 (*mutableFlags & tfMPTClearCanTransfer))
-
130 return temMALFORMED;
-
131 }
-
132 }
-
133
-
134 return preflight2(ctx);
-
135}
+
74 auto const txFlags = ctx.tx.getFlags();
+
75
+
76 // check flags
+
77 if (txFlags & tfMPTokenIssuanceSetMask)
+
78 return temINVALID_FLAG;
+
79 // fails if both flags are set
+
80 else if ((txFlags & tfMPTLock) && (txFlags & tfMPTUnlock))
+
81 return temINVALID_FLAG;
+
82
+
83 auto const accountID = ctx.tx[sfAccount];
+
84 auto const holderID = ctx.tx[~sfHolder];
+
85 if (holderID && accountID == holderID)
+
86 return temMALFORMED;
+
87
+
88 if (ctx.rules.enabled(featureSingleAssetVault) ||
+
89 ctx.rules.enabled(featureDynamicMPT))
+
90 {
+
91 // Is this transaction actually changing anything ?
+
92 if (txFlags == 0 && !ctx.tx.isFieldPresent(sfDomainID) && !isMutate)
+
93 return temMALFORMED;
+
94 }
+
95
+
96 if (ctx.rules.enabled(featureDynamicMPT))
+
97 {
+
98 // Holder field is not allowed when mutating MPTokenIssuance
+
99 if (isMutate && holderID)
+
100 return temMALFORMED;
+
101
+
102 // Can not set flags when mutating MPTokenIssuance
+
103 if (isMutate && (txFlags & tfUniversalMask))
+
104 return temMALFORMED;
+
105
+
106 if (transferFee && *transferFee > maxTransferFee)
+
107 return temBAD_TRANSFER_FEE;
+
108
+
109 if (metadata && metadata->length() > maxMPTokenMetadataLength)
+
110 return temMALFORMED;
+
111
+
112 if (mutableFlags)
+
113 {
+
114 if (!*mutableFlags ||
+
115 (*mutableFlags & tmfMPTokenIssuanceSetMutableMask))
+
116 return temINVALID_FLAG;
+
117
+
118 // Can not set and clear the same flag
+
119 if (std::any_of(
+
120 mptMutabilityFlags.begin(),
+
121 mptMutabilityFlags.end(),
+
122 [mutableFlags](auto const& f) {
+
123 return (*mutableFlags & f.setFlag) &&
+
124 (*mutableFlags & f.clearFlag);
+
125 }))
+
126 return temINVALID_FLAG;
+
127
+
128 // Trying to set a non-zero TransferFee and clear MPTCanTransfer
+
129 // in the same transaction is not allowed.
+
130 if (transferFee.value_or(0) &&
+
131 (*mutableFlags & tmfMPTClearCanTransfer))
+
132 return temMALFORMED;
+
133 }
+
134 }
+
135
+
136 return preflight2(ctx);
+
137}
-
136
-
137TER
-
-
138MPTokenIssuanceSet::checkPermission(ReadView const& view, STTx const& tx)
-
139{
-
140 auto const delegate = tx[~sfDelegate];
-
141 if (!delegate)
-
142 return tesSUCCESS;
-
143
-
144 auto const delegateKey = keylet::delegate(tx[sfAccount], *delegate);
-
145 auto const sle = view.read(delegateKey);
-
146
-
147 if (!sle)
-
148 return tecNO_DELEGATE_PERMISSION;
-
149
-
150 if (checkTxPermission(sle, tx) == tesSUCCESS)
-
151 return tesSUCCESS;
-
152
-
153 auto const txFlags = tx.getFlags();
+
138
+
139TER
+
+
140MPTokenIssuanceSet::checkPermission(ReadView const& view, STTx const& tx)
+
141{
+
142 auto const delegate = tx[~sfDelegate];
+
143 if (!delegate)
+
144 return tesSUCCESS;
+
145
+
146 auto const delegateKey = keylet::delegate(tx[sfAccount], *delegate);
+
147 auto const sle = view.read(delegateKey);
+
148
+
149 if (!sle)
+
150 return tecNO_DELEGATE_PERMISSION;
+
151
+
152 if (checkTxPermission(sle, tx) == tesSUCCESS)
+
153 return tesSUCCESS;
154
-
155 // this is added in case more flags will be added for MPTokenIssuanceSet
-
156 // in the future. Currently unreachable.
-
157 if (txFlags & tfMPTokenIssuanceSetPermissionMask)
-
158 return tecNO_DELEGATE_PERMISSION; // LCOV_EXCL_LINE
-
159
-
160 std::unordered_set<GranularPermissionType> granularPermissions;
-
161 loadGranularPermission(sle, ttMPTOKEN_ISSUANCE_SET, granularPermissions);
-
162
-
163 if (txFlags & tfMPTLock &&
-
164 !granularPermissions.contains(MPTokenIssuanceLock))
-
165 return tecNO_DELEGATE_PERMISSION;
-
166
-
167 if (txFlags & tfMPTUnlock &&
-
168 !granularPermissions.contains(MPTokenIssuanceUnlock))
-
169 return tecNO_DELEGATE_PERMISSION;
-
170
-
171 return tesSUCCESS;
-
172}
+
155 auto const txFlags = tx.getFlags();
+
156
+
157 // this is added in case more flags will be added for MPTokenIssuanceSet
+
158 // in the future. Currently unreachable.
+
159 if (txFlags & tfMPTokenIssuanceSetPermissionMask)
+
160 return tecNO_DELEGATE_PERMISSION; // LCOV_EXCL_LINE
+
161
+
162 std::unordered_set<GranularPermissionType> granularPermissions;
+
163 loadGranularPermission(sle, ttMPTOKEN_ISSUANCE_SET, granularPermissions);
+
164
+
165 if (txFlags & tfMPTLock &&
+
166 !granularPermissions.contains(MPTokenIssuanceLock))
+
167 return tecNO_DELEGATE_PERMISSION;
+
168
+
169 if (txFlags & tfMPTUnlock &&
+
170 !granularPermissions.contains(MPTokenIssuanceUnlock))
+
171 return tecNO_DELEGATE_PERMISSION;
+
172
+
173 return tesSUCCESS;
+
174}
-
173
-
174TER
-
-
175MPTokenIssuanceSet::preclaim(PreclaimContext const& ctx)
-
176{
-
177 // ensure that issuance exists
-
178 auto const sleMptIssuance =
-
179 ctx.view.read(keylet::mptIssuance(ctx.tx[sfMPTokenIssuanceID]));
-
180 if (!sleMptIssuance)
-
181 return tecOBJECT_NOT_FOUND;
-
182
-
183 if (!sleMptIssuance->isFlag(lsfMPTCanLock))
-
184 {
-
185 // For readability two separate `if` rather than `||` of two conditions
-
186 if (!ctx.view.rules().enabled(featureSingleAssetVault) &&
-
187 !ctx.view.rules().enabled(featureDynamicMPT))
-
188 return tecNO_PERMISSION;
-
189 else if (ctx.tx.isFlag(tfMPTLock) || ctx.tx.isFlag(tfMPTUnlock))
+
175
+
176TER
+
+
177MPTokenIssuanceSet::preclaim(PreclaimContext const& ctx)
+
178{
+
179 // ensure that issuance exists
+
180 auto const sleMptIssuance =
+
181 ctx.view.read(keylet::mptIssuance(ctx.tx[sfMPTokenIssuanceID]));
+
182 if (!sleMptIssuance)
+
183 return tecOBJECT_NOT_FOUND;
+
184
+
185 if (!sleMptIssuance->isFlag(lsfMPTCanLock))
+
186 {
+
187 // For readability two separate `if` rather than `||` of two conditions
+
188 if (!ctx.view.rules().enabled(featureSingleAssetVault) &&
+
189 !ctx.view.rules().enabled(featureDynamicMPT))
190 return tecNO_PERMISSION;
-
191 }
-
192
-
193 // ensure it is issued by the tx submitter
-
194 if ((*sleMptIssuance)[sfIssuer] != ctx.tx[sfAccount])
-
195 return tecNO_PERMISSION;
-
196
-
197 if (auto const holderID = ctx.tx[~sfHolder])
-
198 {
-
199 // make sure holder account exists
-
200 if (!ctx.view.exists(keylet::account(*holderID)))
-
201 return tecNO_DST;
-
202
-
203 // the mptoken must exist
-
204 if (!ctx.view.exists(
-
205 keylet::mptoken(ctx.tx[sfMPTokenIssuanceID], *holderID)))
-
206 return tecOBJECT_NOT_FOUND;
-
207 }
-
208
-
209 if (auto const domain = ctx.tx[~sfDomainID])
-
210 {
-
211 if (not sleMptIssuance->isFlag(lsfMPTRequireAuth))
-
212 return tecNO_PERMISSION;
-
213
-
214 if (*domain != beast::zero)
-
215 {
-
216 auto const sleDomain =
-
217 ctx.view.read(keylet::permissionedDomain(*domain));
-
218 if (!sleDomain)
-
219 return tecOBJECT_NOT_FOUND;
-
220 }
-
221 }
-
222
-
223 // sfMutableFlags is soeDEFAULT, defaulting to 0 if not specified on
-
224 // the ledger.
-
225 auto const currentMutableFlags =
-
226 sleMptIssuance->getFieldU32(sfMutableFlags);
-
227
-
228 auto isMutableFlag = [&](std::uint32_t mutableFlag) -> bool {
-
229 return currentMutableFlags & mutableFlag;
-
230 };
-
231
-
232 if (auto const mutableFlags = ctx.tx[~sfMutableFlags])
-
233 {
-
234 if (std::any_of(
-
235 mptMutabilityFlags.begin(),
-
236 mptMutabilityFlags.end(),
-
237 [mutableFlags, &isMutableFlag](auto const& f) {
-
238 return !isMutableFlag(f.canMutateFlag) &&
-
239 ((*mutableFlags & (f.setFlag | f.clearFlag)));
-
240 }))
-
241 return tecNO_PERMISSION;
-
242 }
-
243
-
244 if (!isMutableFlag(lsfMPTCanMutateMetadata) &&
-
245 ctx.tx.isFieldPresent(sfMPTokenMetadata))
-
246 return tecNO_PERMISSION;
-
247
-
248 if (auto const fee = ctx.tx[~sfTransferFee])
-
249 {
-
250 // A non-zero TransferFee is only valid if the lsfMPTCanTransfer flag
-
251 // was previously enabled (at issuance or via a prior mutation). Setting
-
252 // it by tfMPTSetCanTransfer in the current transaction does not meet
-
253 // this requirement.
-
254 if (fee > 0u && !sleMptIssuance->isFlag(lsfMPTCanTransfer))
-
255 return tecNO_PERMISSION;
-
256
-
257 if (!isMutableFlag(lsfMPTCanMutateTransferFee))
-
258 return tecNO_PERMISSION;
-
259 }
-
260
-
261 return tesSUCCESS;
-
262}
+
191 else if (ctx.tx.isFlag(tfMPTLock) || ctx.tx.isFlag(tfMPTUnlock))
+
192 return tecNO_PERMISSION;
+
193 }
+
194
+
195 // ensure it is issued by the tx submitter
+
196 if ((*sleMptIssuance)[sfIssuer] != ctx.tx[sfAccount])
+
197 return tecNO_PERMISSION;
+
198
+
199 if (auto const holderID = ctx.tx[~sfHolder])
+
200 {
+
201 // make sure holder account exists
+
202 if (!ctx.view.exists(keylet::account(*holderID)))
+
203 return tecNO_DST;
+
204
+
205 // the mptoken must exist
+
206 if (!ctx.view.exists(
+
207 keylet::mptoken(ctx.tx[sfMPTokenIssuanceID], *holderID)))
+
208 return tecOBJECT_NOT_FOUND;
+
209 }
+
210
+
211 if (auto const domain = ctx.tx[~sfDomainID])
+
212 {
+
213 if (not sleMptIssuance->isFlag(lsfMPTRequireAuth))
+
214 return tecNO_PERMISSION;
+
215
+
216 if (*domain != beast::zero)
+
217 {
+
218 auto const sleDomain =
+
219 ctx.view.read(keylet::permissionedDomain(*domain));
+
220 if (!sleDomain)
+
221 return tecOBJECT_NOT_FOUND;
+
222 }
+
223 }
+
224
+
225 // sfMutableFlags is soeDEFAULT, defaulting to 0 if not specified on
+
226 // the ledger.
+
227 auto const currentMutableFlags =
+
228 sleMptIssuance->getFieldU32(sfMutableFlags);
+
229
+
230 auto isMutableFlag = [&](std::uint32_t mutableFlag) -> bool {
+
231 return currentMutableFlags & mutableFlag;
+
232 };
+
233
+
234 if (auto const mutableFlags = ctx.tx[~sfMutableFlags])
+
235 {
+
236 if (std::any_of(
+
237 mptMutabilityFlags.begin(),
+
238 mptMutabilityFlags.end(),
+
239 [mutableFlags, &isMutableFlag](auto const& f) {
+
240 return !isMutableFlag(f.canMutateFlag) &&
+
241 ((*mutableFlags & (f.setFlag | f.clearFlag)));
+
242 }))
+
243 return tecNO_PERMISSION;
+
244 }
+
245
+
246 if (!isMutableFlag(lmfMPTCanMutateMetadata) &&
+
247 ctx.tx.isFieldPresent(sfMPTokenMetadata))
+
248 return tecNO_PERMISSION;
+
249
+
250 if (auto const fee = ctx.tx[~sfTransferFee])
+
251 {
+
252 // A non-zero TransferFee is only valid if the lsfMPTCanTransfer flag
+
253 // was previously enabled (at issuance or via a prior mutation). Setting
+
254 // it by tmfMPTSetCanTransfer in the current transaction does not meet
+
255 // this requirement.
+
256 if (fee > 0u && !sleMptIssuance->isFlag(lsfMPTCanTransfer))
+
257 return tecNO_PERMISSION;
+
258
+
259 if (!isMutableFlag(lmfMPTCanMutateTransferFee))
+
260 return tecNO_PERMISSION;
+
261 }
+
262
+
263 return tesSUCCESS;
+
264}
-
263
-
264TER
-
-
265MPTokenIssuanceSet::doApply()
-
266{
-
267 auto const mptIssuanceID = ctx_.tx[sfMPTokenIssuanceID];
-
268 auto const txFlags = ctx_.tx.getFlags();
-
269 auto const holderID = ctx_.tx[~sfHolder];
-
270 auto const domainID = ctx_.tx[~sfDomainID];
-
271 std::shared_ptr<SLE> sle;
-
272
-
273 if (holderID)
-
274 sle = view().peek(keylet::mptoken(mptIssuanceID, *holderID));
-
275 else
-
276 sle = view().peek(keylet::mptIssuance(mptIssuanceID));
-
277
-
278 if (!sle)
-
279 return tecINTERNAL;
-
280
-
281 std::uint32_t const flagsIn = sle->getFieldU32(sfFlags);
-
282 std::uint32_t flagsOut = flagsIn;
-
283
-
284 if (txFlags & tfMPTLock)
-
285 flagsOut |= lsfMPTLocked;
-
286 else if (txFlags & tfMPTUnlock)
-
287 flagsOut &= ~lsfMPTLocked;
-
288
-
289 if (auto const mutableFlags = ctx_.tx[~sfMutableFlags].value_or(0))
-
290 {
-
291 for (auto const& f : mptMutabilityFlags)
-
292 {
-
293 if (mutableFlags & f.setFlag)
-
294 flagsOut |= f.canMutateFlag;
-
295 else if (mutableFlags & f.clearFlag)
-
296 flagsOut &= ~f.canMutateFlag;
-
297 }
-
298
-
299 if (mutableFlags & tfMPTClearCanTransfer)
-
300 {
-
301 // If the lsfMPTCanTransfer flag is being cleared, then also clear
-
302 // the TransferFee field.
-
303 sle->makeFieldAbsent(sfTransferFee);
-
304 }
-
305 }
-
306
-
307 if (flagsIn != flagsOut)
-
308 sle->setFieldU32(sfFlags, flagsOut);
-
309
-
310 if (auto const transferFee = ctx_.tx[~sfTransferFee])
-
311 {
-
312 // TransferFee uses soeDEFAULT style:
-
313 // - If the field is absent, it is interpreted as 0.
-
314 // - If the field is present, it must be non-zero.
-
315 // Therefore, when TransferFee is 0, the field should be removed.
-
316 if (transferFee == 0)
-
317 sle->makeFieldAbsent(sfTransferFee);
-
318 else
-
319 sle->setFieldU16(sfTransferFee, *transferFee);
-
320 }
-
321
-
322 if (auto const metadata = ctx_.tx[~sfMPTokenMetadata])
-
323 {
-
324 if (metadata->empty())
-
325 sle->makeFieldAbsent(sfMPTokenMetadata);
-
326 else
-
327 sle->setFieldVL(sfMPTokenMetadata, *metadata);
-
328 }
-
329
-
330 if (domainID)
-
331 {
-
332 // This is enforced in preflight.
-
333 XRPL_ASSERT(
-
334 sle->getType() == ltMPTOKEN_ISSUANCE,
-
335 "MPTokenIssuanceSet::doApply : modifying MPTokenIssuance");
-
336
-
337 if (*domainID != beast::zero)
-
338 {
-
339 sle->setFieldH256(sfDomainID, *domainID);
-
340 }
-
341 else
-
342 {
-
343 if (sle->isFieldPresent(sfDomainID))
-
344 sle->makeFieldAbsent(sfDomainID);
-
345 }
-
346 }
-
347
-
348 view().update(sle);
+
265
+
266TER
+
+
267MPTokenIssuanceSet::doApply()
+
268{
+
269 auto const mptIssuanceID = ctx_.tx[sfMPTokenIssuanceID];
+
270 auto const txFlags = ctx_.tx.getFlags();
+
271 auto const holderID = ctx_.tx[~sfHolder];
+
272 auto const domainID = ctx_.tx[~sfDomainID];
+
273 std::shared_ptr<SLE> sle;
+
274
+
275 if (holderID)
+
276 sle = view().peek(keylet::mptoken(mptIssuanceID, *holderID));
+
277 else
+
278 sle = view().peek(keylet::mptIssuance(mptIssuanceID));
+
279
+
280 if (!sle)
+
281 return tecINTERNAL;
+
282
+
283 std::uint32_t const flagsIn = sle->getFieldU32(sfFlags);
+
284 std::uint32_t flagsOut = flagsIn;
+
285
+
286 if (txFlags & tfMPTLock)
+
287 flagsOut |= lsfMPTLocked;
+
288 else if (txFlags & tfMPTUnlock)
+
289 flagsOut &= ~lsfMPTLocked;
+
290
+
291 if (auto const mutableFlags = ctx_.tx[~sfMutableFlags].value_or(0))
+
292 {
+
293 for (auto const& f : mptMutabilityFlags)
+
294 {
+
295 if (mutableFlags & f.setFlag)
+
296 flagsOut |= f.canMutateFlag;
+
297 else if (mutableFlags & f.clearFlag)
+
298 flagsOut &= ~f.canMutateFlag;
+
299 }
+
300
+
301 if (mutableFlags & tmfMPTClearCanTransfer)
+
302 {
+
303 // If the lsfMPTCanTransfer flag is being cleared, then also clear
+
304 // the TransferFee field.
+
305 sle->makeFieldAbsent(sfTransferFee);
+
306 }
+
307 }
+
308
+
309 if (flagsIn != flagsOut)
+
310 sle->setFieldU32(sfFlags, flagsOut);
+
311
+
312 if (auto const transferFee = ctx_.tx[~sfTransferFee])
+
313 {
+
314 // TransferFee uses soeDEFAULT style:
+
315 // - If the field is absent, it is interpreted as 0.
+
316 // - If the field is present, it must be non-zero.
+
317 // Therefore, when TransferFee is 0, the field should be removed.
+
318 if (transferFee == 0)
+
319 sle->makeFieldAbsent(sfTransferFee);
+
320 else
+
321 sle->setFieldU16(sfTransferFee, *transferFee);
+
322 }
+
323
+
324 if (auto const metadata = ctx_.tx[~sfMPTokenMetadata])
+
325 {
+
326 if (metadata->empty())
+
327 sle->makeFieldAbsent(sfMPTokenMetadata);
+
328 else
+
329 sle->setFieldVL(sfMPTokenMetadata, *metadata);
+
330 }
+
331
+
332 if (domainID)
+
333 {
+
334 // This is enforced in preflight.
+
335 XRPL_ASSERT(
+
336 sle->getType() == ltMPTOKEN_ISSUANCE,
+
337 "MPTokenIssuanceSet::doApply : modifying MPTokenIssuance");
+
338
+
339 if (*domainID != beast::zero)
+
340 {
+
341 sle->setFieldH256(sfDomainID, *domainID);
+
342 }
+
343 else
+
344 {
+
345 if (sle->isFieldPresent(sfDomainID))
+
346 sle->makeFieldAbsent(sfDomainID);
+
347 }
+
348 }
349
-
350 return tesSUCCESS;
-
351}
+
350 view().update(sle);
+
351
+
352 return tesSUCCESS;
+
353}
-
352
-
353} // namespace ripple
+
354
+
355} // namespace ripple
std::any_of
T any_of(T... args)
ripple::ApplyView::update
virtual void update(std::shared_ptr< SLE > const &sle)=0
Indicate changes to a peeked SLE.
ripple::ApplyView::peek
virtual std::shared_ptr< SLE > peek(Keylet const &k)=0
Prepare to modify the SLE associated with key.
-
ripple::MPTokenIssuanceSet::preclaim
static TER preclaim(PreclaimContext const &ctx)
Definition MPTokenIssuanceSet.cpp:175
-
ripple::MPTokenIssuanceSet::preflight
static NotTEC preflight(PreflightContext const &ctx)
Definition MPTokenIssuanceSet.cpp:48
-
ripple::MPTokenIssuanceSet::checkPermission
static TER checkPermission(ReadView const &view, STTx const &tx)
Definition MPTokenIssuanceSet.cpp:138
- +
ripple::MPTokenIssuanceSet::preclaim
static TER preclaim(PreclaimContext const &ctx)
Definition MPTokenIssuanceSet.cpp:177
+
ripple::MPTokenIssuanceSet::preflight
static NotTEC preflight(PreflightContext const &ctx)
Definition MPTokenIssuanceSet.cpp:50
+
ripple::MPTokenIssuanceSet::checkPermission
static TER checkPermission(ReadView const &view, STTx const &tx)
Definition MPTokenIssuanceSet.cpp:140
+
ripple::ReadView
A view into a ledger.
Definition ReadView.h:52
ripple::ReadView::read
virtual std::shared_ptr< SLE const > read(Keylet const &k) const =0
Return the state item associated with a key.
ripple::ReadView::exists
virtual bool exists(Keylet const &k) const =0
Determine if a state item exists.
@@ -477,34 +479,36 @@ $(document).ready(function() { init_codefold(0); });
ripple
Use hash_* containers for keys that do not need a cryptographically secure hashing algorithm.
Definition algorithm.h:25
ripple::tfMPTokenIssuanceSetMask
constexpr std::uint32_t const tfMPTokenIssuanceSetMask
Definition TxFlags.h:175
ripple::tfMPTokenIssuanceSetPermissionMask
constexpr std::uint32_t const tfMPTokenIssuanceSetPermissionMask
Definition TxFlags.h:176
-
ripple::tfMPTClearCanLock
constexpr std::uint32_t const tfMPTClearCanLock
Definition TxFlags.h:181
-
ripple::tfMPTClearCanEscrow
constexpr std::uint32_t const tfMPTClearCanEscrow
Definition TxFlags.h:185
-
ripple::tfMPTSetRequireAuth
constexpr std::uint32_t const tfMPTSetRequireAuth
Definition TxFlags.h:182
-
ripple::tfMPTClearCanTransfer
constexpr std::uint32_t const tfMPTClearCanTransfer
Definition TxFlags.h:189
+
ripple::tmfMPTClearCanClawback
constexpr std::uint32_t const tmfMPTClearCanClawback
Definition TxFlags.h:191
+
ripple::tmfMPTokenIssuanceSetMutableMask
constexpr std::uint32_t const tmfMPTokenIssuanceSetMutableMask
Definition TxFlags.h:192
+
ripple::tmfMPTClearCanEscrow
constexpr std::uint32_t const tmfMPTClearCanEscrow
Definition TxFlags.h:185
+
ripple::tmfMPTSetCanClawback
constexpr std::uint32_t const tmfMPTSetCanClawback
Definition TxFlags.h:190
+
ripple::tmfMPTSetRequireAuth
constexpr std::uint32_t const tmfMPTSetRequireAuth
Definition TxFlags.h:182
+
ripple::tmfMPTClearCanTrade
constexpr std::uint32_t const tmfMPTClearCanTrade
Definition TxFlags.h:187
ripple::tfMPTUnlock
constexpr std::uint32_t const tfMPTUnlock
Definition TxFlags.h:174
-
ripple::tfMPTClearCanTrade
constexpr std::uint32_t const tfMPTClearCanTrade
Definition TxFlags.h:187
-
ripple::lsfMPTCanMutateCanLock
@ lsfMPTCanMutateCanLock
Definition LedgerFormats.h:191
-
ripple::lsfMPTCanMutateMetadata
@ lsfMPTCanMutateMetadata
Definition LedgerFormats.h:197
ripple::lsfMPTCanTransfer
@ lsfMPTCanTransfer
Definition LedgerFormats.h:188
-
ripple::lsfMPTCanMutateCanClawback
@ lsfMPTCanMutateCanClawback
Definition LedgerFormats.h:196
-
ripple::lsfMPTCanMutateCanTransfer
@ lsfMPTCanMutateCanTransfer
Definition LedgerFormats.h:195
+
ripple::lmfMPTCanMutateMetadata
@ lmfMPTCanMutateMetadata
Definition LedgerFormats.h:197
+
ripple::lmfMPTCanMutateCanTransfer
@ lmfMPTCanMutateCanTransfer
Definition LedgerFormats.h:195
+
ripple::lmfMPTCanMutateTransferFee
@ lmfMPTCanMutateTransferFee
Definition LedgerFormats.h:198
+
ripple::lmfMPTCanMutateCanClawback
@ lmfMPTCanMutateCanClawback
Definition LedgerFormats.h:196
+
ripple::lmfMPTCanMutateRequireAuth
@ lmfMPTCanMutateRequireAuth
Definition LedgerFormats.h:192
ripple::lsfMPTRequireAuth
@ lsfMPTRequireAuth
Definition LedgerFormats.h:185
-
ripple::lsfMPTCanMutateCanEscrow
@ lsfMPTCanMutateCanEscrow
Definition LedgerFormats.h:193
-
ripple::lsfMPTCanMutateCanTrade
@ lsfMPTCanMutateCanTrade
Definition LedgerFormats.h:194
+
ripple::lmfMPTCanMutateCanLock
@ lmfMPTCanMutateCanLock
Definition LedgerFormats.h:191
-
ripple::lsfMPTCanMutateRequireAuth
@ lsfMPTCanMutateRequireAuth
Definition LedgerFormats.h:192
-
ripple::lsfMPTCanMutateTransferFee
@ lsfMPTCanMutateTransferFee
Definition LedgerFormats.h:198
+
ripple::lmfMPTCanMutateCanEscrow
@ lmfMPTCanMutateCanEscrow
Definition LedgerFormats.h:193
+
ripple::lmfMPTCanMutateCanTrade
@ lmfMPTCanMutateCanTrade
Definition LedgerFormats.h:194
+
ripple::tmfMPTClearRequireAuth
constexpr std::uint32_t const tmfMPTClearRequireAuth
Definition TxFlags.h:183
ripple::maxTransferFee
std::uint16_t constexpr maxTransferFee
The maximum token transfer fee allowed.
Definition Protocol.h:83
+
ripple::tmfMPTSetCanLock
constexpr std::uint32_t const tmfMPTSetCanLock
Definition TxFlags.h:180
ripple::preflight1
NotTEC preflight1(PreflightContext const &ctx)
Performs early sanity checks on the account and fee fields.
Definition Transactor.cpp:91
-
ripple::tfMPTSetCanTransfer
constexpr std::uint32_t const tfMPTSetCanTransfer
Definition TxFlags.h:188
-
ripple::tfMPTSetCanEscrow
constexpr std::uint32_t const tfMPTSetCanEscrow
Definition TxFlags.h:184
+
ripple::tmfMPTSetCanTrade
constexpr std::uint32_t const tmfMPTSetCanTrade
Definition TxFlags.h:186
ripple::maxMPTokenMetadataLength
std::size_t constexpr maxMPTokenMetadataLength
The maximum length of MPTokenMetadata.
Definition Protocol.h:114
-
ripple::tfMPTSetCanTrade
constexpr std::uint32_t const tfMPTSetCanTrade
Definition TxFlags.h:186
ripple::loadGranularPermission
void loadGranularPermission(std::shared_ptr< SLE const > const &delegate, TxType const &type, std::unordered_set< GranularPermissionType > &granularPermissions)
Load the granular permissions granted to the delegate account for the specified transaction type.
Definition DelegateUtils.cpp:45
+
ripple::tmfMPTSetCanEscrow
constexpr std::uint32_t const tmfMPTSetCanEscrow
Definition TxFlags.h:184
+
ripple::tmfMPTClearCanLock
constexpr std::uint32_t const tmfMPTClearCanLock
Definition TxFlags.h:181
ripple::preflight2
NotTEC preflight2(PreflightContext const &ctx)
Checks whether the signature appears valid.
Definition Transactor.cpp:160
-
ripple::tfMPTSetCanClawback
constexpr std::uint32_t const tfMPTSetCanClawback
Definition TxFlags.h:190
-
ripple::tfMPTClearCanClawback
constexpr std::uint32_t const tfMPTClearCanClawback
Definition TxFlags.h:191
+
ripple::tmfMPTSetCanTransfer
constexpr std::uint32_t const tmfMPTSetCanTransfer
Definition TxFlags.h:188
ripple::checkTxPermission
TER checkTxPermission(std::shared_ptr< SLE const > const &delegate, STTx const &tx)
Check if the delegate account has permission to execute the transaction.
Definition DelegateUtils.cpp:26
ripple::tecNO_DELEGATE_PERMISSION
@ tecNO_DELEGATE_PERMISSION
Definition TER.h:364
ripple::tecNO_DST
@ tecNO_DST
Definition TER.h:290
@@ -514,10 +518,8 @@ $(document).ready(function() { init_codefold(0); });
ripple::tfMPTLock
constexpr std::uint32_t const tfMPTLock
Definition TxFlags.h:173
ripple::tesSUCCESS
@ tesSUCCESS
Definition TER.h:244
ripple::isTesSuccess
bool isTesSuccess(TER x) noexcept
Definition TER.h:674
-
ripple::tfMPTokenIssuanceSetMutableMask
constexpr std::uint32_t const tfMPTokenIssuanceSetMutableMask
Definition TxFlags.h:192
ripple::tfUniversalMask
constexpr std::uint32_t tfUniversalMask
Definition TxFlags.h:63
-
ripple::tfMPTSetCanLock
constexpr std::uint32_t const tfMPTSetCanLock
Definition TxFlags.h:180
-
ripple::tfMPTClearRequireAuth
constexpr std::uint32_t const tfMPTClearRequireAuth
Definition TxFlags.h:183
+
ripple::tmfMPTClearCanTransfer
constexpr std::uint32_t const tmfMPTClearCanTransfer
Definition TxFlags.h:189
ripple::mptMutabilityFlags
static constexpr std::array< MPTMutabilityFlags, 6 > mptMutabilityFlags
Definition MPTokenIssuanceSet.cpp:39
ripple::NotTEC
TERSubset< CanCvtToNotTEC > NotTEC
Definition TER.h:605
ripple::temBAD_TRANSFER_FEE
@ temBAD_TRANSFER_FEE
Definition TER.h:142
diff --git a/MPTokenIssuanceSet_8h_source.html b/MPTokenIssuanceSet_8h_source.html index fec8181c89..e0c55c1d66 100644 --- a/MPTokenIssuanceSet_8h_source.html +++ b/MPTokenIssuanceSet_8h_source.html @@ -138,11 +138,11 @@ $(document).ready(function() { init_codefold(0); });
51#endif
ripple::ApplyContext
State information when applying a tx.
Definition ApplyContext.h:37
-
ripple::MPTokenIssuanceSet::preclaim
static TER preclaim(PreclaimContext const &ctx)
Definition MPTokenIssuanceSet.cpp:175
-
ripple::MPTokenIssuanceSet::preflight
static NotTEC preflight(PreflightContext const &ctx)
Definition MPTokenIssuanceSet.cpp:48
+
ripple::MPTokenIssuanceSet::preclaim
static TER preclaim(PreclaimContext const &ctx)
Definition MPTokenIssuanceSet.cpp:177
+
ripple::MPTokenIssuanceSet::preflight
static NotTEC preflight(PreflightContext const &ctx)
Definition MPTokenIssuanceSet.cpp:50
ripple::MPTokenIssuanceSet::MPTokenIssuanceSet
MPTokenIssuanceSet(ApplyContext &ctx)
Definition MPTokenIssuanceSet.h:32
-
ripple::MPTokenIssuanceSet::checkPermission
static TER checkPermission(ReadView const &view, STTx const &tx)
Definition MPTokenIssuanceSet.cpp:138
- +
ripple::MPTokenIssuanceSet::checkPermission
static TER checkPermission(ReadView const &view, STTx const &tx)
Definition MPTokenIssuanceSet.cpp:140
+
ripple::MPTokenIssuanceSet::ConsequencesFactory
static constexpr ConsequencesFactoryType ConsequencesFactory
Definition MPTokenIssuanceSet.h:30
ripple::ReadView
A view into a ledger.
Definition ReadView.h:52
diff --git a/MPToken__test_8cpp_source.html b/MPToken__test_8cpp_source.html index ba9ea1f02d..69461ed27a 100644 --- a/MPToken__test_8cpp_source.html +++ b/MPToken__test_8cpp_source.html @@ -2990,8 +2990,8 @@ $(document).ready(function() { init_codefold(0); });
2871 MPTTester mptAlice(env, alice, {.holders = {bob}});
2872 mptAlice.create(
2873 {.ownerCount = 1,
-
2874 .mutableFlags = tfMPTCanMutateMetadata |
-
2875 tfMPTCanMutateCanLock | tfMPTCanMutateTransferFee});
+
2874 .mutableFlags = tmfMPTCanMutateMetadata |
+
2875 tmfMPTCanMutateCanLock | tmfMPTCanMutateTransferFee});
2876
2877 // Setting flags is not allowed when MutableFlags is present
2878 mptAlice.set(
@@ -3025,7 +3025,7 @@ $(document).ready(function() { init_codefold(0); });
2906 .ownerCount = 1,
2907 .flags = tfMPTCanTransfer,
2908 .mutableFlags =
-
2909 tfMPTCanMutateTransferFee | tfMPTCanMutateMetadata});
+
2909 tmfMPTCanMutateTransferFee | tmfMPTCanMutateMetadata});
2910
2911 mptAlice.set(
2912 {.account = alice,
@@ -3062,15 +3062,15 @@ $(document).ready(function() { init_codefold(0); });
2943 auto const mptID = makeMptID(env.seq(alice), alice);
2944
2945 auto const flagCombinations = {
-
2946 tfMPTSetCanLock | tfMPTClearCanLock,
-
2947 tfMPTSetRequireAuth | tfMPTClearRequireAuth,
-
2948 tfMPTSetCanEscrow | tfMPTClearCanEscrow,
-
2949 tfMPTSetCanTrade | tfMPTClearCanTrade,
-
2950 tfMPTSetCanTransfer | tfMPTClearCanTransfer,
-
2951 tfMPTSetCanClawback | tfMPTClearCanClawback,
-
2952 tfMPTSetCanLock | tfMPTClearCanLock | tfMPTClearCanTrade,
-
2953 tfMPTSetCanTransfer | tfMPTClearCanTransfer |
-
2954 tfMPTSetCanEscrow | tfMPTClearCanClawback};
+
2946 tmfMPTSetCanLock | tmfMPTClearCanLock,
+
2947 tmfMPTSetRequireAuth | tmfMPTClearRequireAuth,
+
2948 tmfMPTSetCanEscrow | tmfMPTClearCanEscrow,
+
2949 tmfMPTSetCanTrade | tmfMPTClearCanTrade,
+
2950 tmfMPTSetCanTransfer | tmfMPTClearCanTransfer,
+
2951 tmfMPTSetCanClawback | tmfMPTClearCanClawback,
+
2952 tmfMPTSetCanLock | tmfMPTClearCanLock | tmfMPTClearCanTrade,
+
2953 tmfMPTSetCanTransfer | tmfMPTClearCanTransfer |
+
2954 tmfMPTSetCanEscrow | tmfMPTClearCanClawback};
2955
2956 for (auto const& mutableFlags : flagCombinations)
2957 {
@@ -3090,18 +3090,18 @@ $(document).ready(function() { init_codefold(0); });
2971 mptAlice.create({.ownerCount = 1});
2972
2973 auto const mutableFlags = {
-
2974 tfMPTSetCanLock,
-
2975 tfMPTClearCanLock,
-
2976 tfMPTSetRequireAuth,
-
2977 tfMPTClearRequireAuth,
-
2978 tfMPTSetCanEscrow,
-
2979 tfMPTClearCanEscrow,
-
2980 tfMPTSetCanTrade,
-
2981 tfMPTClearCanTrade,
-
2982 tfMPTSetCanTransfer,
-
2983 tfMPTClearCanTransfer,
-
2984 tfMPTSetCanClawback,
-
2985 tfMPTClearCanClawback};
+
2974 tmfMPTSetCanLock,
+
2975 tmfMPTClearCanLock,
+
2976 tmfMPTSetRequireAuth,
+
2977 tmfMPTClearRequireAuth,
+
2978 tmfMPTSetCanEscrow,
+
2979 tmfMPTClearCanEscrow,
+
2980 tmfMPTSetCanTrade,
+
2981 tmfMPTClearCanTrade,
+
2982 tmfMPTSetCanTransfer,
+
2983 tmfMPTClearCanTransfer,
+
2984 tmfMPTSetCanClawback,
+
2985 tmfMPTClearCanClawback};
2986
2987 for (auto const& mutableFlag : mutableFlags)
2988 {
@@ -3118,7 +3118,7 @@ $(document).ready(function() { init_codefold(0); });
2999 MPTTester mptAlice(env, alice, {.holders = {bob}});
3000
3001 mptAlice.create(
-
3002 {.ownerCount = 1, .mutableFlags = tfMPTCanMutateMetadata});
+
3002 {.ownerCount = 1, .mutableFlags = tmfMPTCanMutateMetadata});
3003
3004 std::string metadata(maxMPTokenMetadataLength + 1, 'a');
3005 mptAlice.set(
@@ -3144,7 +3144,7 @@ $(document).ready(function() { init_codefold(0); });
3025 auto const mptID = makeMptID(env.seq(alice), alice);
3026
3027 mptAlice.create(
-
3028 {.ownerCount = 1, .mutableFlags = tfMPTCanMutateTransferFee});
+
3028 {.ownerCount = 1, .mutableFlags = tmfMPTCanMutateTransferFee});
3029
3030 mptAlice.set(
3031 {.account = alice,
@@ -3164,13 +3164,13 @@ $(document).ready(function() { init_codefold(0); });
3045 .ownerCount = 1,
3046 .flags = tfMPTCanTransfer,
3047 .mutableFlags =
-
3048 tfMPTCanMutateTransferFee | tfMPTCanMutateCanTransfer});
+
3048 tmfMPTCanMutateTransferFee | tmfMPTCanMutateCanTransfer});
3049
3050 // Can not set non-zero transfer fee and clear MPTCanTransfer at the
3051 // same time
3052 mptAlice.set(
3053 {.account = alice,
-
3054 .mutableFlags = tfMPTClearCanTransfer,
+
3054 .mutableFlags = tmfMPTClearCanTransfer,
3055 .transferFee = 1,
3056 .err = temMALFORMED});
3057
@@ -3179,7 +3179,7 @@ $(document).ready(function() { init_codefold(0); });
3060 // be removed.
3061 mptAlice.set(
3062 {.account = alice,
-
3063 .mutableFlags = tfMPTClearCanTransfer,
+
3063 .mutableFlags = tmfMPTClearCanTransfer,
3064 .transferFee = 0});
3065 BEAST_EXPECT(!mptAlice.isTransferFeePresent());
3066 }
@@ -3192,7 +3192,7 @@ $(document).ready(function() { init_codefold(0); });
3073 mptAlice.create(
3074 {.ownerCount = 1,
3075 .mutableFlags =
-
3076 tfMPTCanMutateTransferFee | tfMPTCanMutateCanTransfer});
+
3076 tmfMPTCanMutateTransferFee | tmfMPTCanMutateCanTransfer});
3077
3078 mptAlice.set(
3079 {.account = alice,
@@ -3204,7 +3204,7 @@ $(document).ready(function() { init_codefold(0); });
3085 // fee can be set in a separate transaction.
3086 mptAlice.set(
3087 {.account = alice,
-
3088 .mutableFlags = tfMPTSetCanTransfer,
+
3088 .mutableFlags = tmfMPTSetCanTransfer,
3089 .transferFee = 100,
3090 .err = tecNO_PERMISSION});
3091 }
@@ -3235,8 +3235,8 @@ $(document).ready(function() { init_codefold(0); });
3116
3117 mptAlice.create(
3118 {.ownerCount = 1,
-
3119 .mutableFlags = tfMPTCanMutateCanTrade |
-
3120 tfMPTCanMutateCanTransfer | tfMPTCanMutateMetadata});
+
3119 .mutableFlags = tmfMPTCanMutateCanTrade |
+
3120 tmfMPTCanMutateCanTransfer | tmfMPTCanMutateMetadata});
3121
3122 // Can not mutate transfer fee
3123 mptAlice.set(
@@ -3245,14 +3245,14 @@ $(document).ready(function() { init_codefold(0); });
3126 .err = tecNO_PERMISSION});
3127
3128 auto const invalidFlags = {
-
3129 tfMPTSetCanLock,
-
3130 tfMPTClearCanLock,
-
3131 tfMPTSetRequireAuth,
-
3132 tfMPTClearRequireAuth,
-
3133 tfMPTSetCanEscrow,
-
3134 tfMPTClearCanEscrow,
-
3135 tfMPTSetCanClawback,
-
3136 tfMPTClearCanClawback};
+
3129 tmfMPTSetCanLock,
+
3130 tmfMPTClearCanLock,
+
3131 tmfMPTSetRequireAuth,
+
3132 tmfMPTClearRequireAuth,
+
3133 tmfMPTSetCanEscrow,
+
3134 tmfMPTClearCanEscrow,
+
3135 tmfMPTSetCanClawback,
+
3136 tmfMPTClearCanClawback};
3137
3138 // Can not mutate flags which are not mutable
3139 for (auto const& mutableFlag : invalidFlags)
@@ -3264,15 +3264,15 @@ $(document).ready(function() { init_codefold(0); });
3145 }
3146
3147 // Can mutate MPTCanTrade
-
3148 mptAlice.set({.account = alice, .mutableFlags = tfMPTSetCanTrade});
+
3148 mptAlice.set({.account = alice, .mutableFlags = tmfMPTSetCanTrade});
3149 mptAlice.set(
-
3150 {.account = alice, .mutableFlags = tfMPTClearCanTrade});
+
3150 {.account = alice, .mutableFlags = tmfMPTClearCanTrade});
3151
3152 // Can mutate MPTCanTransfer
3153 mptAlice.set(
-
3154 {.account = alice, .mutableFlags = tfMPTSetCanTransfer});
+
3154 {.account = alice, .mutableFlags = tmfMPTSetCanTransfer});
3155 mptAlice.set(
-
3156 {.account = alice, .mutableFlags = tfMPTClearCanTransfer});
+
3156 {.account = alice, .mutableFlags = tmfMPTClearCanTransfer});
3157
3158 // Can mutate metadata
3159 mptAlice.set({.account = alice, .metadata = "test"});
@@ -3297,7 +3297,7 @@ $(document).ready(function() { init_codefold(0); });
3176 mptAlice.create(
3177 {.metadata = "test",
3178 .ownerCount = 1,
-
3179 .mutableFlags = tfMPTCanMutateMetadata});
+
3179 .mutableFlags = tmfMPTCanMutateMetadata});
3180
3181 std::vector<std::string> metadatas = {
3182 "mutate metadata",
@@ -3327,7 +3327,7 @@ $(document).ready(function() { init_codefold(0); });
3206 .metadata = "test",
3207 .ownerCount = 1,
3208 .flags = tfMPTCanTransfer,
-
3209 .mutableFlags = tfMPTCanMutateTransferFee});
+
3209 .mutableFlags = tmfMPTCanMutateTransferFee});
3210
3211 for (std::uint16_t const fee : std::initializer_list<std::uint16_t>{
3212 1, 10, 100, 200, 500, 1000, maxTransferFee})
@@ -3371,459 +3371,468 @@ $(document).ready(function() { init_codefold(0); });
3250 };
3251
3252 testFlagToggle(
-
3253 tfMPTCanMutateCanLock, tfMPTCanLock, tfMPTClearCanLock);
+
3253 tmfMPTCanMutateCanLock, tfMPTCanLock, tmfMPTClearCanLock);
3254 testFlagToggle(
-
3255 tfMPTCanMutateRequireAuth,
-
3256 tfMPTSetRequireAuth,
-
3257 tfMPTClearRequireAuth);
+
3255 tmfMPTCanMutateRequireAuth,
+
3256 tmfMPTSetRequireAuth,
+
3257 tmfMPTClearRequireAuth);
3258 testFlagToggle(
-
3259 tfMPTCanMutateCanEscrow,
-
3260 tfMPTSetCanEscrow,
-
3261 tfMPTClearCanEscrow);
+
3259 tmfMPTCanMutateCanEscrow,
+
3260 tmfMPTSetCanEscrow,
+
3261 tmfMPTClearCanEscrow);
3262 testFlagToggle(
-
3263 tfMPTCanMutateCanTrade, tfMPTSetCanTrade, tfMPTClearCanTrade);
-
3264 testFlagToggle(
-
3265 tfMPTCanMutateCanTransfer,
-
3266 tfMPTSetCanTransfer,
-
3267 tfMPTClearCanTransfer);
-
3268 testFlagToggle(
-
3269 tfMPTCanMutateCanClawback,
-
3270 tfMPTSetCanClawback,
-
3271 tfMPTClearCanClawback);
-
3272 }
-
3273 }
+
3263 tmfMPTCanMutateCanTrade,
+
3264 tmfMPTSetCanTrade,
+
3265 tmfMPTClearCanTrade);
+
3266 testFlagToggle(
+
3267 tmfMPTCanMutateCanTransfer,
+
3268 tmfMPTSetCanTransfer,
+
3269 tmfMPTClearCanTransfer);
+
3270 testFlagToggle(
+
3271 tmfMPTCanMutateCanClawback,
+
3272 tmfMPTSetCanClawback,
+
3273 tmfMPTClearCanClawback);
+
3274 }
+
3275 }
-
3274
-
3275 void
-
-
3276 testMutateCanLock(FeatureBitset features)
-
3277 {
-
3278 testcase("Mutate MPTCanLock");
-
3279 using namespace test::jtx;
-
3280
-
3281 Account const alice("alice");
-
3282 Account const bob("bob");
-
3283
-
3284 // Individual lock
-
3285 {
-
3286 Env env{*this, features};
-
3287 MPTTester mptAlice(env, alice, {.holders = {bob}});
-
3288 mptAlice.create(
-
3289 {.ownerCount = 1,
-
3290 .holderCount = 0,
-
3291 .flags = tfMPTCanLock | tfMPTCanTransfer,
-
3292 .mutableFlags = tfMPTCanMutateCanLock |
-
3293 tfMPTCanMutateCanTrade | tfMPTCanMutateTransferFee});
-
3294 mptAlice.authorize({.account = bob, .holderCount = 1});
-
3295
-
3296 // Lock bob's mptoken
-
3297 mptAlice.set({.account = alice, .holder = bob, .flags = tfMPTLock});
-
3298
-
3299 // Can mutate the mutable flags and fields
-
3300 mptAlice.set({.account = alice, .mutableFlags = tfMPTClearCanLock});
-
3301 mptAlice.set({.account = alice, .mutableFlags = tfMPTSetCanLock});
-
3302 mptAlice.set({.account = alice, .mutableFlags = tfMPTClearCanLock});
-
3303 mptAlice.set({.account = alice, .mutableFlags = tfMPTSetCanTrade});
-
3304 mptAlice.set(
-
3305 {.account = alice, .mutableFlags = tfMPTClearCanTrade});
-
3306 mptAlice.set({.account = alice, .transferFee = 200});
-
3307 }
-
3308
-
3309 // Global lock
-
3310 {
-
3311 Env env{*this, features};
-
3312 MPTTester mptAlice(env, alice, {.holders = {bob}});
-
3313 mptAlice.create(
-
3314 {.ownerCount = 1,
-
3315 .holderCount = 0,
-
3316 .flags = tfMPTCanLock,
-
3317 .mutableFlags = tfMPTCanMutateCanLock |
-
3318 tfMPTCanMutateCanClawback | tfMPTCanMutateMetadata});
-
3319 mptAlice.authorize({.account = bob, .holderCount = 1});
-
3320
-
3321 // Lock issuance
-
3322 mptAlice.set({.account = alice, .flags = tfMPTLock});
-
3323
-
3324 // Can mutate the mutable flags and fields
-
3325 mptAlice.set({.account = alice, .mutableFlags = tfMPTClearCanLock});
-
3326 mptAlice.set({.account = alice, .mutableFlags = tfMPTSetCanLock});
-
3327 mptAlice.set({.account = alice, .mutableFlags = tfMPTClearCanLock});
-
3328 mptAlice.set(
-
3329 {.account = alice, .mutableFlags = tfMPTSetCanClawback});
-
3330 mptAlice.set(
-
3331 {.account = alice, .mutableFlags = tfMPTClearCanClawback});
-
3332 mptAlice.set({.account = alice, .metadata = "mutate"});
-
3333 }
-
3334
-
3335 // Test lock and unlock after mutating MPTCanLock
-
3336 {
-
3337 Env env{*this, features};
-
3338 MPTTester mptAlice(env, alice, {.holders = {bob}});
-
3339 mptAlice.create(
-
3340 {.ownerCount = 1,
-
3341 .holderCount = 0,
-
3342 .flags = tfMPTCanLock,
-
3343 .mutableFlags = tfMPTCanMutateCanLock |
-
3344 tfMPTCanMutateCanClawback | tfMPTCanMutateMetadata});
-
3345 mptAlice.authorize({.account = bob, .holderCount = 1});
-
3346
-
3347 // Can lock and unlock
-
3348 mptAlice.set({.account = alice, .flags = tfMPTLock});
-
3349 mptAlice.set({.account = alice, .holder = bob, .flags = tfMPTLock});
-
3350 mptAlice.set({.account = alice, .flags = tfMPTUnlock});
-
3351 mptAlice.set(
-
3352 {.account = alice, .holder = bob, .flags = tfMPTUnlock});
-
3353
-
3354 // Clear lsfMPTCanLock
-
3355 mptAlice.set({.account = alice, .mutableFlags = tfMPTClearCanLock});
-
3356
-
3357 // Can not lock or unlock
-
3358 mptAlice.set(
-
3359 {.account = alice,
-
3360 .flags = tfMPTLock,
-
3361 .err = tecNO_PERMISSION});
-
3362 mptAlice.set(
-
3363 {.account = alice,
-
3364 .flags = tfMPTUnlock,
-
3365 .err = tecNO_PERMISSION});
-
3366 mptAlice.set(
-
3367 {.account = alice,
-
3368 .holder = bob,
-
3369 .flags = tfMPTLock,
-
3370 .err = tecNO_PERMISSION});
-
3371 mptAlice.set(
-
3372 {.account = alice,
-
3373 .holder = bob,
-
3374 .flags = tfMPTUnlock,
-
3375 .err = tecNO_PERMISSION});
-
3376
-
3377 // Set MPTCanLock again
-
3378 mptAlice.set({.account = alice, .mutableFlags = tfMPTSetCanLock});
-
3379
-
3380 // Can lock and unlock again
-
3381 mptAlice.set({.account = alice, .flags = tfMPTLock});
-
3382 mptAlice.set({.account = alice, .holder = bob, .flags = tfMPTLock});
-
3383 mptAlice.set({.account = alice, .flags = tfMPTUnlock});
-
3384 mptAlice.set(
-
3385 {.account = alice, .holder = bob, .flags = tfMPTUnlock});
-
3386 }
-
3387 }
+
3276
+
3277 void
+
+
3278 testMutateCanLock(FeatureBitset features)
+
3279 {
+
3280 testcase("Mutate MPTCanLock");
+
3281 using namespace test::jtx;
+
3282
+
3283 Account const alice("alice");
+
3284 Account const bob("bob");
+
3285
+
3286 // Individual lock
+
3287 {
+
3288 Env env{*this, features};
+
3289 MPTTester mptAlice(env, alice, {.holders = {bob}});
+
3290 mptAlice.create(
+
3291 {.ownerCount = 1,
+
3292 .holderCount = 0,
+
3293 .flags = tfMPTCanLock | tfMPTCanTransfer,
+
3294 .mutableFlags = tmfMPTCanMutateCanLock |
+
3295 tmfMPTCanMutateCanTrade | tmfMPTCanMutateTransferFee});
+
3296 mptAlice.authorize({.account = bob, .holderCount = 1});
+
3297
+
3298 // Lock bob's mptoken
+
3299 mptAlice.set({.account = alice, .holder = bob, .flags = tfMPTLock});
+
3300
+
3301 // Can mutate the mutable flags and fields
+
3302 mptAlice.set(
+
3303 {.account = alice, .mutableFlags = tmfMPTClearCanLock});
+
3304 mptAlice.set({.account = alice, .mutableFlags = tmfMPTSetCanLock});
+
3305 mptAlice.set(
+
3306 {.account = alice, .mutableFlags = tmfMPTClearCanLock});
+
3307 mptAlice.set({.account = alice, .mutableFlags = tmfMPTSetCanTrade});
+
3308 mptAlice.set(
+
3309 {.account = alice, .mutableFlags = tmfMPTClearCanTrade});
+
3310 mptAlice.set({.account = alice, .transferFee = 200});
+
3311 }
+
3312
+
3313 // Global lock
+
3314 {
+
3315 Env env{*this, features};
+
3316 MPTTester mptAlice(env, alice, {.holders = {bob}});
+
3317 mptAlice.create(
+
3318 {.ownerCount = 1,
+
3319 .holderCount = 0,
+
3320 .flags = tfMPTCanLock,
+
3321 .mutableFlags = tmfMPTCanMutateCanLock |
+
3322 tmfMPTCanMutateCanClawback | tmfMPTCanMutateMetadata});
+
3323 mptAlice.authorize({.account = bob, .holderCount = 1});
+
3324
+
3325 // Lock issuance
+
3326 mptAlice.set({.account = alice, .flags = tfMPTLock});
+
3327
+
3328 // Can mutate the mutable flags and fields
+
3329 mptAlice.set(
+
3330 {.account = alice, .mutableFlags = tmfMPTClearCanLock});
+
3331 mptAlice.set({.account = alice, .mutableFlags = tmfMPTSetCanLock});
+
3332 mptAlice.set(
+
3333 {.account = alice, .mutableFlags = tmfMPTClearCanLock});
+
3334 mptAlice.set(
+
3335 {.account = alice, .mutableFlags = tmfMPTSetCanClawback});
+
3336 mptAlice.set(
+
3337 {.account = alice, .mutableFlags = tmfMPTClearCanClawback});
+
3338 mptAlice.set({.account = alice, .metadata = "mutate"});
+
3339 }
+
3340
+
3341 // Test lock and unlock after mutating MPTCanLock
+
3342 {
+
3343 Env env{*this, features};
+
3344 MPTTester mptAlice(env, alice, {.holders = {bob}});
+
3345 mptAlice.create(
+
3346 {.ownerCount = 1,
+
3347 .holderCount = 0,
+
3348 .flags = tfMPTCanLock,
+
3349 .mutableFlags = tmfMPTCanMutateCanLock |
+
3350 tmfMPTCanMutateCanClawback | tmfMPTCanMutateMetadata});
+
3351 mptAlice.authorize({.account = bob, .holderCount = 1});
+
3352
+
3353 // Can lock and unlock
+
3354 mptAlice.set({.account = alice, .flags = tfMPTLock});
+
3355 mptAlice.set({.account = alice, .holder = bob, .flags = tfMPTLock});
+
3356 mptAlice.set({.account = alice, .flags = tfMPTUnlock});
+
3357 mptAlice.set(
+
3358 {.account = alice, .holder = bob, .flags = tfMPTUnlock});
+
3359
+
3360 // Clear lsfMPTCanLock
+
3361 mptAlice.set(
+
3362 {.account = alice, .mutableFlags = tmfMPTClearCanLock});
+
3363
+
3364 // Can not lock or unlock
+
3365 mptAlice.set(
+
3366 {.account = alice,
+
3367 .flags = tfMPTLock,
+
3368 .err = tecNO_PERMISSION});
+
3369 mptAlice.set(
+
3370 {.account = alice,
+
3371 .flags = tfMPTUnlock,
+
3372 .err = tecNO_PERMISSION});
+
3373 mptAlice.set(
+
3374 {.account = alice,
+
3375 .holder = bob,
+
3376 .flags = tfMPTLock,
+
3377 .err = tecNO_PERMISSION});
+
3378 mptAlice.set(
+
3379 {.account = alice,
+
3380 .holder = bob,
+
3381 .flags = tfMPTUnlock,
+
3382 .err = tecNO_PERMISSION});
+
3383
+
3384 // Set MPTCanLock again
+
3385 mptAlice.set({.account = alice, .mutableFlags = tmfMPTSetCanLock});
+
3386
+
3387 // Can lock and unlock again
+
3388 mptAlice.set({.account = alice, .flags = tfMPTLock});
+
3389 mptAlice.set({.account = alice, .holder = bob, .flags = tfMPTLock});
+
3390 mptAlice.set({.account = alice, .flags = tfMPTUnlock});
+
3391 mptAlice.set(
+
3392 {.account = alice, .holder = bob, .flags = tfMPTUnlock});
+
3393 }
+
3394 }
-
3388
-
3389 void
-
-
3390 testMutateRequireAuth(FeatureBitset features)
-
3391 {
-
3392 testcase("Mutate MPTRequireAuth");
-
3393 using namespace test::jtx;
-
3394
-
3395 Env env{*this, features};
-
3396 Account const alice("alice");
-
3397 Account const bob("bob");
-
3398
-
3399 MPTTester mptAlice(env, alice, {.holders = {bob}});
-
3400 mptAlice.create(
-
3401 {.ownerCount = 1,
-
3402 .flags = tfMPTRequireAuth,
-
3403 .mutableFlags = tfMPTCanMutateRequireAuth});
-
3404
-
3405 mptAlice.authorize({.account = bob});
-
3406 mptAlice.authorize({.account = alice, .holder = bob});
-
3407
-
3408 // Pay to bob
-
3409 mptAlice.pay(alice, bob, 1000);
-
3410
-
3411 // Unauthorize bob
-
3412 mptAlice.authorize(
-
3413 {.account = alice, .holder = bob, .flags = tfMPTUnauthorize});
+
3395
+
3396 void
+
+
3397 testMutateRequireAuth(FeatureBitset features)
+
3398 {
+
3399 testcase("Mutate MPTRequireAuth");
+
3400 using namespace test::jtx;
+
3401
+
3402 Env env{*this, features};
+
3403 Account const alice("alice");
+
3404 Account const bob("bob");
+
3405
+
3406 MPTTester mptAlice(env, alice, {.holders = {bob}});
+
3407 mptAlice.create(
+
3408 {.ownerCount = 1,
+
3409 .flags = tfMPTRequireAuth,
+
3410 .mutableFlags = tmfMPTCanMutateRequireAuth});
+
3411
+
3412 mptAlice.authorize({.account = bob});
+
3413 mptAlice.authorize({.account = alice, .holder = bob});
3414
-
3415 // Can not pay to bob
-
3416 mptAlice.pay(bob, alice, 100, tecNO_AUTH);
+
3415 // Pay to bob
+
3416 mptAlice.pay(alice, bob, 1000);
3417
-
3418 // Clear RequireAuth
-
3419 mptAlice.set({.account = alice, .mutableFlags = tfMPTClearRequireAuth});
-
3420
-
3421 // Can pay to bob
-
3422 mptAlice.pay(alice, bob, 1000);
-
3423
-
3424 // Set RequireAuth again
-
3425 mptAlice.set({.account = alice, .mutableFlags = tfMPTSetRequireAuth});
-
3426
-
3427 // Can not pay to bob since he is not authorized
-
3428 mptAlice.pay(bob, alice, 100, tecNO_AUTH);
-
3429
-
3430 // Authorize bob again
-
3431 mptAlice.authorize({.account = alice, .holder = bob});
-
3432
-
3433 // Can pay to bob again
-
3434 mptAlice.pay(alice, bob, 100);
-
3435 }
+
3418 // Unauthorize bob
+
3419 mptAlice.authorize(
+
3420 {.account = alice, .holder = bob, .flags = tfMPTUnauthorize});
+
3421
+
3422 // Can not pay to bob
+
3423 mptAlice.pay(bob, alice, 100, tecNO_AUTH);
+
3424
+
3425 // Clear RequireAuth
+
3426 mptAlice.set(
+
3427 {.account = alice, .mutableFlags = tmfMPTClearRequireAuth});
+
3428
+
3429 // Can pay to bob
+
3430 mptAlice.pay(alice, bob, 1000);
+
3431
+
3432 // Set RequireAuth again
+
3433 mptAlice.set({.account = alice, .mutableFlags = tmfMPTSetRequireAuth});
+
3434
+
3435 // Can not pay to bob since he is not authorized
+
3436 mptAlice.pay(bob, alice, 100, tecNO_AUTH);
+
3437
+
3438 // Authorize bob again
+
3439 mptAlice.authorize({.account = alice, .holder = bob});
+
3440
+
3441 // Can pay to bob again
+
3442 mptAlice.pay(alice, bob, 100);
+
3443 }
-
3436
-
3437 void
-
-
3438 testMutateCanEscrow(FeatureBitset features)
-
3439 {
-
3440 testcase("Mutate MPTCanEscrow");
-
3441 using namespace test::jtx;
-
3442 using namespace std::literals;
-
3443
-
3444 Env env{*this, features};
-
3445 auto const baseFee = env.current()->fees().base;
-
3446 auto const alice = Account("alice");
-
3447 auto const bob = Account("bob");
-
3448 auto const carol = Account("carol");
-
3449
-
3450 MPTTester mptAlice(env, alice, {.holders = {carol, bob}});
-
3451 mptAlice.create(
-
3452 {.ownerCount = 1,
-
3453 .holderCount = 0,
-
3454 .flags = tfMPTCanTransfer,
-
3455 .mutableFlags = tfMPTCanMutateCanEscrow});
-
3456 mptAlice.authorize({.account = carol});
-
3457 mptAlice.authorize({.account = bob});
-
3458
-
3459 auto const MPT = mptAlice["MPT"];
-
3460 env(pay(alice, carol, MPT(10'000)));
-
3461 env(pay(alice, bob, MPT(10'000)));
-
3462 env.close();
-
3463
-
3464 // MPTCanEscrow is not enabled
-
3465 env(escrow::create(carol, bob, MPT(3)),
-
3466 escrow::condition(escrow::cb1),
-
3467 escrow::finish_time(env.now() + 1s),
-
3468 fee(baseFee * 150),
-
3469 ter(tecNO_PERMISSION));
-
3470
-
3471 // MPTCanEscrow is enabled now
-
3472 mptAlice.set({.account = alice, .mutableFlags = tfMPTSetCanEscrow});
+
3444
+
3445 void
+
+
3446 testMutateCanEscrow(FeatureBitset features)
+
3447 {
+
3448 testcase("Mutate MPTCanEscrow");
+
3449 using namespace test::jtx;
+
3450 using namespace std::literals;
+
3451
+
3452 Env env{*this, features};
+
3453 auto const baseFee = env.current()->fees().base;
+
3454 auto const alice = Account("alice");
+
3455 auto const bob = Account("bob");
+
3456 auto const carol = Account("carol");
+
3457
+
3458 MPTTester mptAlice(env, alice, {.holders = {carol, bob}});
+
3459 mptAlice.create(
+
3460 {.ownerCount = 1,
+
3461 .holderCount = 0,
+
3462 .flags = tfMPTCanTransfer,
+
3463 .mutableFlags = tmfMPTCanMutateCanEscrow});
+
3464 mptAlice.authorize({.account = carol});
+
3465 mptAlice.authorize({.account = bob});
+
3466
+
3467 auto const MPT = mptAlice["MPT"];
+
3468 env(pay(alice, carol, MPT(10'000)));
+
3469 env(pay(alice, bob, MPT(10'000)));
+
3470 env.close();
+
3471
+
3472 // MPTCanEscrow is not enabled
3473 env(escrow::create(carol, bob, MPT(3)),
3474 escrow::condition(escrow::cb1),
3475 escrow::finish_time(env.now() + 1s),
-
3476 fee(baseFee * 150));
-
3477
-
3478 // Clear MPTCanEscrow
-
3479 mptAlice.set({.account = alice, .mutableFlags = tfMPTClearCanEscrow});
-
3480 env(escrow::create(carol, bob, MPT(3)),
-
3481 escrow::condition(escrow::cb1),
-
3482 escrow::finish_time(env.now() + 1s),
-
3483 fee(baseFee * 150),
-
3484 ter(tecNO_PERMISSION));
-
3485 }
+
3476 fee(baseFee * 150),
+
3477 ter(tecNO_PERMISSION));
+
3478
+
3479 // MPTCanEscrow is enabled now
+
3480 mptAlice.set({.account = alice, .mutableFlags = tmfMPTSetCanEscrow});
+
3481 env(escrow::create(carol, bob, MPT(3)),
+
3482 escrow::condition(escrow::cb1),
+
3483 escrow::finish_time(env.now() + 1s),
+
3484 fee(baseFee * 150));
+
3485
+
3486 // Clear MPTCanEscrow
+
3487 mptAlice.set({.account = alice, .mutableFlags = tmfMPTClearCanEscrow});
+
3488 env(escrow::create(carol, bob, MPT(3)),
+
3489 escrow::condition(escrow::cb1),
+
3490 escrow::finish_time(env.now() + 1s),
+
3491 fee(baseFee * 150),
+
3492 ter(tecNO_PERMISSION));
+
3493 }
-
3486
-
3487 void
-
-
3488 testMutateCanTransfer(FeatureBitset features)
-
3489 {
-
3490 testcase("Mutate MPTCanTransfer");
-
3491
-
3492 using namespace test::jtx;
-
3493 Account const alice("alice");
-
3494 Account const bob("bob");
-
3495 Account const carol("carol");
-
3496
-
3497 {
-
3498 Env env{*this, features};
+
3494
+
3495 void
+
+
3496 testMutateCanTransfer(FeatureBitset features)
+
3497 {
+
3498 testcase("Mutate MPTCanTransfer");
3499
-
3500 MPTTester mptAlice(env, alice, {.holders = {bob, carol}});
-
3501 mptAlice.create(
-
3502 {.ownerCount = 1,
-
3503 .mutableFlags =
-
3504 tfMPTCanMutateCanTransfer | tfMPTCanMutateTransferFee});
-
3505
-
3506 mptAlice.authorize({.account = bob});
-
3507 mptAlice.authorize({.account = carol});
-
3508
-
3509 // Pay to bob
-
3510 mptAlice.pay(alice, bob, 1000);
-
3511
-
3512 // Bob can not pay carol since MPTCanTransfer is not set
-
3513 mptAlice.pay(bob, carol, 50, tecNO_AUTH);
-
3514
-
3515 // Can not set non-zero transfer fee when MPTCanTransfer is not set
-
3516 mptAlice.set(
-
3517 {.account = alice,
-
3518 .transferFee = 100,
-
3519 .err = tecNO_PERMISSION});
-
3520
-
3521 // Can not set non-zero transfer fee even when trying to set
-
3522 // MPTCanTransfer at the same time
-
3523 mptAlice.set(
-
3524 {.account = alice,
-
3525 .mutableFlags = tfMPTSetCanTransfer,
+
3500 using namespace test::jtx;
+
3501 Account const alice("alice");
+
3502 Account const bob("bob");
+
3503 Account const carol("carol");
+
3504
+
3505 {
+
3506 Env env{*this, features};
+
3507
+
3508 MPTTester mptAlice(env, alice, {.holders = {bob, carol}});
+
3509 mptAlice.create(
+
3510 {.ownerCount = 1,
+
3511 .mutableFlags =
+
3512 tmfMPTCanMutateCanTransfer | tmfMPTCanMutateTransferFee});
+
3513
+
3514 mptAlice.authorize({.account = bob});
+
3515 mptAlice.authorize({.account = carol});
+
3516
+
3517 // Pay to bob
+
3518 mptAlice.pay(alice, bob, 1000);
+
3519
+
3520 // Bob can not pay carol since MPTCanTransfer is not set
+
3521 mptAlice.pay(bob, carol, 50, tecNO_AUTH);
+
3522
+
3523 // Can not set non-zero transfer fee when MPTCanTransfer is not set
+
3524 mptAlice.set(
+
3525 {.account = alice,
3526 .transferFee = 100,
3527 .err = tecNO_PERMISSION});
3528
-
3529 // Alice sets MPTCanTransfer
-
3530 mptAlice.set(
-
3531 {.account = alice, .mutableFlags = tfMPTSetCanTransfer});
-
3532
-
3533 // Can set transfer fee now
-
3534 BEAST_EXPECT(!mptAlice.isTransferFeePresent());
-
3535 mptAlice.set({.account = alice, .transferFee = 100});
-
3536 BEAST_EXPECT(mptAlice.isTransferFeePresent());
-
3537
-
3538 // Bob can pay carol
-
3539 mptAlice.pay(bob, carol, 50);
+
3529 // Can not set non-zero transfer fee even when trying to set
+
3530 // MPTCanTransfer at the same time
+
3531 mptAlice.set(
+
3532 {.account = alice,
+
3533 .mutableFlags = tmfMPTSetCanTransfer,
+
3534 .transferFee = 100,
+
3535 .err = tecNO_PERMISSION});
+
3536
+
3537 // Alice sets MPTCanTransfer
+
3538 mptAlice.set(
+
3539 {.account = alice, .mutableFlags = tmfMPTSetCanTransfer});
3540
-
3541 // Alice clears MPTCanTransfer
-
3542 mptAlice.set(
-
3543 {.account = alice, .mutableFlags = tfMPTClearCanTransfer});
-
3544
-
3545 // TransferFee field is removed when MPTCanTransfer is cleared
-
3546 BEAST_EXPECT(!mptAlice.isTransferFeePresent());
-
3547
-
3548 // Bob can not pay
-
3549 mptAlice.pay(bob, carol, 50, tecNO_AUTH);
-
3550 }
-
3551
-
3552 // Can set transfer fee to zero when MPTCanTransfer is not set, but
-
3553 // tfMPTCanMutateTransferFee is set.
-
3554 {
-
3555 Env env{*this, features};
-
3556
-
3557 MPTTester mptAlice(env, alice, {.holders = {bob, carol}});
-
3558 mptAlice.create(
-
3559 {.transferFee = 100,
-
3560 .ownerCount = 1,
-
3561 .flags = tfMPTCanTransfer,
-
3562 .mutableFlags =
-
3563 tfMPTCanMutateTransferFee | tfMPTCanMutateCanTransfer});
+
3541 // Can set transfer fee now
+
3542 BEAST_EXPECT(!mptAlice.isTransferFeePresent());
+
3543 mptAlice.set({.account = alice, .transferFee = 100});
+
3544 BEAST_EXPECT(mptAlice.isTransferFeePresent());
+
3545
+
3546 // Bob can pay carol
+
3547 mptAlice.pay(bob, carol, 50);
+
3548
+
3549 // Alice clears MPTCanTransfer
+
3550 mptAlice.set(
+
3551 {.account = alice, .mutableFlags = tmfMPTClearCanTransfer});
+
3552
+
3553 // TransferFee field is removed when MPTCanTransfer is cleared
+
3554 BEAST_EXPECT(!mptAlice.isTransferFeePresent());
+
3555
+
3556 // Bob can not pay
+
3557 mptAlice.pay(bob, carol, 50, tecNO_AUTH);
+
3558 }
+
3559
+
3560 // Can set transfer fee to zero when MPTCanTransfer is not set, but
+
3561 // tmfMPTCanMutateTransferFee is set.
+
3562 {
+
3563 Env env{*this, features};
3564
-
3565 BEAST_EXPECT(mptAlice.checkTransferFee(100));
-
3566
-
3567 // Clear MPTCanTransfer and transfer fee is removed
-
3568 mptAlice.set(
-
3569 {.account = alice, .mutableFlags = tfMPTClearCanTransfer});
-
3570 BEAST_EXPECT(!mptAlice.isTransferFeePresent());
-
3571
-
3572 // Can still set transfer fee to zero, although it is already zero
-
3573 mptAlice.set({.account = alice, .transferFee = 0});
+
3565 MPTTester mptAlice(env, alice, {.holders = {bob, carol}});
+
3566 mptAlice.create(
+
3567 {.transferFee = 100,
+
3568 .ownerCount = 1,
+
3569 .flags = tfMPTCanTransfer,
+
3570 .mutableFlags =
+
3571 tmfMPTCanMutateTransferFee | tmfMPTCanMutateCanTransfer});
+
3572
+
3573 BEAST_EXPECT(mptAlice.checkTransferFee(100));
3574
-
3575 // TransferFee field is still not present
-
3576 BEAST_EXPECT(!mptAlice.isTransferFeePresent());
-
3577 }
-
3578 }
-
+
3575 // Clear MPTCanTransfer and transfer fee is removed
+
3576 mptAlice.set(
+
3577 {.account = alice, .mutableFlags = tmfMPTClearCanTransfer});
+
3578 BEAST_EXPECT(!mptAlice.isTransferFeePresent());
3579
-
3580 void
-
-
3581 testMutateCanClawback(FeatureBitset features)
-
3582 {
-
3583 testcase("Mutate MPTCanClawback");
-
3584
-
3585 using namespace test::jtx;
-
3586 Env env(*this, features);
-
3587 Account const alice{"alice"};
-
3588 Account const bob{"bob"};
-
3589
-
3590 MPTTester mptAlice(env, alice, {.holders = {bob}});
-
3591
-
3592 mptAlice.create(
-
3593 {.ownerCount = 1,
-
3594 .holderCount = 0,
-
3595 .mutableFlags = tfMPTCanMutateCanClawback});
-
3596
-
3597 // Bob creates an MPToken
-
3598 mptAlice.authorize({.account = bob});
+
3580 // Can still set transfer fee to zero, although it is already zero
+
3581 mptAlice.set({.account = alice, .transferFee = 0});
+
3582
+
3583 // TransferFee field is still not present
+
3584 BEAST_EXPECT(!mptAlice.isTransferFeePresent());
+
3585 }
+
3586 }
+
+
3587
+
3588 void
+
+
3589 testMutateCanClawback(FeatureBitset features)
+
3590 {
+
3591 testcase("Mutate MPTCanClawback");
+
3592
+
3593 using namespace test::jtx;
+
3594 Env env(*this, features);
+
3595 Account const alice{"alice"};
+
3596 Account const bob{"bob"};
+
3597
+
3598 MPTTester mptAlice(env, alice, {.holders = {bob}});
3599
-
3600 // Alice pays bob 100 tokens
-
3601 mptAlice.pay(alice, bob, 100);
-
3602
-
3603 // MPTCanClawback is not enabled
-
3604 mptAlice.claw(alice, bob, 1, tecNO_PERMISSION);
-
3605
-
3606 // Enable MPTCanClawback
-
3607 mptAlice.set({.account = alice, .mutableFlags = tfMPTSetCanClawback});
-
3608
-
3609 // Can clawback now
-
3610 mptAlice.claw(alice, bob, 1);
-
3611
-
3612 // Clear MPTCanClawback
-
3613 mptAlice.set({.account = alice, .mutableFlags = tfMPTClearCanClawback});
-
3614
-
3615 // Can not clawback
-
3616 mptAlice.claw(alice, bob, 1, tecNO_PERMISSION);
-
3617 }
+
3600 mptAlice.create(
+
3601 {.ownerCount = 1,
+
3602 .holderCount = 0,
+
3603 .mutableFlags = tmfMPTCanMutateCanClawback});
+
3604
+
3605 // Bob creates an MPToken
+
3606 mptAlice.authorize({.account = bob});
+
3607
+
3608 // Alice pays bob 100 tokens
+
3609 mptAlice.pay(alice, bob, 100);
+
3610
+
3611 // MPTCanClawback is not enabled
+
3612 mptAlice.claw(alice, bob, 1, tecNO_PERMISSION);
+
3613
+
3614 // Enable MPTCanClawback
+
3615 mptAlice.set({.account = alice, .mutableFlags = tmfMPTSetCanClawback});
+
3616
+
3617 // Can clawback now
+
3618 mptAlice.claw(alice, bob, 1);
+
3619
+
3620 // Clear MPTCanClawback
+
3621 mptAlice.set(
+
3622 {.account = alice, .mutableFlags = tmfMPTClearCanClawback});
+
3623
+
3624 // Can not clawback
+
3625 mptAlice.claw(alice, bob, 1, tecNO_PERMISSION);
+
3626 }
-
3618
-
3619public:
-
3620 void
-
-
3621 run() override
-
3622 {
-
3623 using namespace test::jtx;
-
3624 FeatureBitset const all{testable_amendments()};
-
3625
-
3626 // MPTokenIssuanceCreate
-
3627 testCreateValidation(all - featureSingleAssetVault);
-
3628 testCreateValidation(all - featurePermissionedDomains);
-
3629 testCreateValidation(all);
-
3630 testCreateEnabled(all - featureSingleAssetVault);
-
3631 testCreateEnabled(all);
-
3632
-
3633 // MPTokenIssuanceDestroy
-
3634 testDestroyValidation(all - featureSingleAssetVault);
-
3635 testDestroyValidation(all);
-
3636 testDestroyEnabled(all - featureSingleAssetVault);
-
3637 testDestroyEnabled(all);
-
3638
-
3639 // MPTokenAuthorize
-
3640 testAuthorizeValidation(all - featureSingleAssetVault);
-
3641 testAuthorizeValidation(all);
-
3642 testAuthorizeEnabled(all - featureSingleAssetVault);
-
3643 testAuthorizeEnabled(all);
-
3644
-
3645 // MPTokenIssuanceSet
-
3646 testSetValidation(all - featureSingleAssetVault - featureDynamicMPT);
-
3647 testSetValidation(all - featureSingleAssetVault);
-
3648 testSetValidation(all - featureDynamicMPT);
-
3649 testSetValidation(all - featurePermissionedDomains);
-
3650 testSetValidation(all);
-
3651
-
3652 testSetEnabled(all - featureSingleAssetVault);
-
3653 testSetEnabled(all);
-
3654
-
3655 // MPT clawback
-
3656 testClawbackValidation(all);
-
3657 testClawback(all);
-
3658
-
3659 // Test Direct Payment
-
3660 testPayment(all);
-
3661 testDepositPreauth(all);
-
3662 testDepositPreauth(all - featureCredentials);
+
3627
+
3628public:
+
3629 void
+
+
3630 run() override
+
3631 {
+
3632 using namespace test::jtx;
+
3633 FeatureBitset const all{testable_amendments()};
+
3634
+
3635 // MPTokenIssuanceCreate
+
3636 testCreateValidation(all - featureSingleAssetVault);
+
3637 testCreateValidation(all - featurePermissionedDomains);
+
3638 testCreateValidation(all);
+
3639 testCreateEnabled(all - featureSingleAssetVault);
+
3640 testCreateEnabled(all);
+
3641
+
3642 // MPTokenIssuanceDestroy
+
3643 testDestroyValidation(all - featureSingleAssetVault);
+
3644 testDestroyValidation(all);
+
3645 testDestroyEnabled(all - featureSingleAssetVault);
+
3646 testDestroyEnabled(all);
+
3647
+
3648 // MPTokenAuthorize
+
3649 testAuthorizeValidation(all - featureSingleAssetVault);
+
3650 testAuthorizeValidation(all);
+
3651 testAuthorizeEnabled(all - featureSingleAssetVault);
+
3652 testAuthorizeEnabled(all);
+
3653
+
3654 // MPTokenIssuanceSet
+
3655 testSetValidation(all - featureSingleAssetVault - featureDynamicMPT);
+
3656 testSetValidation(all - featureSingleAssetVault);
+
3657 testSetValidation(all - featureDynamicMPT);
+
3658 testSetValidation(all - featurePermissionedDomains);
+
3659 testSetValidation(all);
+
3660
+
3661 testSetEnabled(all - featureSingleAssetVault);
+
3662 testSetEnabled(all);
3663
-
3664 // Test MPT Amount is invalid in Tx, which don't support MPT
-
3665 testMPTInvalidInTx(all);
-
3666
-
3667 // Test parsed MPTokenIssuanceID in API response metadata
-
3668 testTxJsonMetaFields(all);
-
3669
-
3670 // Test tokens equality
-
3671 testTokensEquality();
+
3664 // MPT clawback
+
3665 testClawbackValidation(all);
+
3666 testClawback(all);
+
3667
+
3668 // Test Direct Payment
+
3669 testPayment(all);
+
3670 testDepositPreauth(all);
+
3671 testDepositPreauth(all - featureCredentials);
3672
-
3673 // Test helpers
-
3674 testHelperFunctions();
+
3673 // Test MPT Amount is invalid in Tx, which don't support MPT
+
3674 testMPTInvalidInTx(all);
3675
-
3676 // Dynamic MPT
-
3677 testInvalidCreateDynamic(all);
-
3678 testInvalidSetDynamic(all);
-
3679 testMutateMPT(all);
-
3680 testMutateCanLock(all);
-
3681 testMutateRequireAuth(all);
-
3682 testMutateCanEscrow(all);
-
3683 testMutateCanTransfer(all);
-
3684 testMutateCanClawback(all);
-
3685 }
+
3676 // Test parsed MPTokenIssuanceID in API response metadata
+
3677 testTxJsonMetaFields(all);
+
3678
+
3679 // Test tokens equality
+
3680 testTokensEquality();
+
3681
+
3682 // Test helpers
+
3683 testHelperFunctions();
+
3684
+
3685 // Dynamic MPT
+
3686 testInvalidCreateDynamic(all);
+
3687 testInvalidSetDynamic(all);
+
3688 testMutateMPT(all);
+
3689 testMutateCanLock(all);
+
3690 testMutateRequireAuth(all);
+
3691 testMutateCanEscrow(all);
+
3692 testMutateCanTransfer(all);
+
3693 testMutateCanClawback(all);
+
3694 }
-
3686};
+
3695};
-
3687
-
3688BEAST_DEFINE_TESTSUITE_PRIO(MPToken, app, ripple, 2);
-
3689
-
3690} // namespace test
-
3691} // namespace ripple
+
3696
+
3697BEAST_DEFINE_TESTSUITE_PRIO(MPToken, app, ripple, 2);
+
3698
+
3699} // namespace test
+
3700} // namespace ripple
Json::StaticString
Lightweight wrapper to tag static string.
Definition json_value.h:63
Json::Value
Represents a JSON value.
Definition json_value.h:149
@@ -3847,13 +3856,13 @@ $(document).ready(function() { init_codefold(0); });
ripple::base_uint< 192 >
ripple::test::MPToken_test
Definition MPToken_test.cpp:37
-
ripple::test::MPToken_test::run
void run() override
Runs the suite.
Definition MPToken_test.cpp:3621
+
ripple::test::MPToken_test::run
void run() override
Runs the suite.
Definition MPToken_test.cpp:3630
ripple::test::MPToken_test::testCreateValidation
void testCreateValidation(FeatureBitset features)
Definition MPToken_test.cpp:39
-
ripple::test::MPToken_test::testMutateCanLock
void testMutateCanLock(FeatureBitset features)
Definition MPToken_test.cpp:3276
-
ripple::test::MPToken_test::testMutateCanClawback
void testMutateCanClawback(FeatureBitset features)
Definition MPToken_test.cpp:3581
+
ripple::test::MPToken_test::testMutateCanLock
void testMutateCanLock(FeatureBitset features)
Definition MPToken_test.cpp:3278
+
ripple::test::MPToken_test::testMutateCanClawback
void testMutateCanClawback(FeatureBitset features)
Definition MPToken_test.cpp:3589
ripple::test::MPToken_test::testInvalidSetDynamic
void testInvalidSetDynamic(FeatureBitset features)
Definition MPToken_test.cpp:2783
ripple::test::MPToken_test::testMutateMPT
void testMutateMPT(FeatureBitset features)
Definition MPToken_test.cpp:3165
-
ripple::test::MPToken_test::testMutateRequireAuth
void testMutateRequireAuth(FeatureBitset features)
Definition MPToken_test.cpp:3390
+
ripple::test::MPToken_test::testMutateRequireAuth
void testMutateRequireAuth(FeatureBitset features)
Definition MPToken_test.cpp:3397
ripple::test::MPToken_test::testClawback
void testClawback(FeatureBitset features)
Definition MPToken_test.cpp:2506
ripple::test::MPToken_test::testTokensEquality
void testTokensEquality()
Definition MPToken_test.cpp:2618
ripple::test::MPToken_test::testAuthorizeValidation
void testAuthorizeValidation(FeatureBitset features)
Definition MPToken_test.cpp:304
@@ -3861,11 +3870,11 @@ $(document).ready(function() { init_codefold(0); });
ripple::test::MPToken_test::testClawbackValidation
void testClawbackValidation(FeatureBitset features)
Definition MPToken_test.cpp:2356
ripple::test::MPToken_test::testCreateEnabled
void testCreateEnabled(FeatureBitset features)
Definition MPToken_test.cpp:162
ripple::test::MPToken_test::testDestroyEnabled
void testDestroyEnabled(FeatureBitset features)
Definition MPToken_test.cpp:286
-
ripple::test::MPToken_test::testMutateCanEscrow
void testMutateCanEscrow(FeatureBitset features)
Definition MPToken_test.cpp:3438
+
ripple::test::MPToken_test::testMutateCanEscrow
void testMutateCanEscrow(FeatureBitset features)
Definition MPToken_test.cpp:3446
ripple::test::MPToken_test::testPayment
void testPayment(FeatureBitset features)
Definition MPToken_test.cpp:918
ripple::test::MPToken_test::testHelperFunctions
void testHelperFunctions()
Definition MPToken_test.cpp:2661
ripple::test::MPToken_test::testMPTInvalidInTx
void testMPTInvalidInTx(FeatureBitset features)
Definition MPToken_test.cpp:1946
-
ripple::test::MPToken_test::testMutateCanTransfer
void testMutateCanTransfer(FeatureBitset features)
Definition MPToken_test.cpp:3488
+
ripple::test::MPToken_test::testMutateCanTransfer
void testMutateCanTransfer(FeatureBitset features)
Definition MPToken_test.cpp:3496
ripple::test::MPToken_test::testAuthorizeEnabled
void testAuthorizeEnabled(FeatureBitset features)
Definition MPToken_test.cpp:486
ripple::test::MPToken_test::testDepositPreauth
void testDepositPreauth(FeatureBitset features)
Definition MPToken_test.cpp:1794
ripple::test::MPToken_test::testDestroyValidation
void testDestroyValidation(FeatureBitset features)
Definition MPToken_test.cpp:236
@@ -3937,38 +3946,39 @@ $(document).ready(function() { init_codefold(0); });
ripple::xrpIssue
Issue const & xrpIssue()
Returns an asset specifier that represents XRP.
Definition Issue.h:115
ripple::tfSingleAsset
constexpr std::uint32_t tfSingleAsset
Definition TxFlags.h:244
ripple::equalTokens
constexpr bool equalTokens(Asset const &lhs, Asset const &rhs)
Definition Asset.h:201
+
ripple::tmfMPTClearCanClawback
constexpr std::uint32_t const tmfMPTClearCanClawback
Definition TxFlags.h:191
+
ripple::tmfMPTCanMutateMetadata
constexpr std::uint32_t const tmfMPTCanMutateMetadata
Definition TxFlags.h:162
+
ripple::tmfMPTClearCanEscrow
constexpr std::uint32_t const tmfMPTClearCanEscrow
Definition TxFlags.h:185
+
ripple::tmfMPTCanMutateCanEscrow
constexpr std::uint32_t const tmfMPTCanMutateCanEscrow
Definition TxFlags.h:158
ripple::asfDepositAuth
constexpr std::uint32_t asfDepositAuth
Definition TxFlags.h:85
-
ripple::tfMPTClearCanLock
constexpr std::uint32_t const tfMPTClearCanLock
Definition TxFlags.h:181
+
ripple::tmfMPTCanMutateCanTrade
constexpr std::uint32_t const tmfMPTCanMutateCanTrade
Definition TxFlags.h:159
ripple::tfMPTCanTransfer
constexpr std::uint32_t const tfMPTCanTransfer
Definition TxFlags.h:149
-
ripple::tfMPTClearCanEscrow
constexpr std::uint32_t const tfMPTClearCanEscrow
Definition TxFlags.h:185
-
ripple::tfMPTSetRequireAuth
constexpr std::uint32_t const tfMPTSetRequireAuth
Definition TxFlags.h:182
+
ripple::tmfMPTSetCanClawback
constexpr std::uint32_t const tmfMPTSetCanClawback
Definition TxFlags.h:190
+
ripple::tmfMPTSetRequireAuth
constexpr std::uint32_t const tmfMPTSetRequireAuth
Definition TxFlags.h:182
+
ripple::tmfMPTClearCanTrade
constexpr std::uint32_t const tmfMPTClearCanTrade
Definition TxFlags.h:187
ripple::uint256
base_uint< 256 > uint256
Definition base_uint.h:558
-
ripple::tfMPTCanMutateMetadata
constexpr std::uint32_t const tfMPTCanMutateMetadata
Definition TxFlags.h:162
-
ripple::tfMPTClearCanTransfer
constexpr std::uint32_t const tfMPTClearCanTransfer
Definition TxFlags.h:189
ripple::assetFromJson
Asset assetFromJson(Json::Value const &jv)
Definition Asset.cpp:77
+
ripple::tmfMPTCanMutateTransferFee
constexpr std::uint32_t const tmfMPTCanMutateTransferFee
Definition TxFlags.h:163
ripple::tfMPTCanTrade
constexpr std::uint32_t const tfMPTCanTrade
Definition TxFlags.h:148
ripple::tfMPTUnlock
constexpr std::uint32_t const tfMPTUnlock
Definition TxFlags.h:174
ripple::maxMPTokenAmount
std::uint64_t constexpr maxMPTokenAmount
The maximum amount of MPTokenIssuance.
Definition Protocol.h:117
-
ripple::tfMPTClearCanTrade
constexpr std::uint32_t const tfMPTClearCanTrade
Definition TxFlags.h:187
-
ripple::tfMPTCanMutateCanEscrow
constexpr std::uint32_t const tfMPTCanMutateCanEscrow
Definition TxFlags.h:158
+
ripple::tmfMPTClearRequireAuth
constexpr std::uint32_t const tmfMPTClearRequireAuth
Definition TxFlags.h:183
ripple::maxTransferFee
std::uint16_t constexpr maxTransferFee
The maximum token transfer fee allowed.
Definition Protocol.h:83
+
ripple::tmfMPTSetCanLock
constexpr std::uint32_t const tmfMPTSetCanLock
Definition TxFlags.h:180
+
ripple::tmfMPTCanMutateCanLock
constexpr std::uint32_t const tmfMPTCanMutateCanLock
Definition TxFlags.h:156
ripple::multiply
STAmount multiply(STAmount const &amount, Rate const &rate)
Definition Rate2.cpp:53
-
ripple::tfMPTCanMutateCanLock
constexpr std::uint32_t const tfMPTCanMutateCanLock
Definition TxFlags.h:156
-
ripple::tfMPTSetCanTransfer
constexpr std::uint32_t const tfMPTSetCanTransfer
Definition TxFlags.h:188
-
ripple::tfMPTSetCanEscrow
constexpr std::uint32_t const tfMPTSetCanEscrow
Definition TxFlags.h:184
+
ripple::tmfMPTSetCanTrade
constexpr std::uint32_t const tmfMPTSetCanTrade
Definition TxFlags.h:186
ripple::mptIssueFromJson
MPTIssue mptIssueFromJson(Json::Value const &jv)
Definition MPTIssue.cpp:78
-
ripple::tfMPTCanMutateCanTransfer
constexpr std::uint32_t const tfMPTCanMutateCanTransfer
Definition TxFlags.h:160
-
ripple::tfMPTCanMutateTransferFee
constexpr std::uint32_t const tfMPTCanMutateTransferFee
Definition TxFlags.h:163
-
ripple::tfMPTCanMutateCanTrade
constexpr std::uint32_t const tfMPTCanMutateCanTrade
Definition TxFlags.h:159
+
ripple::tmfMPTCanMutateCanClawback
constexpr std::uint32_t const tmfMPTCanMutateCanClawback
Definition TxFlags.h:161
ripple::maxMPTokenMetadataLength
std::size_t constexpr maxMPTokenMetadataLength
The maximum length of MPTokenMetadata.
Definition Protocol.h:114
ripple::to_json
Json::Value to_json(Asset const &asset)
Definition Asset.h:123
ripple::tfPartialPayment
constexpr std::uint32_t tfPartialPayment
Definition TxFlags.h:108
-
ripple::tfMPTSetCanTrade
constexpr std::uint32_t const tfMPTSetCanTrade
Definition TxFlags.h:186
ripple::strHex
std::string strHex(FwdIt begin, FwdIt end)
Definition strHex.h:30
ripple::tfMPTUnauthorize
constexpr std::uint32_t const tfMPTUnauthorize
Definition TxFlags.h:169
-
ripple::tfMPTSetCanClawback
constexpr std::uint32_t const tfMPTSetCanClawback
Definition TxFlags.h:190
-
ripple::tfMPTClearCanClawback
constexpr std::uint32_t const tfMPTClearCanClawback
Definition TxFlags.h:191
+
ripple::tmfMPTSetCanEscrow
constexpr std::uint32_t const tmfMPTSetCanEscrow
Definition TxFlags.h:184
+
ripple::tmfMPTClearCanLock
constexpr std::uint32_t const tmfMPTClearCanLock
Definition TxFlags.h:181
+
ripple::tmfMPTSetCanTransfer
constexpr std::uint32_t const tmfMPTSetCanTransfer
Definition TxFlags.h:188
ripple::tecNO_DST
@ tecNO_DST
Definition TER.h:290
ripple::tecOBJECT_NOT_FOUND
@ tecOBJECT_NOT_FOUND
Definition TER.h:326
ripple::tecDUPLICATE
@ tecDUPLICATE
Definition TER.h:315
@@ -3982,8 +3992,9 @@ $(document).ready(function() { init_codefold(0); });
ripple::tfMPTLock
constexpr std::uint32_t const tfMPTLock
Definition TxFlags.h:173
ripple::tfNoRippleDirect
constexpr std::uint32_t tfNoRippleDirect
Definition TxFlags.h:107
ripple::tesSUCCESS
@ tesSUCCESS
Definition TER.h:244
+
ripple::tmfMPTCanMutateRequireAuth
constexpr std::uint32_t const tmfMPTCanMutateRequireAuth
Definition TxFlags.h:157
+
ripple::tmfMPTCanMutateCanTransfer
constexpr std::uint32_t const tmfMPTCanMutateCanTransfer
Definition TxFlags.h:160
ripple::tfLimitQuality
constexpr std::uint32_t tfLimitQuality
Definition TxFlags.h:109
-
ripple::tfMPTCanMutateCanClawback
constexpr std::uint32_t const tfMPTCanMutateCanClawback
Definition TxFlags.h:161
ripple::soeMPTNotSupported
@ soeMPTNotSupported
Definition SOTemplate.h:43
ripple::to_string
std::string to_string(base_uint< Bits, Tag > const &a)
Definition base_uint.h:630
ripple::tfFullyCanonicalSig
constexpr std::uint32_t tfFullyCanonicalSig
Transaction flags.
Definition TxFlags.h:60
@@ -3993,11 +4004,9 @@ $(document).ready(function() { init_codefold(0); });
ripple::mulRoundStrict
STAmount mulRoundStrict(STAmount const &v1, STAmount const &v2, Asset const &asset, bool roundUp)
Definition STAmount.cpp:1655
ripple::tfMPTCanEscrow
constexpr std::uint32_t const tfMPTCanEscrow
Definition TxFlags.h:147
ripple::tfMPTRequireAuth
constexpr std::uint32_t const tfMPTRequireAuth
Definition TxFlags.h:146
-
ripple::tfMPTCanMutateRequireAuth
constexpr std::uint32_t const tfMPTCanMutateRequireAuth
Definition TxFlags.h:157
-
ripple::tfMPTSetCanLock
constexpr std::uint32_t const tfMPTSetCanLock
Definition TxFlags.h:180
-
ripple::tfMPTClearRequireAuth
constexpr std::uint32_t const tfMPTClearRequireAuth
Definition TxFlags.h:183
ripple::tfMPTCanLock
constexpr std::uint32_t const tfMPTCanLock
Definition TxFlags.h:145
ripple::tfMPTCanClawback
constexpr std::uint32_t const tfMPTCanClawback
Definition TxFlags.h:150
+
ripple::tmfMPTClearCanTransfer
constexpr std::uint32_t const tmfMPTClearCanTransfer
Definition TxFlags.h:189
ripple::to_currency
bool to_currency(Currency &, std::string const &)
Tries to convert a string to a Currency, returns true on success.
Definition UintTypes.cpp:84
ripple::temBAD_AMOUNT
@ temBAD_AMOUNT
Definition TER.h:89
ripple::temREDUNDANT
@ temREDUNDANT
Definition TER.h:112
diff --git a/TxFlags_8h_source.html b/TxFlags_8h_source.html index f0f740e658..79fac09e4f 100644 --- a/TxFlags_8h_source.html +++ b/TxFlags_8h_source.html @@ -209,17 +209,17 @@ $(document).ready(function() { init_codefold(0); });
153
154// MPTokenIssuanceCreate MutableFlags:
155// Indicating specific fields or flags may be changed after issuance.
-
156constexpr std::uint32_t const tfMPTCanMutateCanLock = lsfMPTCanMutateCanLock;
-
157constexpr std::uint32_t const tfMPTCanMutateRequireAuth = lsfMPTCanMutateRequireAuth;
-
158constexpr std::uint32_t const tfMPTCanMutateCanEscrow = lsfMPTCanMutateCanEscrow;
-
159constexpr std::uint32_t const tfMPTCanMutateCanTrade = lsfMPTCanMutateCanTrade;
-
160constexpr std::uint32_t const tfMPTCanMutateCanTransfer = lsfMPTCanMutateCanTransfer;
-
161constexpr std::uint32_t const tfMPTCanMutateCanClawback = lsfMPTCanMutateCanClawback;
-
162constexpr std::uint32_t const tfMPTCanMutateMetadata = lsfMPTCanMutateMetadata;
-
163constexpr std::uint32_t const tfMPTCanMutateTransferFee = lsfMPTCanMutateTransferFee;
-
164constexpr std::uint32_t const tfMPTokenIssuanceCreateMutableMask =
-
165 ~(tfMPTCanMutateCanLock | tfMPTCanMutateRequireAuth | tfMPTCanMutateCanEscrow | tfMPTCanMutateCanTrade
-
166 | tfMPTCanMutateCanTransfer | tfMPTCanMutateCanClawback | tfMPTCanMutateMetadata | tfMPTCanMutateTransferFee);
+
156constexpr std::uint32_t const tmfMPTCanMutateCanLock = lmfMPTCanMutateCanLock;
+
157constexpr std::uint32_t const tmfMPTCanMutateRequireAuth = lmfMPTCanMutateRequireAuth;
+
158constexpr std::uint32_t const tmfMPTCanMutateCanEscrow = lmfMPTCanMutateCanEscrow;
+
159constexpr std::uint32_t const tmfMPTCanMutateCanTrade = lmfMPTCanMutateCanTrade;
+
160constexpr std::uint32_t const tmfMPTCanMutateCanTransfer = lmfMPTCanMutateCanTransfer;
+
161constexpr std::uint32_t const tmfMPTCanMutateCanClawback = lmfMPTCanMutateCanClawback;
+
162constexpr std::uint32_t const tmfMPTCanMutateMetadata = lmfMPTCanMutateMetadata;
+
163constexpr std::uint32_t const tmfMPTCanMutateTransferFee = lmfMPTCanMutateTransferFee;
+
164constexpr std::uint32_t const tmfMPTokenIssuanceCreateMutableMask =
+
165 ~(tmfMPTCanMutateCanLock | tmfMPTCanMutateRequireAuth | tmfMPTCanMutateCanEscrow | tmfMPTCanMutateCanTrade
+
166 | tmfMPTCanMutateCanTransfer | tmfMPTCanMutateCanClawback | tmfMPTCanMutateMetadata | tmfMPTCanMutateTransferFee);
167
168// MPTokenAuthorize flags:
169constexpr std::uint32_t const tfMPTUnauthorize = 0x00000001;
@@ -233,22 +233,22 @@ $(document).ready(function() { init_codefold(0); });
177
178// MPTokenIssuanceSet MutableFlags:
179// Set or Clear flags.
-
180constexpr std::uint32_t const tfMPTSetCanLock = 0x00000001;
-
181constexpr std::uint32_t const tfMPTClearCanLock = 0x00000002;
-
182constexpr std::uint32_t const tfMPTSetRequireAuth = 0x00000004;
-
183constexpr std::uint32_t const tfMPTClearRequireAuth = 0x00000008;
-
184constexpr std::uint32_t const tfMPTSetCanEscrow = 0x00000010;
-
185constexpr std::uint32_t const tfMPTClearCanEscrow = 0x00000020;
-
186constexpr std::uint32_t const tfMPTSetCanTrade = 0x00000040;
-
187constexpr std::uint32_t const tfMPTClearCanTrade = 0x00000080;
-
188constexpr std::uint32_t const tfMPTSetCanTransfer = 0x00000100;
-
189constexpr std::uint32_t const tfMPTClearCanTransfer = 0x00000200;
-
190constexpr std::uint32_t const tfMPTSetCanClawback = 0x00000400;
-
191constexpr std::uint32_t const tfMPTClearCanClawback = 0x00000800;
-
192constexpr std::uint32_t const tfMPTokenIssuanceSetMutableMask = ~(tfMPTSetCanLock | tfMPTClearCanLock |
-
193 tfMPTSetRequireAuth | tfMPTClearRequireAuth | tfMPTSetCanEscrow | tfMPTClearCanEscrow |
-
194 tfMPTSetCanTrade | tfMPTClearCanTrade | tfMPTSetCanTransfer | tfMPTClearCanTransfer |
-
195 tfMPTSetCanClawback | tfMPTClearCanClawback);
+
180constexpr std::uint32_t const tmfMPTSetCanLock = 0x00000001;
+
181constexpr std::uint32_t const tmfMPTClearCanLock = 0x00000002;
+
182constexpr std::uint32_t const tmfMPTSetRequireAuth = 0x00000004;
+
183constexpr std::uint32_t const tmfMPTClearRequireAuth = 0x00000008;
+
184constexpr std::uint32_t const tmfMPTSetCanEscrow = 0x00000010;
+
185constexpr std::uint32_t const tmfMPTClearCanEscrow = 0x00000020;
+
186constexpr std::uint32_t const tmfMPTSetCanTrade = 0x00000040;
+
187constexpr std::uint32_t const tmfMPTClearCanTrade = 0x00000080;
+
188constexpr std::uint32_t const tmfMPTSetCanTransfer = 0x00000100;
+
189constexpr std::uint32_t const tmfMPTClearCanTransfer = 0x00000200;
+
190constexpr std::uint32_t const tmfMPTSetCanClawback = 0x00000400;
+
191constexpr std::uint32_t const tmfMPTClearCanClawback = 0x00000800;
+
192constexpr std::uint32_t const tmfMPTokenIssuanceSetMutableMask = ~(tmfMPTSetCanLock | tmfMPTClearCanLock |
+
193 tmfMPTSetRequireAuth | tmfMPTClearRequireAuth | tmfMPTSetCanEscrow | tmfMPTClearCanEscrow |
+
194 tmfMPTSetCanTrade | tmfMPTClearCanTrade | tmfMPTSetCanTransfer | tmfMPTClearCanTransfer |
+
195 tmfMPTSetCanClawback | tmfMPTClearCanClawback);
196
197// MPTokenIssuanceDestroy flags:
198constexpr std::uint32_t const tfMPTokenIssuanceDestroyMask = ~tfUniversal;
@@ -349,26 +349,31 @@ $(document).ready(function() { init_codefold(0); });
ripple::tfOneAssetWithdrawAll
constexpr std::uint32_t tfOneAssetWithdrawAll
Definition TxFlags.h:243
ripple::tfBridgeModifyMask
constexpr std::uint32_t tfBridgeModifyMask
Definition TxFlags.h:264
ripple::tfMPTokenIssuanceSetPermissionMask
constexpr std::uint32_t const tfMPTokenIssuanceSetPermissionMask
Definition TxFlags.h:176
+
ripple::tmfMPTClearCanClawback
constexpr std::uint32_t const tmfMPTClearCanClawback
Definition TxFlags.h:191
+
ripple::tmfMPTokenIssuanceSetMutableMask
constexpr std::uint32_t const tmfMPTokenIssuanceSetMutableMask
Definition TxFlags.h:192
+
ripple::tmfMPTCanMutateMetadata
constexpr std::uint32_t const tmfMPTCanMutateMetadata
Definition TxFlags.h:162
ripple::tfBatchMask
constexpr std::uint32_t const tfBatchMask
Definition TxFlags.h:282
+
ripple::tmfMPTClearCanEscrow
constexpr std::uint32_t const tmfMPTClearCanEscrow
Definition TxFlags.h:185
+
ripple::tmfMPTCanMutateCanEscrow
constexpr std::uint32_t const tmfMPTCanMutateCanEscrow
Definition TxFlags.h:158
ripple::asfDepositAuth
constexpr std::uint32_t asfDepositAuth
Definition TxFlags.h:85
ripple::tfOnlyXRP
constexpr std::uint32_t const tfOnlyXRP
Definition TxFlags.h:138
ripple::asfDisallowIncomingNFTokenOffer
constexpr std::uint32_t asfDisallowIncomingNFTokenOffer
Definition TxFlags.h:90
ripple::tfSetDeepFreeze
constexpr std::uint32_t tfSetDeepFreeze
Definition TxFlags.h:120
-
ripple::tfMPTClearCanLock
constexpr std::uint32_t const tfMPTClearCanLock
Definition TxFlags.h:181
+
ripple::tmfMPTCanMutateCanTrade
constexpr std::uint32_t const tmfMPTCanMutateCanTrade
Definition TxFlags.h:159
ripple::asfAllowTrustLineLocking
constexpr std::uint32_t asfAllowTrustLineLocking
Definition TxFlags.h:95
ripple::tfMPTCanTransfer
constexpr std::uint32_t const tfMPTCanTransfer
Definition TxFlags.h:149
+
ripple::tmfMPTSetCanClawback
constexpr std::uint32_t const tmfMPTSetCanClawback
Definition TxFlags.h:190
ripple::tfOnlyOne
constexpr std::uint32_t tfOnlyOne
Definition TxFlags.h:274
-
ripple::tfMPTClearCanEscrow
constexpr std::uint32_t const tfMPTClearCanEscrow
Definition TxFlags.h:185
ripple::asfRequireDest
constexpr std::uint32_t asfRequireDest
Definition TxFlags.h:77
ripple::tfNFTokenCreateOfferMask
constexpr std::uint32_t const tfNFTokenCreateOfferMask
Definition TxFlags.h:228
ripple::tfOfferCreateMask
constexpr std::uint32_t tfOfferCreateMask
Definition TxFlags.h:103
ripple::tfRenew
constexpr std::uint32_t tfRenew
Definition TxFlags.h:132
-
ripple::tfMPTSetRequireAuth
constexpr std::uint32_t const tfMPTSetRequireAuth
Definition TxFlags.h:182
-
ripple::tfMPTCanMutateMetadata
constexpr std::uint32_t const tfMPTCanMutateMetadata
Definition TxFlags.h:162
-
ripple::tfMPTClearCanTransfer
constexpr std::uint32_t const tfMPTClearCanTransfer
Definition TxFlags.h:189
+
ripple::tmfMPTSetRequireAuth
constexpr std::uint32_t const tmfMPTSetRequireAuth
Definition TxFlags.h:182
+
ripple::tmfMPTClearCanTrade
constexpr std::uint32_t const tmfMPTClearCanTrade
Definition TxFlags.h:187
ripple::tfWithdrawMask
constexpr std::uint32_t tfWithdrawMask
Definition TxFlags.h:255
ripple::tfIndependent
constexpr std::uint32_t tfIndependent
Definition TxFlags.h:276
ripple::tfNFTokenMintOldMaskWithMutable
constexpr std::uint32_t const tfNFTokenMintOldMaskWithMutable
Definition TxFlags.h:220
+
ripple::tmfMPTCanMutateTransferFee
constexpr std::uint32_t const tmfMPTCanMutateTransferFee
Definition TxFlags.h:163
ripple::tfMPTPaymentMask
constexpr std::uint32_t tfMPTPaymentMask
Definition TxFlags.h:112
ripple::tfGotMajority
constexpr std::uint32_t tfGotMajority
Definition TxFlags.h:128
ripple::tfMPTCanTrade
constexpr std::uint32_t const tfMPTCanTrade
Definition TxFlags.h:148
@@ -378,81 +383,79 @@ $(document).ready(function() { init_codefold(0); });
ripple::tfSellNFToken
constexpr std::uint32_t const tfSellNFToken
Definition TxFlags.h:227
ripple::tfNFTokenMintMaskWithMutable
constexpr std::uint32_t const tfNFTokenMintMaskWithMutable
Definition TxFlags.h:223
ripple::tfOptionalDestTag
constexpr std::uint32_t tfOptionalDestTag
Definition TxFlags.h:67
-
ripple::tfMPTClearCanTrade
constexpr std::uint32_t const tfMPTClearCanTrade
Definition TxFlags.h:187
-
ripple::tfMPTCanMutateCanEscrow
constexpr std::uint32_t const tfMPTCanMutateCanEscrow
Definition TxFlags.h:158
-
ripple::lsfMPTCanMutateCanLock
@ lsfMPTCanMutateCanLock
Definition LedgerFormats.h:191
-
ripple::lsfMPTCanMutateMetadata
@ lsfMPTCanMutateMetadata
Definition LedgerFormats.h:197
ripple::lsfMPTCanTransfer
@ lsfMPTCanTransfer
Definition LedgerFormats.h:188
ripple::lsfMPTCanEscrow
@ lsfMPTCanEscrow
Definition LedgerFormats.h:186
-
ripple::lsfMPTCanMutateCanClawback
@ lsfMPTCanMutateCanClawback
Definition LedgerFormats.h:196
+
ripple::lmfMPTCanMutateMetadata
@ lmfMPTCanMutateMetadata
Definition LedgerFormats.h:197
ripple::lsfMPTCanClawback
@ lsfMPTCanClawback
Definition LedgerFormats.h:189
+
ripple::lmfMPTCanMutateCanTransfer
@ lmfMPTCanMutateCanTransfer
Definition LedgerFormats.h:195
+
ripple::lmfMPTCanMutateTransferFee
@ lmfMPTCanMutateTransferFee
Definition LedgerFormats.h:198
+
ripple::lmfMPTCanMutateCanClawback
@ lmfMPTCanMutateCanClawback
Definition LedgerFormats.h:196
ripple::lsfVaultPrivate
@ lsfVaultPrivate
Definition LedgerFormats.h:207
-
ripple::lsfMPTCanMutateCanTransfer
@ lsfMPTCanMutateCanTransfer
Definition LedgerFormats.h:195
+
ripple::lmfMPTCanMutateRequireAuth
@ lmfMPTCanMutateRequireAuth
Definition LedgerFormats.h:192
ripple::lsfMPTRequireAuth
@ lsfMPTRequireAuth
Definition LedgerFormats.h:185
-
ripple::lsfMPTCanMutateCanEscrow
@ lsfMPTCanMutateCanEscrow
Definition LedgerFormats.h:193
-
ripple::lsfMPTCanMutateCanTrade
@ lsfMPTCanMutateCanTrade
Definition LedgerFormats.h:194
-
ripple::lsfMPTCanMutateRequireAuth
@ lsfMPTCanMutateRequireAuth
Definition LedgerFormats.h:192
-
ripple::lsfMPTCanMutateTransferFee
@ lsfMPTCanMutateTransferFee
Definition LedgerFormats.h:198
+
ripple::lmfMPTCanMutateCanLock
@ lmfMPTCanMutateCanLock
Definition LedgerFormats.h:191
+
ripple::lmfMPTCanMutateCanEscrow
@ lmfMPTCanMutateCanEscrow
Definition LedgerFormats.h:193
+
ripple::lmfMPTCanMutateCanTrade
@ lmfMPTCanMutateCanTrade
Definition LedgerFormats.h:194
ripple::tfMPTokenIssuanceCreateMask
constexpr std::uint32_t const tfMPTokenIssuanceCreateMask
Definition TxFlags.h:151
ripple::tfAccountSetMask
constexpr std::uint32_t tfAccountSetMask
Definition TxFlags.h:72
ripple::tfNFTokenMintOldMask
constexpr std::uint32_t const tfNFTokenMintOldMask
Definition TxFlags.h:216
+
ripple::tmfMPTClearRequireAuth
constexpr std::uint32_t const tmfMPTClearRequireAuth
Definition TxFlags.h:183
+
ripple::tmfMPTSetCanLock
constexpr std::uint32_t const tmfMPTSetCanLock
Definition TxFlags.h:180
ripple::tfRequireDestTag
constexpr std::uint32_t tfRequireDestTag
Definition TxFlags.h:66
ripple::tfVaultPrivate
constexpr std::uint32_t const tfVaultPrivate
Definition TxFlags.h:267
ripple::tfLimitLPToken
constexpr std::uint32_t tfLimitLPToken
Definition TxFlags.h:247
+
ripple::tmfMPTCanMutateCanLock
constexpr std::uint32_t const tmfMPTCanMutateCanLock
Definition TxFlags.h:156
ripple::tfMPTokenAuthorizeMask
constexpr std::uint32_t const tfMPTokenAuthorizeMask
Definition TxFlags.h:170
ripple::tfHybrid
constexpr std::uint32_t tfHybrid
Definition TxFlags.h:102
ripple::tfClawTwoAssets
constexpr std::uint32_t tfClawTwoAssets
Definition TxFlags.h:259
+
ripple::tmfMPTokenIssuanceCreateMutableMask
constexpr std::uint32_t const tmfMPTokenIssuanceCreateMutableMask
Definition TxFlags.h:164
ripple::tfBurnable
constexpr std::uint32_t const tfBurnable
Definition TxFlags.h:137
-
ripple::tfMPTCanMutateCanLock
constexpr std::uint32_t const tfMPTCanMutateCanLock
Definition TxFlags.h:156
ripple::asfNoFreeze
constexpr std::uint32_t asfNoFreeze
Definition TxFlags.h:82
ripple::tfFillOrKill
constexpr std::uint32_t tfFillOrKill
Definition TxFlags.h:100
-
ripple::tfMPTSetCanTransfer
constexpr std::uint32_t const tfMPTSetCanTransfer
Definition TxFlags.h:188
ripple::tfPassive
constexpr std::uint32_t tfPassive
Definition TxFlags.h:98
ripple::tfOneAssetLPToken
constexpr std::uint32_t tfOneAssetLPToken
Definition TxFlags.h:246
ripple::tfImmediateOrCancel
constexpr std::uint32_t tfImmediateOrCancel
Definition TxFlags.h:99
-
ripple::tfMPTSetCanEscrow
constexpr std::uint32_t const tfMPTSetCanEscrow
Definition TxFlags.h:184
+
ripple::tmfMPTSetCanTrade
constexpr std::uint32_t const tmfMPTSetCanTrade
Definition TxFlags.h:186
ripple::asfDisableMaster
constexpr std::uint32_t asfDisableMaster
Definition TxFlags.h:80
-
ripple::tfMPTCanMutateCanTransfer
constexpr std::uint32_t const tfMPTCanMutateCanTransfer
Definition TxFlags.h:160
-
ripple::tfMPTCanMutateTransferFee
constexpr std::uint32_t const tfMPTCanMutateTransferFee
Definition TxFlags.h:163
+
ripple::tmfMPTCanMutateCanClawback
constexpr std::uint32_t const tmfMPTCanMutateCanClawback
Definition TxFlags.h:161
ripple::asfDisallowIncomingTrustline
constexpr std::uint32_t asfDisallowIncomingTrustline
Definition TxFlags.h:93
ripple::tfTrustSetPermissionMask
constexpr std::uint32_t tfTrustSetPermissionMask
Definition TxFlags.h:125
ripple::tfTwoAsset
constexpr std::uint32_t tfTwoAsset
Definition TxFlags.h:245
ripple::tfAMMClawbackMask
constexpr std::uint32_t tfAMMClawbackMask
Definition TxFlags.h:260
-
ripple::tfMPTCanMutateCanTrade
constexpr std::uint32_t const tfMPTCanMutateCanTrade
Definition TxFlags.h:159
ripple::tfUntilFailure
constexpr std::uint32_t tfUntilFailure
Definition TxFlags.h:275
ripple::tfPartialPayment
constexpr std::uint32_t tfPartialPayment
Definition TxFlags.h:108
ripple::tfTrustLine
constexpr std::uint32_t const tfTrustLine
Definition TxFlags.h:139
ripple::tfWithdrawAll
constexpr std::uint32_t tfWithdrawAll
Definition TxFlags.h:242
-
ripple::tfMPTSetCanTrade
constexpr std::uint32_t const tfMPTSetCanTrade
Definition TxFlags.h:186
ripple::tfClearNoRipple
constexpr std::uint32_t tfClearNoRipple
Definition TxFlags.h:117
ripple::tfMPTUnauthorize
constexpr std::uint32_t const tfMPTUnauthorize
Definition TxFlags.h:169
ripple::tfDepositSubTx
constexpr std::uint32_t tfDepositSubTx
Definition TxFlags.h:252
-
ripple::tfMPTSetCanClawback
constexpr std::uint32_t const tfMPTSetCanClawback
Definition TxFlags.h:190
+
ripple::tmfMPTSetCanEscrow
constexpr std::uint32_t const tmfMPTSetCanEscrow
Definition TxFlags.h:184
+
ripple::tmfMPTClearCanLock
constexpr std::uint32_t const tmfMPTClearCanLock
Definition TxFlags.h:181
ripple::tfClearAccountCreateAmount
constexpr std::uint32_t tfClearAccountCreateAmount
Definition TxFlags.h:263
ripple::tfSetfAuth
constexpr std::uint32_t tfSetfAuth
Definition TxFlags.h:115
ripple::asfAccountTxnID
constexpr std::uint32_t asfAccountTxnID
Definition TxFlags.h:81
ripple::asfDefaultRipple
constexpr std::uint32_t asfDefaultRipple
Definition TxFlags.h:84
ripple::asfDisallowIncomingCheck
constexpr std::uint32_t asfDisallowIncomingCheck
Definition TxFlags.h:91
ripple::tfClearFreeze
constexpr std::uint32_t tfClearFreeze
Definition TxFlags.h:119
-
ripple::tfMPTClearCanClawback
constexpr std::uint32_t const tfMPTClearCanClawback
Definition TxFlags.h:191
+
ripple::tmfMPTSetCanTransfer
constexpr std::uint32_t const tmfMPTSetCanTransfer
Definition TxFlags.h:188
ripple::tfRequireAuth
constexpr std::uint32_t tfRequireAuth
Definition TxFlags.h:68
ripple::tfMPTLock
constexpr std::uint32_t const tfMPTLock
Definition TxFlags.h:173
ripple::tfLPToken
constexpr std::uint32_t tfLPToken
Definition TxFlags.h:241
ripple::tfUniversal
constexpr std::uint32_t tfUniversal
Definition TxFlags.h:62
ripple::tfNoRippleDirect
constexpr std::uint32_t tfNoRippleDirect
Definition TxFlags.h:107
+
ripple::tmfMPTCanMutateRequireAuth
constexpr std::uint32_t const tmfMPTCanMutateRequireAuth
Definition TxFlags.h:157
ripple::tfOptionalAuth
constexpr std::uint32_t tfOptionalAuth
Definition TxFlags.h:69
ripple::tfVaultShareNonTransferable
constexpr std::uint32_t const tfVaultShareNonTransferable
Definition TxFlags.h:269
ripple::tfClearDeepFreeze
constexpr std::uint32_t tfClearDeepFreeze
Definition TxFlags.h:121
ripple::tfDisallowXRP
constexpr std::uint32_t tfDisallowXRP
Definition TxFlags.h:70
ripple::tfNFTokenCancelOfferMask
constexpr std::uint32_t const tfNFTokenCancelOfferMask
Definition TxFlags.h:232
ripple::tfDepositMask
constexpr std::uint32_t tfDepositMask
Definition TxFlags.h:256
+
ripple::tmfMPTCanMutateCanTransfer
constexpr std::uint32_t const tmfMPTCanMutateCanTransfer
Definition TxFlags.h:160
ripple::tfWithdrawSubTx
constexpr std::uint32_t tfWithdrawSubTx
Definition TxFlags.h:249
ripple::tfPaymentMask
constexpr std::uint32_t tfPaymentMask
Definition TxFlags.h:110
ripple::tfLimitQuality
constexpr std::uint32_t tfLimitQuality
Definition TxFlags.h:109
-
ripple::tfMPTCanMutateCanClawback
constexpr std::uint32_t const tfMPTCanMutateCanClawback
Definition TxFlags.h:161
-
ripple::tfMPTokenIssuanceSetMutableMask
constexpr std::uint32_t const tfMPTokenIssuanceSetMutableMask
Definition TxFlags.h:192
ripple::tfTrustSetMask
constexpr std::uint32_t tfTrustSetMask
Definition TxFlags.h:122
ripple::asfDisallowIncomingPayChan
constexpr std::uint32_t asfDisallowIncomingPayChan
Definition TxFlags.h:92
ripple::tfClose
constexpr std::uint32_t tfClose
Definition TxFlags.h:133
@@ -469,14 +472,11 @@ $(document).ready(function() { init_codefold(0); });
ripple::tfMPTRequireAuth
constexpr std::uint32_t const tfMPTRequireAuth
Definition TxFlags.h:146
ripple::tfSetFreeze
constexpr std::uint32_t tfSetFreeze
Definition TxFlags.h:118
ripple::tfSetNoRipple
constexpr std::uint32_t tfSetNoRipple
Definition TxFlags.h:116
-
ripple::tfMPTCanMutateRequireAuth
constexpr std::uint32_t const tfMPTCanMutateRequireAuth
Definition TxFlags.h:157
ripple::tfVaultCreateMask
constexpr std::uint32_t const tfVaultCreateMask
Definition TxFlags.h:270
-
ripple::tfMPTSetCanLock
constexpr std::uint32_t const tfMPTSetCanLock
Definition TxFlags.h:180
ripple::tfMutable
constexpr std::uint32_t const tfMutable
Definition TxFlags.h:141
-
ripple::tfMPTokenIssuanceCreateMutableMask
constexpr std::uint32_t const tfMPTokenIssuanceCreateMutableMask
Definition TxFlags.h:164
-
ripple::tfMPTClearRequireAuth
constexpr std::uint32_t const tfMPTClearRequireAuth
Definition TxFlags.h:183
ripple::tfMPTCanLock
constexpr std::uint32_t const tfMPTCanLock
Definition TxFlags.h:145
ripple::tfMPTCanClawback
constexpr std::uint32_t const tfMPTCanClawback
Definition TxFlags.h:150
+
ripple::tmfMPTClearCanTransfer
constexpr std::uint32_t const tmfMPTClearCanTransfer
Definition TxFlags.h:189
ripple::tfTransferable
constexpr std::uint32_t const tfTransferable
Definition TxFlags.h:140
ripple::tfNFTokenMintMask
constexpr std::uint32_t const tfNFTokenMintMask
Definition TxFlags.h:213
ripple::asfDisallowXRP
constexpr std::uint32_t asfDisallowXRP
Definition TxFlags.h:79
diff --git a/classripple_1_1MPTokenIssuanceSet.html b/classripple_1_1MPTokenIssuanceSet.html index b796280dea..b5581dd7b8 100644 --- a/classripple_1_1MPTokenIssuanceSet.html +++ b/classripple_1_1MPTokenIssuanceSet.html @@ -405,7 +405,7 @@ Static Private Member Functions
-

Definition at line 48 of file MPTokenIssuanceSet.cpp.

+

Definition at line 50 of file MPTokenIssuanceSet.cpp.

@@ -443,7 +443,7 @@ Static Private Member Functions
-

Definition at line 138 of file MPTokenIssuanceSet.cpp.

+

Definition at line 140 of file MPTokenIssuanceSet.cpp.

@@ -471,7 +471,7 @@ Static Private Member Functions
-

Definition at line 175 of file MPTokenIssuanceSet.cpp.

+

Definition at line 177 of file MPTokenIssuanceSet.cpp.

@@ -500,7 +500,7 @@ Static Private Member Functions

Implements ripple::Transactor.

-

Definition at line 265 of file MPTokenIssuanceSet.cpp.

+

Definition at line 267 of file MPTokenIssuanceSet.cpp.

diff --git a/classripple_1_1test_1_1MPToken__test.html b/classripple_1_1test_1_1MPToken__test.html index b878a1e586..f950b19113 100644 --- a/classripple_1_1test_1_1MPToken__test.html +++ b/classripple_1_1test_1_1MPToken__test.html @@ -844,7 +844,7 @@ Private Attributes
-

Definition at line 3276 of file MPToken_test.cpp.

+

Definition at line 3278 of file MPToken_test.cpp.

@@ -872,7 +872,7 @@ Private Attributes
-

Definition at line 3390 of file MPToken_test.cpp.

+

Definition at line 3397 of file MPToken_test.cpp.

@@ -900,7 +900,7 @@ Private Attributes
-

Definition at line 3438 of file MPToken_test.cpp.

+

Definition at line 3446 of file MPToken_test.cpp.

@@ -928,7 +928,7 @@ Private Attributes
-

Definition at line 3488 of file MPToken_test.cpp.

+

Definition at line 3496 of file MPToken_test.cpp.

@@ -956,7 +956,7 @@ Private Attributes
-

Definition at line 3581 of file MPToken_test.cpp.

+

Definition at line 3589 of file MPToken_test.cpp.

@@ -987,7 +987,7 @@ Private Attributes

Implements beast::unit_test::suite.

-

Definition at line 3621 of file MPToken_test.cpp.

+

Definition at line 3630 of file MPToken_test.cpp.

diff --git a/mpt_8cpp_source.html b/mpt_8cpp_source.html index 3a50a2a9e9..d10f6cfd95 100644 --- a/mpt_8cpp_source.html +++ b/mpt_8cpp_source.html @@ -367,34 +367,34 @@ $(document).ready(function() { init_codefold(0); });
265
266 if (arg.mutableFlags)
267 {
-
268 if (*arg.mutableFlags & tfMPTSetCanLock)
+
268 if (*arg.mutableFlags & tmfMPTSetCanLock)
269 flags |= lsfMPTCanLock;
-
270 else if (*arg.mutableFlags & tfMPTClearCanLock)
+
270 else if (*arg.mutableFlags & tmfMPTClearCanLock)
271 flags &= ~lsfMPTCanLock;
272
-
273 if (*arg.mutableFlags & tfMPTSetRequireAuth)
+
273 if (*arg.mutableFlags & tmfMPTSetRequireAuth)
274 flags |= lsfMPTRequireAuth;
-
275 else if (*arg.mutableFlags & tfMPTClearRequireAuth)
+
275 else if (*arg.mutableFlags & tmfMPTClearRequireAuth)
276 flags &= ~lsfMPTRequireAuth;
277
-
278 if (*arg.mutableFlags & tfMPTSetCanEscrow)
+
278 if (*arg.mutableFlags & tmfMPTSetCanEscrow)
279 flags |= lsfMPTCanEscrow;
-
280 else if (*arg.mutableFlags & tfMPTClearCanEscrow)
+
280 else if (*arg.mutableFlags & tmfMPTClearCanEscrow)
281 flags &= ~lsfMPTCanEscrow;
282
-
283 if (*arg.mutableFlags & tfMPTSetCanClawback)
+
283 if (*arg.mutableFlags & tmfMPTSetCanClawback)
284 flags |= lsfMPTCanClawback;
-
285 else if (*arg.mutableFlags & tfMPTClearCanClawback)
+
285 else if (*arg.mutableFlags & tmfMPTClearCanClawback)
286 flags &= ~lsfMPTCanClawback;
287
-
288 if (*arg.mutableFlags & tfMPTSetCanTrade)
+
288 if (*arg.mutableFlags & tmfMPTSetCanTrade)
289 flags |= lsfMPTCanTrade;
-
290 else if (*arg.mutableFlags & tfMPTClearCanTrade)
+
290 else if (*arg.mutableFlags & tmfMPTClearCanTrade)
291 flags &= ~lsfMPTCanTrade;
292
-
293 if (*arg.mutableFlags & tfMPTSetCanTransfer)
+
293 if (*arg.mutableFlags & tmfMPTSetCanTransfer)
294 flags |= lsfMPTCanTransfer;
-
295 else if (*arg.mutableFlags & tfMPTClearCanTransfer)
+
295 else if (*arg.mutableFlags & tmfMPTClearCanTransfer)
296 flags &= ~lsfMPTCanTransfer;
297 }
298 }
@@ -728,13 +728,13 @@ $(document).ready(function() { init_codefold(0); });
ripple::test::jtx::claw
Json::Value claw(Account const &account, STAmount const &amount, std::optional< Account > const &mptHolder)
Definition trust.cpp:69
ripple::test::jtx::pay
Json::Value pay(AccountID const &account, AccountID const &to, AnyAmount amount)
Create a payment.
Definition pay.cpp:30
ripple
Use hash_* containers for keys that do not need a cryptographically secure hashing algorithm.
Definition algorithm.h:25
-
ripple::tfMPTClearCanLock
constexpr std::uint32_t const tfMPTClearCanLock
Definition TxFlags.h:181
-
ripple::tfMPTClearCanEscrow
constexpr std::uint32_t const tfMPTClearCanEscrow
Definition TxFlags.h:185
-
ripple::tfMPTSetRequireAuth
constexpr std::uint32_t const tfMPTSetRequireAuth
Definition TxFlags.h:182
-
ripple::tfMPTClearCanTransfer
constexpr std::uint32_t const tfMPTClearCanTransfer
Definition TxFlags.h:189
+
ripple::tmfMPTClearCanClawback
constexpr std::uint32_t const tmfMPTClearCanClawback
Definition TxFlags.h:191
+
ripple::tmfMPTClearCanEscrow
constexpr std::uint32_t const tmfMPTClearCanEscrow
Definition TxFlags.h:185
+
ripple::tmfMPTSetCanClawback
constexpr std::uint32_t const tmfMPTSetCanClawback
Definition TxFlags.h:190
+
ripple::tmfMPTSetRequireAuth
constexpr std::uint32_t const tmfMPTSetRequireAuth
Definition TxFlags.h:182
+
ripple::tmfMPTClearCanTrade
constexpr std::uint32_t const tmfMPTClearCanTrade
Definition TxFlags.h:187
ripple::transferRate
Rate transferRate(ReadView const &view, AccountID const &issuer)
Returns IOU issuer transfer fee as Rate.
Definition View.cpp:760
ripple::tfMPTUnlock
constexpr std::uint32_t const tfMPTUnlock
Definition TxFlags.h:174
-
ripple::tfMPTClearCanTrade
constexpr std::uint32_t const tfMPTClearCanTrade
Definition TxFlags.h:187
ripple::lsfMPTCanTransfer
@ lsfMPTCanTransfer
Definition LedgerFormats.h:188
ripple::lsfMPTCanTrade
@ lsfMPTCanTrade
Definition LedgerFormats.h:187
ripple::lsfMPTCanEscrow
@ lsfMPTCanEscrow
Definition LedgerFormats.h:186
@@ -743,21 +743,21 @@ $(document).ready(function() { init_codefold(0); });
ripple::lsfMPTRequireAuth
@ lsfMPTRequireAuth
Definition LedgerFormats.h:185
ripple::lsfMPTAuthorized
@ lsfMPTAuthorized
Definition LedgerFormats.h:201
ripple::lsfMPTLocked
@ lsfMPTLocked
Definition LedgerFormats.h:183
+
ripple::tmfMPTClearRequireAuth
constexpr std::uint32_t const tmfMPTClearRequireAuth
Definition TxFlags.h:183
+
ripple::tmfMPTSetCanLock
constexpr std::uint32_t const tmfMPTSetCanLock
Definition TxFlags.h:180
ripple::multiply
STAmount multiply(STAmount const &amount, Rate const &rate)
Definition Rate2.cpp:53
-
ripple::tfMPTSetCanTransfer
constexpr std::uint32_t const tfMPTSetCanTransfer
Definition TxFlags.h:188
-
ripple::tfMPTSetCanEscrow
constexpr std::uint32_t const tfMPTSetCanEscrow
Definition TxFlags.h:184
-
ripple::tfMPTSetCanTrade
constexpr std::uint32_t const tfMPTSetCanTrade
Definition TxFlags.h:186
+
ripple::tmfMPTSetCanTrade
constexpr std::uint32_t const tmfMPTSetCanTrade
Definition TxFlags.h:186
ripple::strHex
std::string strHex(FwdIt begin, FwdIt end)
Definition strHex.h:30
ripple::tfMPTUnauthorize
constexpr std::uint32_t const tfMPTUnauthorize
Definition TxFlags.h:169
-
ripple::tfMPTSetCanClawback
constexpr std::uint32_t const tfMPTSetCanClawback
Definition TxFlags.h:190
-
ripple::tfMPTClearCanClawback
constexpr std::uint32_t const tfMPTClearCanClawback
Definition TxFlags.h:191
+
ripple::tmfMPTSetCanEscrow
constexpr std::uint32_t const tmfMPTSetCanEscrow
Definition TxFlags.h:184
+
ripple::tmfMPTClearCanLock
constexpr std::uint32_t const tmfMPTClearCanLock
Definition TxFlags.h:181
+
ripple::tmfMPTSetCanTransfer
constexpr std::uint32_t const tmfMPTSetCanTransfer
Definition TxFlags.h:188
ripple::tecDUPLICATE
@ tecDUPLICATE
Definition TER.h:315
ripple::tfMPTLock
constexpr std::uint32_t const tfMPTLock
Definition TxFlags.h:173
ripple::tesSUCCESS
@ tesSUCCESS
Definition TER.h:244
ripple::to_string
std::string to_string(base_uint< Bits, Tag > const &a)
Definition base_uint.h:630
ripple::makeMptID
MPTID makeMptID(std::uint32_t sequence, AccountID const &account)
Definition Indexes.cpp:170
-
ripple::tfMPTSetCanLock
constexpr std::uint32_t const tfMPTSetCanLock
Definition TxFlags.h:180
-
ripple::tfMPTClearRequireAuth
constexpr std::uint32_t const tfMPTClearRequireAuth
Definition TxFlags.h:183
+
ripple::tmfMPTClearCanTransfer
constexpr std::uint32_t const tmfMPTClearCanTransfer
Definition TxFlags.h:189
std::optional::has_value
T has_value(T... args)
std::optional
std::shared_ptr
diff --git a/namespacemembers_eval_l.html b/namespacemembers_eval_l.html index ced626116e..825a45fa9b 100644 --- a/namespacemembers_eval_l.html +++ b/namespacemembers_eval_l.html @@ -74,6 +74,14 @@ $(function() {

- l -